Claude Code Skills vs MCP Servers: When to Use Each

Claude Code offers two primary extension mechanisms: Skills (prompt-based templates invoked via slash commands) and MCP servers (external processes that provide tools via the Model Context Protocol). They solve different problems, and picking the right one can save you significant setup time and complexity.

This guide breaks down the differences, gives you a decision framework, and walks through real examples of when each approach shines.

What Are Skills?

Skills are markdown files (typically named SKILL.md) that contain a system prompt template. When you invoke a skill via a slash command like /review or /tdd, Claude Code loads that prompt as context and follows its instructions.

A skill file looks like this:

---
name: Code Review
description: Thorough code review with security focus
command: /review
---

# Code Review Skill

You are a senior code reviewer. When the user provides code or
a file path, review it for:

1. Security vulnerabilities (injection, XSS, auth issues)
2. Performance problems (N+1 queries, memory leaks)
3. Code clarity and maintainability
4. Test coverage gaps

Format your review as a numbered list of findings,
each with severity (Critical/Warning/Info) and a fix suggestion.

Skills are stored in your project's .claude/skills/ directory or installed from community repositories. They're pure text -- no servers, no APIs, no infrastructure.

What Are MCP Servers?

MCP (Model Context Protocol) servers are external processes that provide Claude with tools -- callable functions that extend what Claude can do. An MCP server runs alongside Claude Code and exposes capabilities like database access, API calls, browser automation, or custom infrastructure operations.

MCP servers are configured in .claude/settings.json:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb"
      }
    }
  }
}

When Claude needs to query a database, the MCP server handles the actual connection and query execution. Claude sends structured tool calls, the MCP server executes them, and results flow back.

Key Differences

When to Use Skills

Skills are the right choice when you want to change how Claude approaches a task without giving it fundamentally new capabilities. Choose skills when:

• You want a specialized workflow -- code review, TDD, documentation writing, commit message formatting. Claude already has the tools (file read/write, bash); you're guiding how it uses them.
• You need team-specific conventions -- your team's code style, architectural patterns, testing standards. A skill can encode "how we do things here."
• You want quick shareability -- skills are just markdown files. Drop one in a GitHub repo and anyone can use it. Try them in our Skills Playground before installing.
• You don't want infrastructure -- no servers to maintain, no processes to monitor, no dependencies to update.

Skill example: TDD workflow

---
name: TDD
command: /tdd
---

# Test-Driven Development

Follow strict TDD for every code change:

1. Write a failing test FIRST
2. Run it to confirm it fails
3. Write minimal code to pass
4. Run tests to confirm green
5. Refactor if needed
6. Run tests again

Never write implementation before a test exists for it.

When to Use MCP Servers

MCP servers are the right choice when Claude needs to do something it can't do with its built-in tools. Choose MCP when:

• You need external data access -- databases, APIs, cloud services. Claude can't query your Postgres database with a prompt; it needs an MCP server with a connection.
• You need authenticated operations -- Slack messages, Jira tickets, GitHub operations beyond what the gh CLI covers. MCP servers can hold credentials and manage auth flows.
• You need browser or UI automation -- tools like Puppeteer or Playwright, wrapped in an MCP server, let Claude interact with web applications.
• You need specialized computation -- image processing, data analysis, ML inference. MCP servers can run arbitrary code in any language.

MCP example: Slack integration

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"],
      "env": {
        "SLACK_TOKEN": "xoxb-your-token"
      }
    }
  }
}

With this configured, Claude can read channels, post messages, and search Slack -- capabilities that no prompt template could provide.

Using Both Together

Skills and MCP servers are complementary. A common pattern is to pair an MCP server (providing the capability) with a skill (guiding how Claude uses that capability).

Decision Framework

Ask yourself these questions:

1. Does Claude already have the ability to do this? (file I/O, bash, web fetch) -- If yes, use a skill to guide the approach.
2. Does Claude need new capabilities? (database access, API calls, specialized tools) -- If yes, use an MCP server.
3. Do I want to enforce a workflow? -- Use a skill for advisory guidance, or hooks for hard enforcement.
4. Is this something I'd share with my team? -- Skills are trivially shareable. MCP servers require each person to run the server.

Most teams end up with a handful of MCP servers for infrastructure access and a larger collection of skills for workflow standardization. That's a healthy pattern.