Drawn out by layers it becomes clearer:

This is exactly why the question "what is better, a skill or MCP" is usually put wrongly. A skill explains to the agent how to work with PostgreSQL properly, while MCP gives it a real tool for running queries. They are not competitors but different floors.

Agent Skills are gradually becoming a common format

The most interesting change of the past year is that a skill is less and less tied to Claude alone. The Agent Skills specification describes a lightweight open format: a directory with a mandatory SKILL.md, metadata in YAML and instructions. On top of that a skill may contain scripts, reference files, templates and other resources.

In the minimal case a name, a description and instructions are enough for the agent. An important part of the architecture is progressive disclosure: the agent first sees only the metadata and loads the detailed contents only when the skill is actually needed.

The practical consequence: a good skill today is best thought of as a portable working module rather than a prompt for one Claude. The open format is already supported by several agents, including Claude Code and OpenAI's Codex.

Official collections: Anthropic and Vercel

The first place to look is the vendors' own collections. For Anthropic that is the public anthropics/skills repository, which shows how real skills are built: there are technical scenarios as well as work with documents, design, testing and enterprise processes. It is worth reading for the canonical skill structure, the shape of SKILL.md, the handling of extra files and the approach to narrow workflows. skill-creator deserves a separate mention: Anthropic uses it not only to create skills but to improve them and assess their quality. The collection is small - seventeen skills - and alongside them sit the format specification itself and a ready template for a new skill. This is a reference set rather than a marketplace: for mass discovery skills.sh or the plugin catalogue is more convenient.

With Vercel it is slightly trickier, because the names are easy to confuse. Laid out plainly:

It is vercel-labs/agent-skills that holds ready instructions and scripts for agents in the Agent Skills format: React, web design, deployment, work with the Vercel ecosystem. This is a good example of vendor-maintained skills: instead of a random instruction from a catalogue you get material from the team that works with that stack directly.

Vercel Agent Resources deserves a separate note - the name suggests yet another catalogue, but in practice it is a section of Vercel's documentation about agent resources and Agent Skills. Use it as documentation, and go to skills.sh or the vendors' repositories for the skills themselves. How wide the compatibility runs is clearer from the tool itself: its own description lists OpenCode, Claude Code, Codex and Cursor and adds another seventy-two environments - seventy-six in total.

The Claude Plugin Marketplace

If you work in Claude Code specifically, claude-plugins-official is the most natural first source. Claude Code adds the official marketplace itself on the first interactive run, and the catalogue can be browsed through /plugin in the Discover section.

The key difference from an ordinary skills catalogue is that a Claude plugin is an extension container. It may include several things at once:

Anthropic maintains two public tracks, and the distinction between them matters. The official catalogue is curated by Anthropic itself. The community catalogue gathers third-party plugins for Claude Code and Claude Cowork, but it is arranged differently than it looks: the repository itself is declared a read-only mirror, and you submit your plugin through a separate form rather than a pull request.

And here is a subtlety worth getting right: the word "official" refers to the catalogue and the curation process, not to a guarantee that every external component inside every plugin was written at Anthropic. Anthropic itself recommends trusting a plugin only after checking its source and composition.

skills.sh and the Skills CLI

skills.sh is no longer a Claude catalogue but an open Agent Skills ecosystem; the vercel-labs/skills repository holds the tool for finding, installing and updating them.

The idea is simple: instead of a separate installation route for every tool there is one shared package layer. The same skill is distributed for Claude Code, Codex, Cursor, GitHub Copilot and other compatible clients.

It has more commands than the four shown, and one deserves a separate mention: npx skills use runs a skill once without installing it at all. Handy when you want to see how someone else's instruction behaves without leaving it in your system. There is also removal of an installed skill and scaffolding of a new one.

The strength here is portability, and it is especially valuable if you work with several agents at once and want the same working rules in all of them. The limitation is worth knowing too: the catalogue is large and mixes official content with community content, so presence in the index does not replace checking the author and the contents.

The awesome catalogues: Composio and VoltAgent

ComposioHQ/awesome-claude-skills is one of the best-known community repositories around Claude skills. It gathers ready skills, resources and tools sorted by practical direction: development, business and marketing, communication and writing, creative and media.

Why keep it if skills.sh exists? Because an awesome list and a package catalogue solve different problems. skills.sh is better for finding and installing; a list is better for browsing the ecosystem with your own eyes - reading a category description, finding adjacent projects, catching ideas. The right order is this: you find a suitable skill in the list, then go to its source repository and check the code, the history and the author.

VoltAgent/awesome-agent-skills builds a wider list - its own description claims over a thousand skills. Where Composio has historically been oriented towards Claude, here you find skills from official teams and the community that work with Claude Code, Codex, Gemini CLI, Cursor and other agents. That helps when the task is not "find a Claude extension" but "find a portable working module for any of my agents". A good move is to check first whether there is already an official skill from Google, Supabase, Vercel or Cloudflare, and only then install a community equivalent.

Author collections

Not every useful source has to be a giant marketplace. miolamio/claude-skills is an example of a small author collection where the value is not in quantity but in a few well-drawn workflows. It contains, for instance, ru-editor - a skill for editing Russian text with sequential revision, a self-check and a final read-through.

Such repositories are best seen as an author's set of working practices. They are especially useful when the author's method suits you.

What each source actually is

A caveat about that last column: the level of trust refers to the origin and degree of curation of the source, not to a guarantee that a particular package is safe.

If you need a tool rather than a skill - the MCP Registry

For MCP there is an official centralised registry of public servers, registry.modelcontextprotocol.io. It lives in the protocol's own ecosystem and is meant precisely for discovering servers.

The difference between the three branches of extensions is clear from one example:

That is why a good working set often consists of more than one element: a vendor skill describes the correct order of work, while an official MCP gives the agent a safely bounded set of operations.

One caveat on status: the official MCP registry was still in preview at the time of checking, so its API and data may change.

Three ways to install

Through the Claude plugin catalogue. Open /plugin, go to Discover, study what the plugin contains and install it through the interface. The official marketplace is usually already added.

Through the Skills CLI. Suited to portable skills and especially convenient if you use several different agents.

By hand from the repository. The most transparent option, especially for a security-sensitive environment: look at all the contents first, connect it second.

A skill is not a harmless text preset

The most dangerous mistake is treating a skill as styling or a set of hints. A modern skill can instruct the agent to run shell commands and can contain executable scripts. A plugin can additionally wire in hooks and MCP servers. The chain of trust looks like this:

What to check before installing. The author and the repository - is this an official vendor, a known team or a random account? What SKILL.md says - which actions is the agent allowed to perform? Does scripts/ contain executables in shell, Python or Node? Does anything run automatically on events through hooks? Which MCP servers will be started and what credentials will they get? What will the package manager actually install? Is the project alive by its change history, and has ownership changed unexpectedly? And finally - does the skill need to be global, or is one project enough?

The rule is simple: the more autonomy the agent has, the stricter you should be with third-party skills and plugins. An instruction that lets an agent run commands is already part of your supply chain.

Where to go in different situations

"I want to improve Claude Code" - the Claude Plugin Marketplace first, it is the best integrated with the tool itself.

"I want the same rules in Claude and Codex" - Agent Skills and skills.sh: portability matters more here than platform-specific features.

"I work with React, Next or Vercel" - start with vercel-labs/agent-skills, then compare with community options.

"I need a skill for a specific product" - look for the vendor's official repository first: they know their own API and practices better than a random author.

"I need a rare task" - the Composio and VoltAgent awesome lists, then a move to the source repository and a manual check.

"I need to connect GitHub, a database or a service" - look for an official MCP or check the registry. A skill on its own does not create an external tool.

"I need my own internal processes" - it is often better to write a small skill of your own than to drag in a huge universal package.

What I would avoid

I would not install dozens of skills just in case: a skill is useful when it has a clear area of responsibility, while a warehouse of overlapping instructions complicates choice and breeds contradictions.

I would not confuse popularity with quality: stars, install counts and a place in a listing help you find something but say nothing about whether the skill suits your way of working.

I would not put a community plugin straight into working infrastructure: a local check first, a look at scripts, hooks and MCP, then a limited test.

I would not choose a community option when a fresh official one exists - especially for fast-moving APIs and frameworks, where a stale instruction is sometimes worse than no skill at all.

And I would not build a monolithic super-skill for everything: small specialised ones are easier to read, test, update, switch off and carry between agents.

In conclusion: the ecosystem is splitting into levels

Instead of one universal plugin store, several parallel layers are forming.

A simple strategy looks like this: check the vendor's official skill or plugin first; if portability is needed, search through skills.sh; if nothing turns up, go to the good awesome catalogues; if you need a real integration with an external system, look for MCP. And before installing any third-party extension, read not only the README but also what it actually makes the agent do.

Skills are becoming to agents roughly what packages once became to programming languages: a convenient way to reuse someone else's work. Which means that along with the convenience comes the familiar supply-chain problem - the question is not only "what can this package do" but "whose code am I allowing to run".

Sources

The information and links were checked on 11 August 2026. Supplemented on 15 August 2026: the number of compatible environments taken from the tool's own description, the status of the community catalogue clarified as a read-only mirror, and the size of Anthropic's official collection, running a skill once without installing, and VoltAgent's claimed volume added. The ecosystem of Agent Skills and plugin catalogues changes fast, so it is worth checking a project's README and documentation before installing.

• Agent Skills - the format's official site
• Agent Skills Specification
• Anthropic - the public Agent Skills repository
• Claude Code Docs - discover and install plugins
• Claude Code Docs - plugin marketplaces
• Anthropic - claude-plugins-official
• Anthropic - claude-plugins-community
• skills.sh - the Agent Skills directory
• Vercel Labs - the Skills CLI
• Vercel Labs - the Agent Skills collection
• Vercel Agent Resources - Skills
• ComposioHQ - awesome-claude-skills
• VoltAgent - awesome-agent-skills
• miolamio - claude-skills
• The official MCP Registry
• Model Context Protocol - about the registry