Anthropic announced Claude Skills and my first reaction was: “So what?” We already have AGENTS.md, slash commands, nested instructions, or even MCPs. What’s new here?

But if Simon W thinks this is a big deal, then pelicans be damned; I must be missing something. So I dissected every word of Anthropic’s eng. blog post to find what I missed.

I don’t think the innovation is what Skills does or achieves, but rather how it does it that’s super interesting. This continues their push on context engineering as the next frontier.

Skills and how it works

Skills are simple markdown files with YAML frontmatter. But what makes them different is the idea of progressive disclosure:

Progressive disclosure is the core design principle that makes Agent Skills flexible and scalable. Like a well-organized manual that starts with a table of contents, then specific chapters, and finally a detailed appendix, skills let Claude load information only as needed:

So here’s how it works:

  1. Scan at startup: Claude scans available Skills and reads only their YAML descriptions (name, summary, when to use)
  2. Build lightweight index: This creates a catalog of capabilities (with minimal token cost); so think dozens of tokens per skill
  3. Load on demand: The full content of a Skill only gets injected into context when Claude’s reasoning determines it’s relevant to the current task

This dynamic context loading mechanism is very token efficient; that’s the interesting development here. In this token-starved AI economy, that’s 🤑. Other solutions aren’t as good in this specific way.

Why the alternatives aren’t as good

AGENTS.md (monolithic)

Why not throw everything into AGENTS.md? You could add all the info directly and agents would load it at session start. The problem: loading everything fills up your context window fast, and your model starts outputting garbage unless you adopt other strategies. Not scalable.

Nested AGENTS.md

Place an AGENTS.md in each subfolder and agents read the nearest file in the tree. This splits context across folders and solves token bloat. But it’s not portable across directories and creates an override behavior instead of true composition.

Referenced instruction files

Place instructions in separate files and reference them in AGENTS.md. This fixes the portability problem vs the nested approach. But when referenced, the full content still loads statically. Feels closest to Skills, but lacks the JIT loading mechanism.

Slash commands

Slash commands (or /prompts in Codex) let you provide organized, hyper-specific instructions to the LLM. You can even script sequences of actions, just like Skills. The problem: these aren’t auto-discovered. You must manually invoke them, which breaks agent autonomy.

MCPs (Model Context Protocol)

Skills handle 80% of MCP use cases with 10% of the complexity. You don’t need a network protocol if you can drop a markdown file that says “to access GitHub API, use curl api.github.com with $GITHUB_API_KEY.” To be quite honest, I’ve never been a big fan of MCPs. I think they make a lot of sense for the inter-service communication but more often than not they’re overkill.

The Verdict

  • Token-efficient context loading is the innovation. Everything else you can already do with existing tools.
  • If this gets adoption, it could replace slash commands and simplify MCP use cases.
  • I keep forgetting, this is for the Claude product generally (not just Claude Code) which is cool.

Skills is starting to solve the larger problem: “How do I give my agent deep expertise without paying the full context cost upfront?” That’s an architectural improvement definitely worth solving and Skills looks like a good attempt.