# Claude Code Skills vs Plugins vs Agents vs MCP: Which Do You Need? (2026)

> Claude Code skills vs agents, plugins, commands, and MCP — explained in one master table, with five plain rules for picking the right primitive for any task.

Source: https://designrevision.com/blog/claude-code-skills-vs-plugins-vs-agents

---

Skills, plugins, agents, commands, MCP — Claude Code now gives you five different ways to extend it, and it is genuinely easy to reach for the wrong one. This guide settles **Claude Code skills vs agents** and every other pairing in the set, so you always know which primitive fits the job.

The short version: these are not competing choices so much as different layers. A skill is a capability, a subagent is an isolated worker, MCP is a connection to the outside world, a command is now just a skill you invoke by hand, and a plugin is the package that ships any of them. Once that hierarchy clicks, the "which do I use?" question mostly answers itself. Below is one master table, then a plain-English breakdown of each comparison, and a decision guide at the end.

## Key Takeaways

> If you remember nothing else:
>
> * A **skill** is procedural knowledge (a `SKILL.md` file) that loads into context when relevant — the *capability*
> * A **subagent** (a.k.a. "agent") is a separate context with its own tools that handles a delegated task and reports back — the *isolated worker*
> * **MCP** is a live server connection to external tools and data — the *connection*
> * A **command** is now the same thing as a skill; custom commands have **merged into skills**
> * A **plugin** bundles skills, subagents, hooks, and MCP servers into one installable package — the *distribution*
> * They **compose** rather than compete: a plugin can ship skills that call MCP tools and delegate to subagents

## Table of Contents

1. [The Five Primitives at a Glance](#the-five-primitives-at-a-glance)
2. [Claude Code Skills vs. Agents (Subagents)](#claude-code-skills-vs-agents-subagents)
3. [Claude Code Skills vs. Commands](#claude-code-skills-vs-commands)
4. [Claude Code Skills vs. Plugins](#claude-code-skills-vs-plugins)
5. [Claude Code Skills vs. MCP](#claude-code-skills-vs-mcp)
6. [Which Do You Need? A Decision Guide](#which-do-you-need-a-decision-guide)
7. [Conclusion](#conclusion)

## The Five Primitives at a Glance

Here is the whole comparison in one table. Each row is a primitive; read across for what it is, when to reach for it, how it loads, and where it lives.

| Primitive | What it is | When to use it | How it loads | Where it lives | Example |
|-----------|-----------|----------------|--------------|----------------|---------|
| **Skill** | A folder with a `SKILL.md` file — instructions Claude follows | You repeat a procedure, checklist, or house style | Progressive disclosure: description at startup, full body on match | `~/.claude/skills/`, `.claude/skills/`, inside plugins, enterprise | A deploy checklist, a code-review rubric |
| **Subagent (Agent)** | A separate context with its own tools and prompt | You delegate a big, isolated task and want a clean result back | Spawned on demand; runs in its own context window | `.claude/agents/` or a plugin's `agents/` | A "reviewer" agent, a research agent |
| **MCP** | Model Context Protocol — a live connection to external tools/data | You need Claude to reach an outside system (API, DB, SaaS) | A server connects; its tools are exposed to Claude live | `.mcp.json` config, pointing at a local or remote server | A Postgres server, the GitHub API, Figma |
| **Command** | A slash command — now the same thing as a skill | You want a quick, directly-invoked shortcut | Registered as `/name`; merged with skills | `.claude/commands/` or `.claude/skills/` | `/commit`, `/review` |
| **Plugin** | A package that bundles skills, agents, hooks, and MCP | You want to share or reuse a bundle across projects/teams | Installed from a marketplace, then enabled | A marketplace — any git repository | A "GitHub" plugin, Superpowers |

The pattern to notice: **skills, subagents, and MCP are the capabilities; plugins are how you package and ship them; commands are just skills by another name.** The rest of this guide walks each pairing people actually search for.

## Claude Code Skills vs. Agents (Subagents)

First, a naming note: in Claude Code the feature is called **subagents**, and "agents" is the everyday shorthand — so *skills vs agents*, *skills vs subagents*, and *subagents vs skills* are all the same question.

The real difference is **context**. A [Claude Code skill](/blog/claude-code-skills) is knowledge that loads *into your current session* — Claude reads the instructions and follows them in the same conversation. A subagent is a *separate* context: Claude hands it a task, it works with its own tools and its own token budget, and it returns only a summary. Nothing the subagent read clutters your main thread.

That makes the choice about scope. Reach for a **skill** when you want Claude to *know how* to do something — apply your commit-message format, run your release checklist, follow your migration steps. Reach for a **subagent** when you want to *delegate* a large, self-contained job — "review this whole diff," "research these five libraries" — especially one you would rather run in isolation (or in parallel) so it does not flood your working context.

Crucially, *agents vs skills* is not either/or. Skills and subagents compose: a skill can be configured to run inside a forked subagent, so the procedure and the isolation work together.

## Claude Code Skills vs. Commands

This one has a clean answer: **custom commands have merged into skills.** A file in `.claude/commands/` and a skill in `.claude/skills/` both produce the same `/name` slash command. There is no longer a separate "commands system" to learn.

So what was the distinction? Historically, a command was something *you* typed to trigger a canned prompt. A skill adds one thing on top: **automatic, model-triggered invocation.** Because every skill carries a `description`, Claude can decide *on its own* to load a relevant skill when your request matches — no slash needed. A command only ever fired when you invoked it by hand.

For *commands vs skills* today, the guidance is simple: put new work in `skills/`, give it a good description so Claude can invoke it automatically, and still type `/name` whenever you want to trigger it explicitly. The `commands/` folder stays supported for backward compatibility, but skills are the forward path.

## Claude Code Skills vs. Plugins

The trap here is treating *plugins vs skills* as a fork in the road. It is not. **A skill is the unit of capability; a [plugin](/blog/claude-code-plugins) is the unit of distribution.**

A single skill lives happily in your `.claude/skills/` folder and does its job. The moment you want that skill in a *second* project, or in a teammate's setup, copying files by hand gets old fast. A plugin solves distribution: it wraps one or more skills — plus any subagents, hooks, and MCP servers they depend on — into a package you install with a single command from a marketplace.

So you rarely choose "skill *or* plugin." You build a skill, and when it earns its keep you package it into a plugin so it travels. A plugin might bundle a dozen skills or none at all (just an MCP server, say). When you are ready to find pre-built ones, our roundups of the [best Claude Code skills](/blog/best-claude-code-skills) and the [best Claude Code plugins](/blog/best-claude-code-plugins), plus the [Claude skills marketplace](/blog/claude-skills-marketplace) guide, are the place to start.

## Claude Code Skills vs. MCP

Skills and MCP solve different halves of a problem. A skill teaches Claude **how** to do something; MCP gives Claude **access** to something.

A skill is just instructions and files — there is no server, no process, no live connection. It is perfect for encoding a procedure Claude carries out with the tools it already has. **MCP (Model Context Protocol)** is the opposite kind of thing: a running server that connects Claude to an external system — a database, an internal API, a SaaS product like GitHub or Figma — and exposes that system's real operations as tools Claude can call.

The rule of thumb: if the task is "follow these steps," you want a **skill**; if the task is "reach into that system," you want **MCP**. And, like everything else here, they compose beautifully — a skill can spell out exactly how and when to use the tools an MCP server provides, turning raw access into a reliable workflow.

## Which Do You Need? A Decision Guide

Match your goal to the primitive:

- **"I keep re-explaining the same procedure."** → Write a **skill**. It is the lightest option and the right default.
- **"I want to type a quick shortcut."** → Also a **skill** (commands merged in) — give it a slash name.
- **"I need Claude to talk to an external tool, API, or database."** → Add an **MCP** server.
- **"I want to hand off a big, self-contained job in isolation."** → Delegate to a **subagent**.
- **"I want to reuse or share all of the above."** → Package it as a **plugin** and publish it to a marketplace.

And the meta-rule: **these are layers, not rivals.** A well-built plugin ships skills that invoke MCP tools and delegate to subagents. You do not pick one primitive and abandon the others — you reach for whichever layer the task lives on, and combine them freely.

## Conclusion

The confusion around Claude Code skills vs agents, plugins, commands, and MCP dissolves once you see them as a stack rather than a menu. Skills are your capabilities. Subagents isolate heavy work. MCP connects Claude to the outside world. Commands are simply skills you invoke by hand. And plugins are the wrapper that lets you distribute any combination of them.

Start with a skill — it is the fastest to write and the easiest to reason about — then add MCP for access, subagents for delegation, and a plugin when it is worth sharing. For the full mechanics of the two most important primitives, read the complete guides to [Claude Code skills](/blog/claude-code-skills) and [Claude Code plugins](/blog/claude-code-plugins).

---

## Related Resources

- [Claude Code Skills: The Complete Guide](/blog/claude-code-skills)
- [Claude Code Plugins: The Complete Guide](/blog/claude-code-plugins)
- [Best Claude Code Skills (2026): Tested & Ranked](/blog/best-claude-code-skills)
- [Best Claude Code Plugins (2026): Tested & Ranked](/blog/best-claude-code-plugins)
- [Claude Skills Marketplace: Find, Install & Publish Skills](/blog/claude-skills-marketplace)