Agent Skills: expertise your agent loads on demand.

Strip the branding and a skill is a folder. At its heart sits a SKILL.md — instructions for doing one kind of task well: your deploy runbook, a code-review checklist, a brand voice guide, the exact steps for cutting a release. Around it, optionally: scripts the agent can run, templates, reference files.

The trick is what the agent sees. Not the whole folder — just each skill's name and one-line description, a menu costing a few dozen tokens. When a task matches a description, the agent opens that skill and follows it. Expertise stored outside the window, selected on demand.

Anthropic shipped the pattern for Claude (and open-sourced the format), but nothing about it is vendor-specific — it's "a folder of instructions with a discoverable description," and variants of that idea are spreading through every serious agent stack.

The naive alternative is obvious: paste every workflow into the system prompt. Teams did. It fails on three axes at once:

This is progressive disclosure — the UI principle, applied to model context. The agent knows that a capability exists (cheap) without carrying how to do it (expensive) until the moment of use. The window stays lean; recall stays sharp; the attention budget gets spent on the task.

The saving is countable. Inlining pays for every playbook on every request; skills pay a one-line description each, plus the one body the task actually matches:

And the gap widens with every workflow you add — the whole point of the pattern. The runnable version below matches a task to a skill and prices both architectures.

The format is deliberately boring — markdown with a small frontmatter header:

Two design pressures shape a good SKILL.md. It must be self-sufficient: the agent arrives with zero memory of writing it, so context, prerequisites and success criteria all go in. And it must be scoped: one skill, one job. "Deploy the API" is a skill; "everything about our infrastructure" is a junk drawer that will never trigger cleanly.

Four mechanisms extend an agent; they answer different questions:

The stack composes: MCP connects the tools, skills teach the workflows that use them, and the loop decides when each gets pulled in. Most teams need skills long before they need fine-tuning — editing a markdown file beats a training run.

The most common failure isn't a bad skill — it's a good skill that never fires, or fires for the wrong task. Almost all of that is the description.

A skill is instructions your agent will follow and often scripts it will execute. Installing one is exactly as consequential as adding a package to your build — and the ecosystem is younger and less audited than npm.

The standing defenses of agent security still carry the real weight: least-privilege tools, sandboxed execution, approval gates on irreversible actions, and treating retrieved content as untrusted input. A skill changes what the agent intends to do; the guardrails bound what it can do.