Don't Build Agents, Build Skills Instead

In plain English

Barry and Mahesh created Agent Skills at Anthropic. They argue that one general AI agent (software that carries out tasks on its own) that can write and run code can handle work in almost any field, so there is no need to build a separate agent for every job.

What it lacks is expertise. Their example: you would want an experienced tax adviser doing your taxes, not a genius working the tax code out from scratch. A skill fills that gap. It is simply a folder of written instructions, and often small programs, that teach the agent how a particular job is done.

The agent sees only a short description of each skill until it needs one, so it can carry hundreds without getting overloaded.

Three ideas worth keeping

• When an agent keeps redoing the same step, save that step inside the skill so it runs the same way every time.
• Connections to other systems bring the data in, and skills bring the know-how about what to do with it.
• People in finance, recruiting, legal and accounting are already writing skills, not just developers.

What it means for your business

Your team’s way of doing things can be written down once and handed to an AI, so it follows your process instead of guessing. Because a skill is just files, it can be shared and improved like any document.

The speakers picture a company-wide library that keeps getting better, so a new starter’s AI already knows how the team works.

What it means for software teams

Treat skills like software: the speakers plan better testing of whether a skill is picked up at the right moment, version history, and skills that depend on other skills. Keep each skill’s short description sharp, since that is all the agent sees before deciding to load it.

Turn scripts the agent keeps rewriting into tools stored inside the skill.

What we found, and what we did

We work the same way: repeatable procedures are captured as named skills that our agents load, both inside our own platform, Mibble, for jobs like putting a change through our pipeline or adding a feature, and in a shared playbook we use across our work.

We published the approach in Build Skills, Then Loop Them Into a Super-Agent. One thing we would add: a skill is still written instructions, and written rules alone did not stop our agents.

The agent that wrote our rule against working in a shared copy of the code broke it itself, and only a hard check in the tooling stopped it.

So where a rule really matters, we enforce it in the tools rather than relying on the skill.

Worth watching

• 02:30: why a brilliant agent still needs expertise, and why skills are just folders.
• 04:03: saving a repeated script as a tool, and loading skills only when they are needed.
• 14:06: an agent that is better on day 30 than day one, and the processor, operating system and apps comparison.