Claude Skills vs Agents vs MCP: When to Use Each

Claude skills vs agents vs MCP isn't a contest, because each one solves a different problem. Skills give Claude a procedure. Subagents give it a separate worker with a clean context. MCP servers give it access to tools and data outside your machine.

Most confusion comes from using one where another belongs.

I use all three every day. This article lays out what each one actually is, a decision table you can apply in ten seconds, and the combination that works best in practice.

The one-line definitions#

• Skill: a folder with a SKILL.md file of instructions that Claude loads into the current conversation when a request matches its description.
• Subagent: a separate Claude instance, defined in a markdown file, with its own context window, tool permissions and model, that does a job and returns a result.
• MCP server: a connector that speaks the Model Context Protocol, the open standard its maintainers describe as "a USB-C port for AI applications," giving Claude tools such as GitHub, Notion or a database.

Anthropic's own help center draws the line between the first and third cleanly: MCP connects Claude to external services, while skills provide the procedural knowledge for using them.

Claude skills vs agents vs MCP compared#

When should you use a skill?#

Use a skill when the task is a procedure you'd otherwise explain again, and when it benefits from everything already said in the conversation:

• A release checklist, a code review rubric, a content audit
• A multi-step workflow where you answer questions along the way
• A task that writes or changes files as part of your current work

Skills are cheap to keep around because only their name and description sit in context until a request matches. My guide to building Claude skills covers the format.

When should you use a subagent?#

Use a subagent when the task benefits from a clean slate or from running in parallel. Claude Code includes built-in subagents: Explore searches a codebase, Plan researches while you're in plan mode, and a general-purpose agent handles multi-step work. You can define your own in .claude/agents/ with a description, a tool list and a model.

Three situations make a subagent the right call:

1. Fresh eyes. When Claude reviews work it just wrote, it tends to find its own output acceptable because it knows what it meant. A subagent sees only what's on the page. As one practitioner's rule of thumb puts it: if you're asking Claude to critique something it helped create, use an agent.
2. Parallel work. Three subagents can research three approaches at once and report back.
3. Noisy output. Test runs, long logs and documentation dumps stay inside the subagent. Only the summary lands in your main session, which keeps it fast and cheap.

The trade-off: a subagent can't see your conversation, so you must pass it everything it needs, and running many at once uses more tokens in total.

When should you use an MCP server?#

Use MCP when Claude needs to reach something it can't see from your files: your GitHub issues, a Postgres database, a design tool, your notes app. In Claude Code, a remote server is one command:

claude mcp add --transport http notion https://mcp.notion.com/mcp

Two practical rules from the Claude Code MCP documentation:

• Only connect servers you trust. Servers that fetch external content can expose you to prompt injection.
• Prefer a CLI when one exists. Tools like gh add no tool listings to your context, so they're often lighter than the equivalent MCP server.

I list the servers worth installing in the best MCP servers for Claude Code.

How to combine skills, subagents and MCP#

The strongest setups use all three, each for its own job. Here's a pattern I use for content:

1. An MCP server or CLI gives Claude access to search data and the live page.
2. A skill holds the procedure: pick the keyword, check it against existing pages, write the brief, then draft.
3. A subagent with read-only tools audits the draft against the rules, without the bias of having written it.
4. A hook runs the final script check, because some rules must hold every single time.

If you work in plain markdown, the same pattern powers an AI knowledge base: MCP or file access to your vault, a skill for ingesting sources, and a subagent that checks new notes for unsupported claims. That's the architecture behind the AI Brains I build.

A quick decision checklist#

Ask these in order:

• Does Claude need to reach an outside system? Add an MCP server or use a CLI.
• Is it a procedure you'd repeat? Write a skill.
• Does it need fresh eyes, parallel runs or to hide noisy output? Delegate to a subagent.
• Must it happen every time, no matter what? Make it a hook.
• Is it a rule for every session in the repository? Put it in CLAUDE.md.

Learning when to reach for which is most of what separates a Claude Code user from a power user. It's also the backbone of weeks two and three in my Claude Code course.