Skills.sh Is the npm Moment for AI Agents (And Most Developers Haven't Noticed)
Command Palette
Search for a command to run...
Comments
Join the discussionNo comments yet. Be the first to comment.
Search for a command to run...
No comments yet. Be the first to comment.
I started building AI agents about two years ago. Not toy demos, actual production features inside a health-tech product. And every single project started the same way.
Write the tool-calling wrapper. Handle the edge cases in structured output. Figure out how the agent should read a PDF without hallucinating page numbers. Build the retry logic. Wire up the logging.
Same boilerplate. Every time. From scratch.
The frustrating part is that every developer building agents is doing this too. Quietly. In their own repo. And nobody shares it.
That is the real infrastructure problem in the agent space right now. Not the model. The model is fine. The problem is everything in between the model and a working agent.
Skills.sh is trying to solve that. And after spending time with it, I think it has a real shot.
When npm launched, developers were already writing JavaScript. The language was not the bottleneck. The bottleneck was that every team was reinventing the same utilities and then never sharing them. npm gave the ecosystem a way to publish, discover, and install reusable logic.
Agent development is in that same phase right now. The LLMs are capable enough. Claude, GPT-4, Gemini, they can all do the work. But the procedural knowledge layer, the "how to actually do this specific thing correctly," lives inside private codebases, personal notes, and Slack messages.
How do you reliably parse a multi-page PDF inside an agent? How do you get consistent structured output from a chain of tool calls? How do you write a SKILL.md that actually teaches the agent something useful instead of being ignored?
Everyone figures this out on their own. Nobody publishes it in a way other agents can consume.
Skills.sh is an open ecosystem from Vercel for discovering, installing, and sharing reusable capabilities for AI agents.
A skill is a SKILL.md file. It is a markdown document with a small YAML frontmatter block at the top:
---
name: my-skill
description: What this skill does and when to use it
---
# My Skill
Instructions for the agent to follow when this skill is activated.
## When to use
Describe the scenarios clearly.
## Steps
1. First, do this
2. Then, do that
That is it. Plain text. Version controlled. Shareable.
To install a skill into your agent, you run one command:
npx skills add anthropics/skills
The CLI detects which coding agent you are using, and places the skill where that agent can find it. Claude Code, Cursor, GitHub Copilot, Windsurf, Codex, Gemini, VS Code, Cline. Over 38 agents supported. One skill works across all of them.
The project is open source (MIT license) on GitHub at vercel-labs/skills. The underlying specification was originally developed by Anthropic and released as an open standard in late 2025. Skills.sh is the directory and leaderboard built on top of that spec.
I always check adoption numbers before deciding whether something is worth writing about. Early-adopter hype without traction is noise.
Skills.sh currently shows over 91,000 total installs on the leaderboard. The top skill, find-skills from Vercel Labs, has 1.4 million installs. Anthropic's frontend-design skill has 391,000. Microsoft published a full suite of Azure skills that together have over 4.5 million installs.
Look at who is publishing: Vercel, Anthropic, Microsoft, Supabase, Firebase, shadcn, Expo, Better Auth, Convex, Sentry, Firecrawl. These are production teams shipping and maintaining skills. Not weekend projects.
The community side is growing too. Matt Pocock published TypeScript skills. Independent developers have published skills for debugging workflows, code review, TDD, and marketing automation. The long tail is filling in fast.
This is not early-adopter hype. This is an ecosystem that has already moved past the "will it survive?" question.
Here is the shift that I think matters most, and it is not about the tooling.
The traditional approach to building agents is monolithic. You decide upfront what your agent can do, you build all of that in, and you ship it. If it needs a new capability, you go back into the codebase.
Skills push you toward a composable model. Your agent starts minimal. It has a core set of instructions. Then it picks up capabilities based on what the project actually needs.
Working on a Next.js project? Add vercel-labs/next-skills. Need the agent to understand your Azure infrastructure? Add microsoft/azure-skills. Want consistent TDD practices across your codebase? Add mattpocock/skills.
The agent does not know about these capabilities until you install them. And when you switch projects, you install different skills. The agent adapts.
I have been using Claude Code in my own projects, and this model changes how I think about agent setup. Instead of a long system prompt trying to encode everything, I have a small core instruction set and a set of skills that load in for specific contexts. It is cleaner. It is easier to maintain. And it is shareable, so the next project I start does not begin from zero.
There is also a security dimension worth noting. Skills.sh runs routine audits on published skills and flags anything suspicious. The audits page shows ratings for every skill. In an ecosystem where anyone can publish, that matters.
One of the most painful things in early agent work is document handling. You want the agent to read a PDF and extract specific information. Sounds simple. In practice, agents hallucinate page numbers, misread tables, and lose track of multi-page structures constantly.
Anthropic published a pdf skill with 99,000 installs. It gives the agent a structured approach for reading and extracting from PDF documents. Install it once, and every project where you use that agent gets consistent document handling.
Same thing for frontend work. The frontend-design skill from Anthropic's team encodes design system constraints, typography rules, and component patterns. Instead of writing a long prompt that says "please use 14px font and no gradients," the skill handles it. And it is versioned, so when the guidelines update, you pull the latest version.
This is what I mean by procedural knowledge. Not what the agent can do in theory. How it actually does specific things in practice.
If you are already using Claude Code, Cursor, Copilot, or any of the other supported agents, you can try this in under two minutes.
npx skills add anthropics/skills
That installs Anthropic's official skill collection including frontend-design, pdf, skill-creator, and others. The CLI will detect your agent and place them correctly.
If you want to browse first, go to skills.sh and filter by topic or agent. The leaderboard shows install counts so you can see what the community actually uses rather than just what gets promoted.
One more thing: if you build something useful and want to share it, publishing a skill is as simple as pushing a SKILL.md file to a public GitHub repo. The ecosystem is open. The spec is public. You do not need permission to contribute.
The npm moment for agent behaviour happened quietly. I would rather know about it earlier than later.
MJ Verdi is a senior full-stack developer based in Toronto, building with ASP.NET Core, Flutter, and Next.js. He writes about agent architecture, developer tooling, and building software in the AI era.