Claude Code Skills vs Plugins vs MCP Servers: Which One Should You Use?

The terms "skills," "plugins," and "MCP servers" appear together constantly in Claude Code documentation and discussions, and they're frequently conflated. They're three different things that serve different purposes — and using the wrong one for a given need produces worse results than using the right one.

Here's a precise explanation of what each one does, when to use it, and why backends work best in Plugin form.

MCP Servers: Tool Access

An MCP server is a running program that speaks the Model Context Protocol — Anthropic's open standard for connecting AI agents to external systems. MCP servers give Claude Code access to things it can't do on its own: read a database, trigger a GitHub Action, control a browser, call an external API.

The agent interacts with an MCP server by calling the tools the server exposes. A Postgres MCP server might expose query_database, list_tables, and describe_table. A GitHub MCP server might expose create_issue, get_pull_request, list_files_in_repo.

What MCP servers don't do: teach the agent how to use themselves effectively. If the agent has never worked with your specific database schema before, a Postgres MCP server gives it the ability to run queries — but the agent still has to figure out what queries to run, what your tables are called, and what patterns your codebase follows. That knowledge has to come from somewhere else.

When to use an MCP server:

• You need to connect Claude Code to a specific external system
• The agent's usage pattern is simple enough that it doesn't need explicit workflow guidance
• You want universal compatibility — MCP servers work with Claude Code, Cursor, Windsurf, and any other MCP-compatible host
• You're a developer comfortable configuring JSON and debugging connection issues

How to configure (in claude_desktop_config.json or via /mcp):

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://..."]
    }
  }
}

Skills: Agent Intelligence

A Skill is an instruction set stored in your repo (as a SKILL.md file) that teaches Claude Code how to do something correctly and repeatably. Skills don't give the agent new tool access — they shape how it uses the tools it already has.

A typical Skill contains:

• The trigger condition (when should this skill activate?)
• The step-by-step pattern to follow
• Common mistakes to avoid
• Output format expectations

For example, a "code review" Skill might instruct the agent to read every file changed in the current diff, evaluate against a specific checklist, and format findings in a particular structure — rather than performing a generic review based on training data.

Skills solve the problem of knowledge that isn't in the code. Your project has conventions, patterns, and decision rationale that live in your team's heads. A Skill encodes those conventions in a place the agent reads at the right moment.

What Skills don't do: give the agent access to external systems. A Skill that says "query the database for the current user's orders" doesn't work without a database connection (MCP server) in place.

When to use a Skill:

• You want Claude Code to follow a specific workflow repeatedly and consistently
• There's a pattern in your codebase that isn't obvious from reading the code alone
• You need the agent to know something about how your project works, not just what it contains
• You want to encode lessons from past mistakes so the agent doesn't repeat them

Install a Skill:

# From the official marketplace
claude skill add context7/docs-lookup

# From a URL
claude skill add https://github.com/yourorg/skills/tree/main/database-conventions

Plugins: Skill + MCP + Lifecycle Together

A Plugin is a packaged combination of a Skill, an MCP server (or CLI), and lifecycle hooks — installed as a single unit from a marketplace.

Instead of:

• Finding and configuring an MCP server
• Finding and installing a Skill that teaches the agent to use that server
• Writing lifecycle hooks to verify the connection at session start

You do:

• Install the Plugin

The lifecycle hooks are particularly important. A well-designed Plugin includes a SessionStart hook that verifies the backend connection is valid before the first prompt. If the connection is broken, you know immediately — not when you're deep in a session and a query fails unexpectedly.

Plugins are available in Claude Code's official marketplace and Codex's plugin marketplace. Cursor 2.5+ supports plugins via team marketplaces (admin installs the repo as a team source) or local symlink for development; for most individual setups Cursor reaches the same capability through the MCP delivery path.

When to use a Plugin:

• The tool you're connecting is complex enough to need both access and workflow guidance
• You want a turnkey setup without manual configuration steps
• You're connecting a backend, payment system, or other multi-faceted service
• The host supports it (Claude Code and Codex via marketplace; Cursor 2.5+ via team marketplace or MCP delivery)

Why Backends Work Best as Plugins

A backend isn't a single-purpose tool. It's a system with tables, relations, auth, permissions, server-side logic, and async jobs. To use a backend effectively, an AI coding tool needs:

• Access to read the schema and call APIs (MCP / CLI)
• Knowledge of how to interpret the schema, compose queries correctly, and call server-side flows in the right order (Skill)
• Verification that the connection is working before the session begins (SessionStart hook)

A bare MCP server gives you (1) and nothing else. A Plugin gives you all three.

Momen delivers this as a Plugin for Claude Code and Codex. The Plugin includes:

• A CLI that handles schema codegen, typed GraphQL operations, and Actionflow calls
• A Skill that teaches Claude Code and Codex the connection recipe, schema reading pattern, and how to call server-side logic correctly
• A SessionStart hook that runs a version check and backend connection verification before the first prompt

The Momen Plugin installs in two steps on each host:

Claude Code:

/plugin marketplace add momen-tech-org/momen-nocode-plugin
/plugin install momen-nocode@momen

Codex:

codex plugin marketplace add momen-tech-org/momen-nocode-plugin
codex plugin add momen-nocode@momen

Cursor (and other MCP-compatible tools — Windsurf, Cline, Claude Desktop) — add to your MCP config:

{
  "mcpServers": {
    "momen": {
      "command": "npx",
      "args": ["-y", "momen-mcp@latest", "mcp"]
    }
  }
}

The difference in practice: with a bare Postgres MCP, the agent knows it can run queries but has to derive your schema every session. With Momen's Plugin, the agent knows your schema, knows which operations to use, and verifies the connection before starting — every session.

Mapping Each to Claude Code's Hosts

Capability	Claude Code	Codex	Cursor
MCP Servers	✓	✓	✓
Skills	✓ (SKILL.md)	✓ (SKILL.md)	Via .cursor/rules
Plugins	✓ (native)	✓ (native)	✓ (2.5+, team/local); MCP delivery otherwise

The Decision

• Building on a specific external API (GitHub, Slack, Notion)? Use an MCP server.
• Want Claude Code to follow a consistent workflow for a recurring task? Add a Skill.
• Connecting a backend, database service, or multi-faceted tool? Use a Plugin — or, for Cursor, the MCP equivalent from the same provider.
• Not sure which host your users will be on? MCP servers work everywhere; Plugins work on Claude Code and Codex; deliver both.

The search term "Claude Code skills vs plugins" often comes from people who've installed one without the other and noticed the gap. The pattern isn't "pick one" — it's "understand which layer each one covers, and use the format that covers all three layers at once when you need them all."