Skills Instead of Agents

Source: Barry Zhang and Mahesh Murag (Anthropic), Don’t Build Agents, Build Skills Instead (AI Engineer, 2025-12-08, 16 minutes): https://www.youtube.com/watch?v=CEvIs9y1uog

A summary of the talk in my own words, built from its transcript. Watch the talk for the full argument. Counts and product names are as of December 2025.

The argument

Stop building a separate specialized agent for each domain. Build one general agent, then give it a library of skills, which are packages of expertise it loads only when a task calls for one. Zhang and Murag created Agent Skills at Anthropic, and the talk explains why their own work shifted from agents to skills.

Why one general agent is enough

• The old assumption: agents in different domains would look very different, each with its own tools and scaffolding, so every use case would need its own agent.
• What changed their mind: Claude Code turned out to be a general-purpose agent, not just a coding tool. Code is, in the speakers’ words, “the universal interface to the digital world.”
  • Their example: a financial report. The agent calls an API to pull the data, organizes it in the file system, analyzes it in Python, and writes the result out as a document, all through code.
  • The consequence: the core scaffolding can shrink to little more than bash and a file system, which scales well.

The problem skills solve: intelligence without expertise

• The analogy: for your taxes you would pick an experienced tax professional over a brilliant mathematician working out the tax code from first principles. You want consistent execution, not rediscovery.
• Today’s agents are the mathematician. They can do impressive work with enough guidance, but they lack important context up front, can’t easily absorb your expertise, and don’t learn over time.

What a skill is

A skill is a folder: an organized collection of files that packages procedural knowledge an agent can combine with other skills.

• The simplicity is deliberate. People and agents alike can make one with nothing but a computer, and it fits tools teams already use: version it in Git, put it in a shared drive, or zip it and send it.
• Scripts act as tools, and fix problems that classic tool definitions have:
  • A tool with vague instructions leaves the model stuck, because it can’t change the tool, and every tool definition sits in the context window all the time.
  • Code documents itself, the agent can modify it, and it stays on disk until it’s needed.
  • Their example: Claude kept rewriting the same Python script to style slides, so they had it save the script inside the skill for its future self. Running the saved script is faster and more consistent.

Progressive disclosure

At runtime the model sees only each skill’s metadata, just enough to know the skill exists. When a task needs it, the agent reads the rest of SKILL.md, which holds the core instructions and acts as a directory for everything else in the folder.

• Why it matters: this protects the context window, so one agent can carry hundreds of skills and combine them.
• For the always-loaded alternative this replaces, see AGENTS.md vs SKILLS.md in the AI Agents primer course; for why context cost matters at all, see Context-Rot-and-Governing-Context.

Who is building skills

About five weeks after launch the speakers counted thousands of skills, of three kinds:

Three trends they see:

• Skills are getting bigger. The simplest is still one SKILL.md, but many now bundle software, binaries, scripts and assets, and may grow into software projects maintained over months.
• Skills complement MCP. MCP servers connect the agent to the outside world; skills supply the expertise, often by orchestrating several MCP tools into one workflow.
• Non-developers are writing them. People in finance, recruiting, accounting and legal are extending general agents for their own work.

The emerging architecture

General agents are converging on four pieces:

1. An agent loop that manages what goes into and out of the model’s context.
2. A runtime environment where the agent has a file system and can read, write and run code.
3. MCP servers for outside tools and data.
4. A skill library the agent draws from at runtime.

Adding a new domain then becomes a matter of choosing the right MCP servers and the right skills. Anthropic’s financial-services and life-sciences offerings shipped exactly that way, soon after skills launched.

What comes next

• Treat skills like software: testing and evaluation (does the agent load the right skill at the right time, and is the output good?), versioning with a clear history of how behavior changed, and explicit dependencies on other skills, MCP servers and packages.
• Sharing: an organization’s skills become a shared, growing knowledge base. A new team member’s agent already knows how the team works, and skills from the wider community help everyone’s agents the same way MCP servers do.
• Continuous learning: because the format is standard, anything Claude writes down as a skill can be reused efficiently by a later session. That makes memory concrete, though only for procedural knowledge. The agent can pick up, revise and retire skills as needs change, and Anthropic already ships a skill for creating skills. The stated goal is an agent that is clearly better after a month of working with you than it was on its first day.

The agent stack, by analogy to a computer

The value, as with computers, ends up in the application layer. Skills are meant to open that layer to anyone who can put the right files in a folder.

In this course

• Matt Pocock Skills Overview and Matt Pocock Skills Main Flow — a working skill library for software engineering, and the workflow built from it.
• Hermes-Agent-Skill-Authoring-SKILL-md-Structure-and-Best-Practices — how to write one skill well.