The core difference
Claude Skills are pre-loaded behavior instructions. You install a skill by dropping a folder with a SKILL.md into ~/.claude/skills/. Claude reads it at startup. No server, no runtime connection, no external process. The skill encodes a workflow, a reasoning pattern, or a domain-specific behavior — and Claude applies it when your request matches the skill's description.
MCP (Model Context Protocol) is an active connection layer. An MCP server runs alongside Claude and exposes tools — read from a database, write to a file, call an API, run a query. Claude can call these tools at runtime during a conversation. The server must be running for the tools to be available.
The simplest mental model: skills change how Claude thinks; MCP changes what Claude can do.
Claude Skills in depth
A skill is passive. Once installed, Claude knows it's there and invokes it when appropriate. The user doesn't need to activate it manually or name it. Skills work well for:
- Repeatable workflows — audit checklists, deployment runbooks, code review protocols
- Domain-specific reasoning — understanding a specific codebase pattern, applying a company style guide
- Output format constraints — always produce a certain JSON shape, always follow a specific commit message format
- Template-based generation — populate a specific report structure, generate code following internal conventions
Skills have no runtime overhead. They're just text in Claude's context at session start. There's nothing to maintain, nothing to keep running, nothing that can crash.
Limitation: Skills can't fetch live data, read your actual files at runtime, or call external services. If the task requires interacting with the real world at execution time, a skill alone won't do it.
MCP in depth
MCP gives Claude tools it can call during a conversation. An MCP server exposes a set of functions — think of them as API endpoints — and Claude decides when to call them based on the task at hand. Common MCP use cases:
- Database access — read and write to Postgres, SQLite, or a Supabase project
- File system operations — read files, list directories, write output to disk
- API calls — fetch data from GitHub, Notion, Linear, or any HTTP endpoint
- Live data — check a service's current status, pull the latest metrics, read real-time logs
MCP servers can be local (running on your machine) or remote (hosted services). Configuring an MCP server requires editing Claude's settings file and starting the server process before or alongside Claude Code.
Limitation: MCP servers must be running when Claude needs them. They add setup complexity, dependency on external processes, and potential failure points. They're more powerful but more fragile than skills.
Comparison at a glance
| Skills | MCP | |
|---|---|---|
| Setup complexity | Low — drop a folder, restart | Medium — run a server, configure Claude |
| External connections | None | Yes — required |
| Runtime overhead | None | Server must be running |
| Live data access | No | Yes |
| Best for | Workflows, templates, reasoning patterns | Tools, APIs, databases, file I/O |
| Can fail silently? | No — it's just text | Yes — server might be down |
| Shareable as a ZIP? | Yes | Only the server code |
Can you use both at the same time?
Yes, and it's often the right answer. A skill handles the "how" — the workflow, the reasoning steps, the output format. MCP handles the "what" — the actual data retrieval or action. Together they're more capable than either alone.
Example: you have an Env Doctor skill that knows the workflow for auditing environment variables. You also have an MCP server connected to your project's secret manager. The skill guides Claude through the audit; MCP fetches the actual live values to check against. Neither alone would do the job as well.
Which should you use?
Start with the simpler question: does this task require Claude to act on the real world at runtime?
- If yes — reading a file that changes, calling an API, writing to a database — you need MCP.
- If no — the task is about reasoning, formatting, following a process, or generating content based on what the user tells you — start with a skill.
In practice, most developer productivity tasks (checklists, code review patterns, schema generation, test writing) work well as skills. Most integration tasks (database queries, API calls, file watching) need MCP.