# Anthropic's developer doctrine in fifteen videos and a panel

URL: https://www.thedeepfeed.ai/posts/2026-05-02-anthropic-developers-playlist/
Category: Agents
Published: 2026-05-15
Author: the-deep-feed
Tags: anthropic, claude-code, agents, mcp, prompt-engineering
Kind: deep

> The Developers playlist is Anthropic's public lecture series for builders. Read against Building Effective Agents, MCP, and Claude Code, the canon hangs together. Here is what it argues.

## TL;DR

- The **Anthropic Developers playlist** (15 videos, 1.5M+ cumulative views) is the closest thing the company has to a public lecture series for builders. The two anchor talks each cleared **560K views**: *Tips for building AI agents* and *AI prompt engineering: A deep dive*.
- The canon coheres around six positions: **agent ≠ chatbot**, **simplicity beats frameworks**, **tools are the bottleneck not prompts**, **validation environment beats model intelligence**, **build for the model six months from now**, **the harness is part of the product**.
- **MCP is the open-protocol bet.** David Soria Parra's talk re-positions the protocol after the **Dec 9 2025 donation to the Linux Foundation** (Agentic AI Foundation). One year in: 97M monthly SDK downloads, 10K+ active servers.
- **Boris Cherny's Claude Code thesis** carries three of the playlist's most-viewed talks. Anthropic claims a **150% productivity lift** internally (PRs per engineer). The framework Cherny built started as a throwaway terminal experiment and now defines the IDE-vs-terminal debate.
- The seven cross-cutting builder lessons — workflow vs agent distinction, empathetic prompt engineering, artifact-pattern multi-agent, end-state eval, model-of-the-future design, terminal-as-IDE, open protocols — are the actionable takeaway. Together they form a doctrine that explains why Anthropic ships the way it does.

![A long shelf of fifteen lecture-card spines stacked horizontally, each labeled by topic, with one in editorial red marking the canonical talk](/post-images/2026-05-02-anthropic-developers-playlist/hero-canon-shelf.jpg)

Anthropic does not run a developer conference. The team has no annual keynote, no roadmap event, no equivalent of OpenAI DevDay or Google I/O. What it has instead is a YouTube channel and a slow-cadence publishing rhythm that, over the last fifteen months, has produced something close to a public lecture series for builders. The channel calls it *Developers* — a fifteen-video playlist that opens with a David Soria Parra talk on why the team built and donated the Model Context Protocol, runs through Boris Cherny on the future of agentic coding, and closes on roundtables featuring Erik Schluntz, Barry Zhang, Amanda Askell, and Alex Albert.

The two anchor videos in the playlist have each cleared **560,000 views**: *Tips for building AI agents* (568K) from February 2025 and *AI prompt engineering: A deep dive* (561K) from earlier that year. Cumulative views across the playlist sit at over [1.5 million](https://www.youtube.com/playlist?list=PLf2m23nhTg1PBzCb-nOGFH6NFYSkkVuZ5). The series is not a marketing reel. Read against Anthropic's published written canon (the *Building Effective Agents* paper, the multi-agent research system writeup, the Claude Code best-practices doc, the MCP donation post), the videos are the company's developer doctrine in oral form. The talks are deliberately conservative, the speakers are the engineers who built the systems they describe, and the arguments hang together as a single coherent position.

This piece is a structural reading of what the playlist as a whole is arguing — what the doctrine commits to, where it dissents from the prevailing AI-agent discourse, who the recurring voices are, and what builders should take from it.

# The fifteen videos, mapped

| # | Title | Length | Views | Anchor speakers |
|---|---|---|---|---|
| 1 | [Why we built—and donated—the Model Context Protocol (MCP)](https://www.youtube.com/watch?v=PLyCki2K0Lg) | 35:32 | 31K | David Soria Parra |
| 2 | [Claude Code updates: When to use Haiku 4.5, Claude Code on web, and more](https://www.youtube.com/watch?v=CBneTpXF1CQ) | 5:15 | — | Update reel |
| 3 | [Building more effective AI agents](https://www.youtube.com/watch?v=uhJJgc-0iTQ) | 18:58 | 80K | Alex Albert, Erik Schluntz |
| 4 | [Building with MCP and the Claude API](https://www.youtube.com/watch?v=aZLr962R6Ag) | — | — | API + MCP integration |
| 5 | [Building the future of agents with Claude](https://www.youtube.com/watch?v=XuvKFsktX0Q) | — | — | Vision talk |
| 6 | [Designing Claude Code](https://www.youtube.com/watch?v=vLIDHi-1PVU) | 12:03 | 44K | Meaghan Choi, Alex Albert |
| 7 | [The future of agentic coding with Claude Code](https://www.youtube.com/watch?v=iF9iV4xponk) | 20:20 | **147K** | Boris Cherny, Alex Albert |
| 8 | [Building and prototyping with Claude Code](https://www.youtube.com/watch?v=DAQJvGjlgVM) | — | — | Prototyping primer |
| 9 | [The Model Context Protocol (MCP)](https://www.youtube.com/watch?v=CQywdSdi5iA) | — | — | MCP architecture |
| 10 | [How Cursor is building the future of AI coding with Claude](https://www.youtube.com/watch?v=BGgsoIgbT_Y) | — | — | Cursor x Anthropic |
| 11 | [A conversation on Claude Code](https://www.youtube.com/watch?v=Yf_1w00qIKc) | — | — | Founders' chat |
| 12/13 | [Lessons on AI agents from Claude Plays Pokémon](https://www.youtube.com/watch?v=CXhYDOvgpuU) | 44:50 | 21K | David Hershey, Alex Albert |
| 14 | [Tips for building AI agents](https://www.youtube.com/watch?v=LP5OCa20Zpg) | 18:19 | **568K** | Erik Schluntz, Barry Zhang, Alex Albert |
| 15 | [AI prompt engineering: A deep dive](https://www.youtube.com/watch?v=T9aRN5JkmL8) | ~75:00 | **561K** | Amanda Askell, David Hershey, Zack Witten, Alex Albert |

The publication rhythm runs from early 2024 (the prompt-engineering panel predates the others) through January 2026 (Soria Parra's MCP retrospective filmed shortly after the Linux Foundation donation). The cadence is roughly one video a month. The two seven-figure-view panels are both moderated by Alex Albert, head of Claude Relations. The single most-viewed talk by a builder rather than a panel is Boris Cherny's *Future of agentic coding* at 147K. The lowest-viewed substantive talk is *Lessons on AI agents from Claude Plays Pokémon* at 21K, which is also the talk most explicitly about Anthropic's open research bets.

# The recurring cast

A small group carries the playlist. Six recurring speakers, two of them on screen for nearly half the videos.

| Speaker | Role | What they own in the canon |
|---|---|---|
| **Alex Albert** | Head of Claude Relations | Hosts every panel. Was a prompt engineer before. The interviewer who asks the architecture questions. |
| **Erik Schluntz** | Multi-Agent Research | Co-author of *Building Effective Agents* (Dec 2024). The single most-quoted source on the workflow-vs-agent distinction. |
| **Barry Zhang** | Applied AI | Co-author with Schluntz. Gave the canonical *How We Build Effective Agents* talk at the AI Engineer World's Fair. |
| **Boris Cherny** | Creator, Claude Code | Three videos in the playlist. Ex-Meta principal, author of *Programming TypeScript*. The most public face of Anthropic's developer-tools work. |
| **David Hershey** | Applied AI | Lead on Claude Plays Pokémon. Anthropic's voice on agent eval. |
| **David Soria Parra** | MCP co-creator | Owns the protocol post-donation. Anthropic's voice on open-standard governance. |
| **Amanda Askell** | Philosopher / character | Carries the prompt-engineering canon. Designs the Claude.ai persona. |

Two structural points worth noticing. First, none of these are leadership cameos — every recurring speaker is an engineer or researcher who built the system they are describing. Second, Anthropic is publishing the same doctrine multiple ways: Schluntz and Zhang published the *Building Effective Agents* paper in December 2024, then sat down for the *Tips for building AI agents* panel two months later, then Schluntz appeared again on *Building more effective AI agents* in October 2025 to update the framework after another six months of customer work. Watching the playlist in order is reading the same paper getting refined three times in front of a camera.

![An editorial collage of seven labeled portrait silhouettes connected by a central node, showing the cast of recurring speakers across the playlist](/post-images/2026-05-02-anthropic-developers-playlist/recurring-cast.jpg)

# The canon, in six positions

The doctrine across the playlist comes down to six positions, each of which shows up explicitly in at least three videos.

# 1. Agent ≠ chatbot. Agent ≈ workflow with dynamism.

The Schluntz-Zhang frame is the playlist's foundational argument. The pair distinguishes two architectures inside *agentic systems*: **workflows** (LLMs and tools orchestrated through predefined code paths) and **agents** (LLMs dynamically directing their own processes and tool use). The *Tips for building AI agents* panel, watched 568,000 times, opens by re-stating this distinction and then spending most of its 18 minutes arguing that current consumer "AI agent" products are mostly workflows being mislabeled. Schluntz and Zhang are direct: most successful production deployments are workflows, not agents. The cases where agents (in their stricter sense) actually win are narrow.

The followup video, [*Building more effective AI agents*](https://www.youtube.com/watch?v=uhJJgc-0iTQ), refines the frame with a year of production data. Six patterns crystallize as the most common workflows: prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, and the autonomous-loop agent. The doctrine is that you should reach for the simplest pattern your task allows — start with a single LLM call plus retrieval, escalate to a workflow only when needed, and only build a true autonomous agent when the task demands flexibility no predefined path can offer.

# 2. Simplicity beats frameworks.

The most-cited line from the *Building Effective Agents* post is the one from its first paragraph: *["Consistently, the most successful implementations weren't using complex frameworks or specialized libraries. Instead, they were building with simple, composable patterns."](https://www.anthropic.com/index/building-effective-agents)* This is repeated in the panel video almost verbatim. It is also the position that separates Anthropic's developer doctrine from most of the agent-framework category — LangChain, CrewAI, AutoGen, even the company's own [Claude Agent SDK](https://platform.claude.com/docs/en/agent-sdk/overview), which Anthropic describes in the post as appropriate only when its abstractions match your needs.

The corollary in the Claude Code talks is that simple loops compose better than orchestration DSLs. Boris Cherny's framing is that Claude Code is not a framework; it is a TUI shell over a small set of primitives (read, write, edit, bash, grep, glob, task) plus a markdown skill format. The reason Cursor, Continue, Aider, and Codex have all converged toward the same shape is not framework adoption; it is convergent evolution against a stable underlying problem.

# 3. Tools are the bottleneck, not prompts.

Erik Schluntz's [single most-shared clip from Anthropic](https://www.youtube.com/watch?v=SO43O_7jqzk), a 45-second video titled *The Most Common Mistake People Make When Building AI Agents*, distils the position into one sentence: *"People will put a lot of effort into creating these really beautiful detailed prompts and then the tools that they make to give the model are subpar."*

The doctrine is that tool descriptions, parameter schemas, error messages, and output formats are first-class artifacts that deserve as much engineering attention as the system prompt. The *Tips for building AI agents* panel calls this **empathetic prompt engineering** — designing the tool surface from the model's perspective. When the model gets stuck, the question to ask first is not "is my prompt unclear" but "is my tool's response unclear."

This is the single highest-impact idea in the canon for non-Anthropic builders, because most teams under-invest in tool design. A model with great prompts and bad tools will fail in ways that look like prompt failures. A model with mediocre prompts and great tools will quietly succeed.

# 4. Validation environment beats model intelligence.

The argument that runs through both *Tips for building AI agents* and *Lessons on AI agents from Claude Plays Pokémon* is that agent reliability is bounded by the cost and quality of validating the output, not by the smartness of the model. Coding agents work because unit tests are cheap to run and produce binary truth. Research agents work because Anthropic's [multi-agent research system writeup](https://www.anthropic.com/engineering/multi-agent-research-system) describes end-state evaluation, where the lead agent compares the artifact a subagent produced against the original goal. Pokémon works as an eval because the game's state is fully observable and discrete.

The corollary, made explicit in the Schluntz-Zhang panel: consumer "agents" like vacation booking are bad not because the models lack capability, but because verification is as expensive as the task itself. If checking the agent's work takes the same time as doing the work yourself, the agent has saved nothing. The right consumer agent surfaces are the ones where verification is dramatically cheaper than execution, which is most code, much research, and almost no general-purpose assistant work.

![A diagram showing two parallel agent loops: a coding agent with a tight unit-test feedback cycle on the right, and a vacation-booking agent with an expensive human-verification cycle on the left, with the right side highlighted in editorial red](/post-images/2026-05-02-anthropic-developers-playlist/validation-environment.jpg)

# 5. Build for the model six months from now.

Boris Cherny's mantra, repeated across the [*Future of agentic coding with Claude Code*](https://www.youtube.com/watch?v=iF9iV4xponk) talk and the [Pragmatic Engineer interview](https://www.youtube.com/watch?v=julbw1JuAz0), is that the only durable design decision is the one that gets out of the way of model improvement. Claude Code's first version was a throwaway terminal experiment Cherny built to learn the Anthropic API; he describes it on YC's Lightcone as an [accidental product](https://www.youtube.com/watch?v=PQU9o_5rHC4). The infrastructure that survived was the bash tool, the read tool, and the markdown skill format — the simplest possible primitives. The infrastructure that did not survive was every clever orchestration scaffold the team tried to ship as the model got better.

The internal data point Anthropic offers (and which has been picked up by [GLN-7.5's writeup](https://gln75.com/en/blog/inside-claude-code-accidental-cli-ai-dev)) is that engineer productivity at Anthropic grew roughly **150% post-Claude Code**, measured by pull requests per engineer. That number deserves the usual skepticism applied to any internal productivity claim, but the direction is consistent with what every team that has shipped Claude Code or Cursor seriously reports: agents that compose with simple primitives compound on model improvement, agents wrapped in elaborate orchestration do not.

# 6. The harness is part of the product.

The single design idea that makes Claude Code's *Designing Claude Code* talk worth the 12 minutes is Meaghan Choi's framing that the agent harness (the system prompt, tool surface, slash commands, hooks, `.claude` directory, skill format) is a designable artifact. Most agent products treat the harness as plumbing: the bit between the model and the user that vendors should hide. Cherny's bet is the opposite. The harness is the product. Hackability is a design principle. Users should be able to read, modify, and extend the harness. Skills are just markdown files. Slash commands are templates anyone can write.

This is the same argument [Flue made on May 1](/posts/2026-05-02-flue-agent-harness-framework/) when Fred Schott shipped the agent-harness framework: the harness has been latent in every successful agent product for a year, and the projects that name it as a build target tend to age better than the ones that hide it. Cherny got there first inside Anthropic. Cursor's response (adopting the same skill-and-rules pattern in 2025) confirms the convergence.

# What the playlist does not cover

The playlist's silences are as informative as its content. Three areas where the Anthropic developer canon is conspicuously thin:

| Silence | What's missing |
|---|---|
| 🔴 **Cost engineering** | No video addresses tokens-per-task, prompt caching strategy, or cost ceilings on autonomous agents. Customers consistently raise these as the actual blocker; the playlist treats them as out of scope. |
| 🔴 **Eval rigor** | The *Building Effective Agents* paper acknowledges eval is hard and the multi-agent research writeup describes end-state evaluation, but no video walks through a quantitative eval pipeline. Compare to LangChain's *Anatomy of an Agent Harness* piece or the LessWrong [*Insights into Claude Opus 4.5 from Pokémon*](https://www.lesswrong.com/posts/u6Lacc7wx4yYkBQ3r/insights-into-claude-opus-4-5-from-pokemon) writeup — outside-Anthropic voices have done more on this. |
| 🟡 **Negative results** | What did Anthropic try that did not work? Cherny mentions abandoned orchestration scaffolds in passing on the Pragmatic Engineer interview but the company's official channel does not catalogue failed experiments. The playlist is bullish-only. |

The first silence is the most important. Every customer-facing agent has a cost problem within twelve months of shipping. The playlist's six positions all hold even when cost is binding, but the doctrine of "build for the model six months from now" assumes inference prices keep falling — an assumption that is currently true but not architecturally guaranteed. A more complete developer canon would name the assumption.

# MCP as the open-protocol bet

[David Soria Parra's talk on why Anthropic built and donated the Model Context Protocol](https://www.youtube.com/watch?v=PLyCki2K0Lg) is the playlist's clearest statement of the company's protocol thesis. The talk frames the [December 9, 2025 donation to the Linux Foundation](https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/) as the decision Anthropic made to give up unilateral control of MCP in exchange for cross-vendor adoption. By the time of the donation, the protocol had reached **97 million monthly SDK downloads**, **10,000 active servers**, and first-class support across every major IDE and chat client. The bet has paid off: the protocol is now the de-facto integration layer for agent tooling, and no major player is shipping a proprietary alternative.

What the talk argues is that the donation was not a concession but an architectural commitment. Anthropic could have kept MCP under its own governance and likely retained near-total adoption — the network effects favor the first mover. The reason to donate was that protocols sustain themselves only when they are perceived as neutral, and the long-run value of MCP as a substrate is bigger than the short-run value of MCP as a moat. Soria Parra is direct that the team designed for this from the start: the spec was open, the SDKs were Apache 2.0, the reference implementations were committed to GitHub. The Linux Foundation move was the act of finishing what was always intended.

This stance is consistent with the rest of the doctrine. Open protocols, like simple primitives, age well as models improve. Proprietary integration layers do not.

# Where the doctrine diverges from the rest of the field

Three places where Anthropic's developer canon is openly different from the prevailing AI-agent discourse:

| Topic | Prevailing position | Anthropic doctrine |
|---|---|---|
| **Frameworks** | LangChain, CrewAI, AutoGen, smolagents — buy-vs-build pitches in favor of buy. | "Most successful implementations weren't using complex frameworks." Build composable patterns. |
| **Multi-agent** | Marketing-heavy, vendor-pitched as the next frontier. | Real but bounded. Use the artifact pattern (subagent → filesystem). End-state eval. |
| **Prompt engineering** | Marketed as a craft with elaborate technique catalogs. | Clear communication is most of it. Don't lie to the model. Read outputs. Test prompts on humans first. |
| **Autonomy** | "Agent that books your vacation" framing. | Verification cost ≈ task cost is the failure mode. Coding works because tests are cheap. |
| **Vendor lock-in** | Vendor-specific SDKs as the integration layer. | Donate the protocol. Build the moat at the model layer, not the wire layer. |

What is striking about the divergence is that Anthropic's positions are mostly the conservative, builder-pragmatic ones. The framework skepticism, the prompt-engineering deflation, the artifact pattern for multi-agent, the protocol donation — these are positions that cost the company some near-term market share in exchange for being correct.

![A two-column comparison illustration with marketing-style framework logos on the left and a single hand-drawn tool labeled simply on the right, the right side rendered in editorial red](/post-images/2026-05-02-anthropic-developers-playlist/anthropic-vs-field.jpg)

# What builders should do with the playlist

Watching all fifteen videos takes about four hours and is worth it for anyone shipping an agent product. The compressed extract:

| 🟢 If you're starting | What the playlist says to do |
|---|---|
| Small team, first agent | Watch *Tips for building AI agents* and read the [*Building Effective Agents*](https://www.anthropic.com/index/building-effective-agents) paper. Pick the simplest of the six patterns that fits your task. |
| Choosing tools vs prompts focus | Watch the [45-second Schluntz clip](https://www.youtube.com/watch?v=SO43O_7jqzk). Spend 60% of agent-engineering time on tool descriptions and parameter schemas. |
| Building a coding agent | Watch *The future of agentic coding with Claude Code* and *Designing Claude Code*. Steal the harness pattern (skills, slash commands, hooks). |
| Considering a framework | Re-read the *Building Effective Agents* opening paragraph. The paper itself argues against most framework adoption. |
| Multi-agent design | Watch *Building more effective AI agents*. Use the artifact pattern. End-state eval. |
| Designing for cost | The playlist will not help you. Read [Mario Zechner's pi-agent-core writeup](https://newsletter.pragmaticengineer.com/p/building-pi-and-what-makes-self-modifying) and the LessWrong Pokemon analysis instead. |
| MCP integration | Watch *Why we built—and donated—the Model Context Protocol*. The protocol is now Linux Foundation-governed; build assuming long-term cross-vendor support. |

![A small numbered checklist of seven action items, with the second item marked in editorial red as the highest-impact one](/post-images/2026-05-02-anthropic-developers-playlist/builder-checklist.jpg)

# The doctrine that shipped Claude Code

The Anthropic Developers playlist is what happens when an AI lab decides to publish its developer canon openly, slowly, in long-form, and through the engineers who actually built the systems. It is not a marketing series. It is not a roadmap event. The talks are recorded with one or two cameras and the speakers refer to internal failures, abandoned approaches, and customer pushback by name. The company's developer-relations function is small, the publishing cadence is monthly, and the consistency across speakers is unusual: every video repeats the same six positions with different examples. There is no marketing department softening the rough edges.

What this produces is a coherent doctrine that builders can actually use. The doctrine is conservative on frameworks, pragmatic on multi-agent, deflationary on prompt engineering, ambitious on tool design, principled on protocol governance, and unsentimental about consumer-agent hype. It is also the doctrine that actually shipped the product Anthropic is currently winning with — Claude Code, with its claimed 150% internal productivity lift and its ecosystem of skills and slash commands that other coding agents now imitate. Doctrines that generate working products age better than doctrines that generate slide decks.

For builders, the actionable read is simpler than the four-hour playlist suggests. Pick one of the six workflow patterns. Spend more time on tools than on prompts. Build assuming the next model will be cheaper and smarter. Treat the harness as the product. Donate to open protocols when you can. The rest is iteration. The Anthropic playlist is fifteen videos saying so, in slightly different ways, by the people who would know.

## Sources

- [Anthropic — Developers playlist](https://www.youtube.com/playlist?list=PLf2m23nhTg1PBzCb-nOGFH6NFYSkkVuZ5)
- [Anthropic — Building Effective Agents (Schluntz, Zhang)](https://www.anthropic.com/index/building-effective-agents)
- [Anthropic — Claude Code best practices](https://www.anthropic.com/engineering/claude-code-best-practices)
- [Anthropic — How we built our multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system)
- [Anthropic — Introducing the Model Context Protocol](https://www.anthropic.com/news/model-context-protocol)
- [MCP — joins the Agentic AI Foundation (Dec 9 2025)](https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/)
- [Tips for building AI agents — Anthropic (568K views)](https://www.youtube.com/watch?v=LP5OCa20Zpg)
- [AI prompt engineering: A deep dive — Anthropic (561K views)](https://www.youtube.com/watch?v=T9aRN5JkmL8)
- [Building more effective AI agents — Anthropic (Oct 2025)](https://www.youtube.com/watch?v=uhJJgc-0iTQ)
- [Designing Claude Code — Anthropic (Sep 2025)](https://www.youtube.com/watch?v=vLIDHi-1PVU)
- [The future of agentic coding with Claude Code (Sep 2025)](https://www.youtube.com/watch?v=iF9iV4xponk)
- [Lessons on AI agents from Claude Plays Pokémon (Apr 2025)](https://www.youtube.com/watch?v=CXhYDOvgpuU)
- [Why we built—and donated—the Model Context Protocol](https://www.youtube.com/watch?v=PLyCki2K0Lg)
- [How Cursor is building the future of AI coding with Claude](https://www.youtube.com/watch?v=BGgsoIgbT_Y)
- [Pragmatic Engineer — Building Claude Code with Boris Cherny](https://www.youtube.com/watch?v=julbw1JuAz0)
- [Y Combinator Lightcone — Inside Claude Code with Boris Cherny](https://www.youtube.com/watch?v=PQU9o_5rHC4)
- [Latent Space — One Year of MCP with David Soria Parra](https://www.latent.space/p/one-year-of-mcp-with-david-soria)
- [AI Engineer World's Fair — How We Build Effective Agents (Barry Zhang)](https://www.youtube.com/watch?v=D7_ipDqhtwk)
- [Latent.Space — How Claude 3.7 Plays Pokémon (David Hershey)](https://www.latent.space/p/how-claude-plays-pokemon-was-made)
- [LessWrong — Insights into Claude Opus 4.5 from Pokémon](https://www.lesswrong.com/posts/u6Lacc7wx4yYkBQ3r/insights-into-claude-opus-4-5-from-pokemon)
- [Boris Cherny on Anthropic's 150% productivity claim (GLN-7.5)](https://gln75.com/en/blog/inside-claude-code-accidental-cli-ai-dev)
- [Anthropic — The Most Common Mistake People Make When Building AI Agents (Erik Schluntz)](https://www.youtube.com/watch?v=SO43O_7jqzk)

---

Canonical: https://www.thedeepfeed.ai/posts/2026-05-02-anthropic-developers-playlist/
Site: https://www.thedeepfeed.ai
Full corpus: https://www.thedeepfeed.ai/llms-full.txt