A four-part series on one agent pattern.

  1. The Caller Knows Nothing
  2. The Agent Writes the Next Prompt
  3. “Anthropic Already Does This.” Let’s Check. (you are here)
  4. Antifragile by Construction

Whenever I explain the pattern from The Caller Knows Nothing and The Agent Writes the Next Prompt, someone says Anthropic already does this, or that it’s just SKILL.md. Both are fair challenges. So instead of arguing, I checked, against Anthropic’s own documentation, with citations on every row.

“Isn’t this just SKILL.md?”

People say so, and I see why. In both, the caller sees only a name and a description and decides when to reach for it. Both are a file you drop in, and both work with any model. But the similarity stops at the front door.

SKILL.md agent.py
When invoked Its instructions load into the caller’s context. The caller reads the insides and does the work. The insides never enter the context. perform() does the work; only the output comes back.
Input No typed parameters. A JSON Schema call that can be checked.
Who executes The model, by following prose. Code, the same way every time.
The transcript Instructions stay loaded and shape every later turn. Only the relevant result goes in.
What comes next Steered by instructions the caller must remember. Steered by the output itself.
Replaying a step The outcome depends on the model following the instructions again. The same code runs again with more data, so you compare results.
Host needs A filesystem, usually a sandbox. Just a tool-calling loop, even in a browser.

A skill teaches the caller how to do something. An agent does it for the caller. A skill makes the caller know more. This pattern keeps the caller knowing nothing. They’re opposites at the one point this post is about.

They’re not rivals, though. Skills are great for know-how a person wants to read and edit: long procedures, style guides, judgment. Agents win where you need the same result every time, a typed input, a clean transcript and replay. A skill can tell the caller when to reach for agents, and once a skill’s procedure is stable, it can become an agent.

“Anthropic already does this.” Let’s check.

This is the debate I keep having, so I settled it the boring way: I had every claim checked against Anthropic’s own documentation, with several independent reviewers trying to refute each one and a claim kept only when a majority couldn’t. Here’s what holds up, as of November 5, 2026. Every row links the page it rests on.

Property of the pattern Does Anthropic have it? Where
The caller sees only a name, a description and a schema; the code is hidden Yes. This is ordinary tool use. Your app runs the tool and returns a result. Tool use overview, Managed Agents tools, Agent SDK custom tools, MCP connector
Only the relevant output enters the transcript Yes, in several ways. Subagents return a summary from a separate context; skill scripts are executed, not loaded; programmatic tool calling shrinks large results; hooks cost no context unless they return output; context editing clears old tool results. Subagents, Skills, Advanced tool use, Features overview, Context editing
Selection by description Yes. Skills and subagents keep their name and description in context and load the body when used. Features overview
Typed parameters on that description-driven unit Not for skills or subagents. A subagent gets a free-text prompt; a skill’s body is instructions. Typed schemas live on tools, a separate mechanism. Subagents
The model creates a capability mid-conversation and uses it next turn Partly. Claude Code picks up skills and subagents written to disk, including ones Claude writes itself, without a restart. On the API, tool search only reveals tools the client already sent, and Managed Agents can’t add tools to a running session. Skills, Tool search, Managed Agents custom tools
The return value is deliberately shaped to steer the next step Advice, not a pattern. Managed Agents suggests returning “only the fields Claude needs to determine its next step.” Nothing defines a result that carries a shaped piece, an instruction for the next step and a structured payload. Managed Agents tools, Memory tool
Replay a fixed transcript from any turn with more data No. Claude Code checkpoints each prompt and /rewind restores code or conversation; the Agent SDK can fork a saved session. Both ask the model again. Neither re-runs a fixed step with new data. Checkpointing, SDK sessions
One portable file that is all of the above No. Each property above lives in a different mechanism with its own host: Claude Code, the API, the SDK, Managed Agents, or Cowork (which runs on Claude Code’s architecture in the cloud). Cowork, Skills in Claude

So the honest verdict: Anthropic built excellent parts, and if someone says “tools already hide their code,” they’re right. The claim here isn’t that any single property is new. It’s that one file carries all of them at once, on purpose: typed and described going in, hidden code inside, a result written for the next step coming out, creatable mid-conversation, and replayable as a fixed step. That combination is the pattern, and I couldn’t find it anywhere in Anthropic’s documentation.

To be fair about the limits of this check: docs change fast, and “I couldn’t find it” rests on absence. Shaping a tool’s result to steer the next step is a convention anyone can adopt in any tool, today. That’s rather the point: it’s not a feature to wait for, it’s a way of writing.

Depth without the descent

In Own the Engine I wrote about Karpathy’s funnel: most people will never climb down to the layer where AI really does the work by learning prompts, picking models and wiring tools together. They shouldn’t have to.

The comparison above is that funnel in miniature. To combine what Anthropic offers, you learn roughly 25 separate concepts across four hosts: tool use, server tools, tool search, programmatic tool calling, the memory tool, context editing, caching, the MCP connector, skills, subagents, hooks, plugins, checkpoints, SDK sessions, Managed Agents, Cowork and more. Each one is good. Together they are a descent.

The pattern asks you to learn one thing: a file with a name, a description, a perform() and a result written for whoever comes next. It doesn’t teach you the 25 concepts; it carries their properties for you. That’s why I hold it to a bar of one hour to learn, and why the file runs on an engine you own rather than one you rent. Depth, without the descent.

Go deeper: two free companion books, written side by side with the same chapters so you can compare them page for page: The Brainstem Agent Programming Language and The Claude Agent Programming Language. Both are runnable, and the Claude one cites Anthropic’s docs throughout.