The Emergence of Agent Skills

I read Anthropic’s post on Agent Skills¹ and had that familiar pause, the one where nothing feels wrong, but nothing feels new either.

Folders of capabilities, a markdown file that describes when something should be used, optional deeper docs, and scripts the agent can run. It’s a clean pattern, and it’s also the exact shape my own workflow had already collapsed into.

What they shipped

At a glance, agent skills are just a structured way to package agent behavior where a directory represents a capability and a SKILL.md explains what it’s for. The agent sees the description first, not the whole thing, and if it decides the capability is relevant, it pulls in more detail or runs a script.

This is good design, and it’s hard to argue with, but it’s also not surprising. The standardization of these skills at agentskills.io² is the real news because it’s an acknowledgment that the industry is converging on a specific shape for using these agentic tools.

The path of least resistance

Before this had a name, I was using cursor rules³ in roughly the same shape in an effort to better manage my context window. I had an agent-scripts repo that contained all my bun scripts, and I used cursor rules to point at folders of domain knowledge, expose short descriptions instead of full instructions, and let the agent decide when to read deeper material or call custom bun tools.

I stopped thinking of them as rules and started treating them as on-demand capabilities. It was a way to manage the context tax that comes with globally available tools, because once your tool suite grows, the bloat starts to degrade every single generation, and this on-demand approach wasn’t a stylistic choice but a requirement of the physics of the context window.

The mechanics that force this shape

The shape of these skills is less about design and more about the fundamentals of the engine. When you move past the chatbot metaphor and treat the model as a stochastic completion engine, the constraints of the context window and attention budget stop being theoretical and start being the primary architect of your system.

If you accept that context is limited and that dumping everything upfront degrades performance, a few conclusions follow. You don’t push everything into the prompt, you summarize first, and you defer detail until it’s needed. Eventually you stop writing instructions and start organizing capabilities.

Why Agent Skills feel new

Anthropic frames this as folders of capabilities and progressive disclosure, which is true, but none of those ideas were missing, they were just unnamed. Once context windows mattered, progressive disclosure stopped being optional, and once you had more than one agent, orchestration became unavoidable.

Skills didn’t introduce these behaviors, they acknowledged them.

Where the real value actually is

The real value here is social, not conceptual. By giving the pattern a name and a portable on-disk format, Anthropic moved it from a local hack to a shared standard. We’re seeing the typical cycle of tool development where power users solve a constraint locally, those solutions eventually converge, and a spec emerges to formalize what was already happening in practice.

It makes it easier for the rest of the ecosystem to follow the path that the constraints already carved out.

Closing note

I don’t think agent skills are a leap forward as much as they are confirmation. If you understand agents at the level of context, cost, and execution, this shape emerges on its own, and you don’t need permission or a spec to find it. But for the many, the spec makes it much easier to talk about, and it marks another step in the shift from typing to planning.

Anthropic, “Equipping agents for the real world with Agent Skills”. ↩
Agent Skills Standard. ↩
Cursor, “Rules for AI”. “Apply intelligently” allows rules to be triggered based on context rather than being globally active. ↩