Skills, MCP servers, plugins and subagents are not rivals, and the useful question is which job each one does. In short: a skill teaches Claude how to do something, an MCP server connects Claude to something, a subagent hands a task to a separate worker, and a plugin is a package that can carry any of those. This page compares Claude skills vs MCP and the other two, with a decision table first and the trade-offs after.
It is written for Claude Code, since that is where all four exist side by side, and it notes where other agents differ. For the definition of a skill, read what Claude skills are first. Here the aim is only to help you pick.
Quick decision table
| You want to... | Reach for | Why |
|---|---|---|
| Repeat a procedure the same way each time | Skill | Instructions load on demand and can bundle scripts |
| Read or change data in an outside system | MCP server | It exposes tools and data through an open protocol |
| Keep a noisy side task out of your main chat | Subagent | It has its own context and returns a summary |
| Share a setup with a team or many projects | Plugin | One install, versioned updates from a marketplace |
| Apply a rule to every task in a repo | Instruction file | CLAUDE.md or AGENTS.md is always loaded |
| Give an agent a role with limited tools | Subagent | You can restrict tools, model and permissions |
The last two rows involve neither skills nor MCP. They are here because people often reach for a skill when an always-loaded instruction file would be simpler, a question the post on CLAUDE.md, AGENTS.md and skills takes on directly.
Claude skills vs MCP: how methods differ from connections
An MCP server is a running program. The Model Context Protocol describes itself as an open-source standard for connecting AI applications to external systems, and compares it to a USB-C port: a standard way to connect data sources, tools and workflows. In Claude Code you add a server with a command such as claude mcp add --transport http <name> <url>, and you can list what is configured with claude mcp list or the /mcp panel.
A skill is a folder. It does not connect to anything by itself. It carries instructions, and sometimes scripts, that tell the agent how to carry out a task with the tools it already has.
| Skill | MCP server | |
|---|---|---|
| What it is | A folder with SKILL.md | A program speaking the Model Context Protocol |
| What it provides | Instructions, scripts, references | Tools, data and prompts from an outside system |
| Runs as | Text the agent reads, plus scripts it executes | A local process or a remote service |
| Needs credentials | Only if its scripts call something | Often, for the service it connects to |
| Context cost | Short description always; body when used | Tool definitions, loaded through MCP tool search by default in Claude Code |
| Portable across agents | Yes, via the open Agent Skills format | Yes, many clients support MCP |
The difference shows up in a simple test. If the job is "get the open issues from the tracker," you need access, and an MCP server is the natural fit. If the job is "triage issues the way our team does," you need a method, and that is a skill. Plenty of workflows need both, with a skill describing the procedure and an MCP server supplying the data.
The directory has resources for each side. Anthropic's MCP Server Builder skill guides designing and implementing servers in TypeScript or Python, and the MCP topic lists more skills that deal with the protocol.
Skills vs plugins: a file against a package
A plugin is not a competitor to a skill, because a skill can live inside one. Anthropic's documentation describes a plugin as a directory of skills, agents, hooks, MCP servers or other components that Claude Code installs and loads as one unit. A manifest at .claude-plugin/plugin.json names it, and plugin skills run with the plugin name as a prefix, for example /my-plugin:review.
Skills, subagents, hooks and MCP servers all work on their own without a plugin. The documentation's own guidance is to use a plugin when you want several of them packaged together: to install someone else's setup with one command, or to share your own setup with teammates and publish versioned releases.
There is a cost to weigh. An enabled plugin is part of every session, so the name and description of each skill, agent and command Claude can invoke on its own sit in context on every turn, even in sessions where the plugin never runs. Its MCP servers run alongside the session and its hooks fire at their events. If you only need one skill, installing that single skill with the skills CLI or GitHub CLI keeps the footprint small. Anthropic's skills repository publishes a plugin marketplace for its example and document skills, so both routes exist for the same content.
Skills vs subagents: shared context against separate context
This is the pair people confuse most, and the Claude Code documentation draws the line clearly. A subagent is a specialized assistant with its own context window, its own system prompt, specific tool access and independent permissions. It does not see your conversation history, and only a summary returns to the main conversation. A skill runs in your main conversation and shares its context.
| Skill | Subagent | |
|---|---|---|
| Purpose | Reusable prompts and workflows in the main context | Self-contained tasks with their own constraints |
| Context | Main conversation | Fresh, isolated context |
| Tools | Inherits the main conversation's tools | Can be restricted extensively |
| System prompt | Appended to the main prompt | Custom for each subagent |
| Defined in | SKILL.md folders | Markdown files in .claude/agents/ or ~/.claude/agents/ |
| Token use | Shares the conversation's tokens | Separate requests |
Subagents also cost something: they make their own API requests, which count toward the same usage limits. They are a good fit for exploration that would otherwise fill your chat with file listings, and for roles that should not edit files, such as a reviewer with read-only tools.
The two features connect in both directions. A subagent can preload skills through its skills field, which injects the full skill content at startup. A skill can set context: fork in its frontmatter to run in an isolated subagent, with agent choosing a type such as Explore or Plan. Skills built around delegation exist in the directory too: Subagent-Driven Development gives each task in a plan to a fresh subagent with a review after each, and Dispatching Parallel Agents splits unrelated tasks across subagents that run at the same time. See the subagents topic for the wider list.
Skills vs commands and instruction files
Two older or simpler tools deserve a mention because they overlap with skills.
Custom commands. Files in .claude/commands/ still work in Claude Code, and .claude/commands/deploy.md and a skill named deploy both create /deploy. Anthropic's docs call skills the preferred format for new work, because a skill is a folder that can hold scripts and references and that Claude can load automatically when relevant. If you have working commands, there is no urgency to convert them.
Instruction files. CLAUDE.md and AGENTS.md are read at the start of a session, so everything in them costs context every time. That is correct for rules that apply to every task and wrong for a long procedure you need twice a month. A skill's body stays out of context until the skill is used. The agent instructions topic collects skills that help write and maintain these files.
How the pieces combine
Real setups usually mix several of these. Here are illustrative setups, each built only from features the Claude Code documentation describes:
- A team ships one plugin containing a review skill, a read-only reviewer subagent and an MCP server for their issue tracker. Installing the plugin gives every teammate all three.
- A subagent for database work preloads a skill with the team's query conventions, so the conventions are in its context without being in the main chat.
- A skill with
context: forkand the Explore agent does codebase research in the background while you keep working. - A personal skill in
~/.claude/skills/covers one habit, with no plugin involved.
Trade-offs, stated plainly
- Skills are cheap to write and read, and portable across agents. They do not give the agent new capabilities, and a vague description means they never trigger.
- MCP servers open up external systems and are widely supported. They need a running process or remote service, often credentials, and their tools add to context.
- Plugins make distribution easy. They also bundle components that run with your privileges, so Anthropic's documentation advises reviewing a plugin before you install it.
- Subagents protect your main context and allow tight tool limits. They add separate requests, and they start without your conversation, so the delegating message has to carry what the subagent needs.
A sensible order for most people is to start with a skill or an instruction file, add an MCP server when you need outside data, add a subagent when context or permissions become the problem, and package everything as a plugin when other people need it. When you are ready to write the first one, how to create a Claude skill is the practical next step.
Frequently asked questions
What is the difference between a Claude skill and an MCP server?
A skill is a folder of instructions, and optionally scripts, that tells the agent how to do a task. An MCP server is a running program that gives the agent tools and data from an external system such as a database, an issue tracker or a calendar. Skills teach a method, and MCP servers provide access.
Is a plugin the same thing as a skill?
No. A plugin is a package that can hold skills, subagents, hooks and MCP servers and that Claude Code installs as one unit. A skill is one possible component inside a plugin, and skills also work on their own without any plugin.
When should I use a subagent instead of a skill?
Use a subagent when a side task would clutter your main conversation, or when you want a different set of tools, permissions or model for it. A subagent runs in its own context window and returns only a summary. A skill runs inside your main conversation and shares its context.
Do slash commands still work now that skills exist?
Yes. Files in .claude/commands/ still work in Claude Code, and a command and a skill can both create a slash command. Anthropic's documentation recommends skills for new work because they can bundle supporting files and let Claude load them automatically.
Can skills, MCP servers and subagents be used together?
Yes, and they often are. A subagent can preload skills through its skills field, a skill can run in a forked subagent with context set to fork, and a plugin can ship skills, subagents and MCP servers in one package.