Agent skills are becoming composable the way npm packages did — and it will reshape how we build

Skills are just markdown files that make agents useful

An agent skill is a markdown file. That is it. You write instructions in natural language, save it as .md, and suddenly your AI coding agent knows how to do something it could not do before. No API. No SDK. No build step. Just prose that teaches a machine how to perform a specific task well.

The distribution model is what makes this interesting. npx skills add mblode/agent-skills — one command and the skill is in your project. Sound familiar? It should. This is npm install for agent capabilities. You browse a registry, pick what you need, install it, and your agent gets smarter.

I have been building skills for Claude Code since late 2025. Every time I find myself repeating the same instructions across projects, I extract them into a skill. Deployment patterns, code review checklists, animation guidelines, component architecture decisions. Things that used to live in my head or in scattered docs now live in composable, shareable files.

The meta moment

I built agent-skills-creator — a skill that creates other skills. You describe what you want the skill to do, and the agent generates a well-structured skill file following best practices. A skill that makes skills. The recursion is not a gimmick. It is the natural consequence of treating agent capabilities as composable units.

Then I built allmd. It converts any URL, PDF, video, or audio file into clean markdown. The tagline is "turn the whole universe into a skill," and I meant it literally. Any knowledge source on the internet can become agent-consumable context in one command. Research papers, documentation, blog posts, YouTube tutorials — all of it becomes raw material for teaching agents.

Then I built Shareful.ai. Think of it as Stack Overflow for AI coding agents. A platform where developers share solutions, patterns, and approaches that work well with AI tools. The problems we solve with agents are different from the problems we Google. They deserve their own knowledge base.

Each project felt like a standalone idea. Looking back, they are all the same idea. Build the ecosystem that makes agent capabilities shareable.

The npm analogy is not a metaphor

In 2010, npm was a weird idea. Why would you share a four-line function as a package? Why would you install left-pad instead of writing it yourself? The answer turned out to be that composability at scale changes everything. Small, focused, reusable units compound into capability that no single developer could build alone.

Skills are following the exact same trajectory. They are small. They are focused. They are shareable. They compose. You install a skill for database migrations, another for accessibility audits, another for performance profiling. Your agent becomes competent across domains without you becoming an expert in all of them.

The early npm ecosystem was messy and exciting. Skills are messy and exciting right now. There is no dominant registry yet. Best practices are still forming. The people building skills today are the equivalent of the people who published the first npm packages — they are shaping a format that millions will eventually use.

MCPs are the other half

MCPs are related but they serve a different purpose. MCPs are infrastructure for AI agents rather than humans. They expose natural language APIs so bots can run commands on our behalf. Stainless is already auto-generating SDKs and MCPs from OpenAPI specs. The infrastructure layer is standardising fast.

Skills sit on top of that infrastructure. A skill might tell an agent when and why to use a specific MCP. The MCP provides the capability. The skill provides the judgment. Together they turn a generic AI assistant into a domain-specific collaborator.

The honest tension

Here is the part I wrestle with: even skills for CLI tools are mostly overkill because Claude Code can just figure it out. Give it a well-documented tool and it will read the docs, understand the flags, and use it correctly without any skill file telling it how.

So why do skills matter? Because right now, they dramatically improve output quality and consistency. The gap between "the agent can figure it out" and "the agent does it exactly the way I want" is real. Skills close that gap. They encode preferences, patterns, and hard-won decisions that the agent would not discover on its own.

But the honest question is whether that gap shrinks to zero. Maybe agents get good enough that explicit skills become unnecessary. Maybe every skill eventually gets absorbed into the model's general capability. Maybe the skills ecosystem is a transitional technology — essential now, obsolete later.

The open question

Will skills consolidate the way npm did — a dominant registry, a standard format, an ecosystem so entrenched it becomes permanent infrastructure? Or will agents absorb skills into their own intelligence, making the explicit skill file a historical artefact?

I do not know. But I know which side I am building on. The people who shaped npm's early ecosystem got to define how an entire generation of developers shared code. The people shaping the skills ecosystem today get to define how an entire generation of developers share agent capabilities.

That is a bet worth making. Even if the agents eventually eat it all.