Skill vs plugin vs MCP server: what each one is and when to use it

A skill is a directory containing a SKILL.md file with a name and a description in its frontmatter, followed by instructions. It may include reference files and scripts. The agent reads only the description at session start; when a request matches, it loads the full file and follows it. The format is open and shared by Claude Code, Cursor, Codex, Gemini CLI and GitHub Copilot, which is why one skill from GitHub installs into all of them with npx skills add.

A skill gives the model no new ability. It cannot reach a database or a browser by itself. What it changes is judgement and procedure: how to review a diff, what a landing page must not do, which steps to take before claiming a bug is fixed. Cost: a line or two of description per installed skill on every turn, plus the whole file when it triggers.

my-skill/
  SKILL.md        # frontmatter: name, description; then instructions
  reference.md    # optional
  scripts/        # optional, runs with your permissions

In Claude Code, a plugin is a repository with a .claude-plugin/plugin.json manifest that can carry slash commands, subagent definitions, hooks, MCP server configuration and skills together. You add a marketplace with /plugin marketplace add owner/repo and install with /plugin install name@marketplace. The plugin itself does nothing at run time; it is the unit of distribution and versioning for the things inside it.

The word is Claude Code specific. Cursor calls its equivalents extensions and rules, Gemini CLI has extensions, Codex has none of this and reads skills and AGENTS.md directly. A plugin can contain skills, so "plugin or skill" is often a false choice: the skill is the content, the plugin is the box it ships in. Cost: the sum of whatever it contains, and hooks run automatically on events, which is the part to read before installing.

/plugin marketplace add anthropics/claude-plugins-official
/plugin install frontend-design@claude-plugins-official

An MCP server is a separate program that speaks the Model Context Protocol over stdio or HTTP and exposes tools (functions the agent can call), resources (data it can read) and prompts. You register it in the agent's configuration: .mcp.json or claude mcp add for Claude Code, .cursor/mcp.json for Cursor, ~/.codex/config.toml for Codex, settings.json for Gemini CLI. Once connected, the agent can query Postgres, drive a browser, read Linear tickets or call your internal API, none of which a Markdown file can do.

The cost is different in kind. Every connected server's tool definitions are sent with every turn, so a server with forty tools can consume thousands of tokens before you type anything. And it is code running on your machine with your credentials, so it needs the scrutiny you would give any dependency.

claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres postgresql://localhost/app

The table condenses the three, plus the always-on instruction file (CLAUDE.md, AGENTS.md, GEMINI.md, Cursor rules) that people most often confuse with a skill.

                  Skill              Plugin (Claude Code)      MCP server             Rules file
----------------  -----------------  ------------------------  ---------------------  ---------------------
What it is        SKILL.md folder    Manifest + bundled parts  Separate process       CLAUDE.md / AGENTS.md
Gives the agent   Procedure, taste   Distribution, versioning  New tools and data     Standing constraints
Loaded            When task matches  Parts load by their rule  Tool list every turn   Every turn
Token cost idle   ~1 line each       Sum of contents           Hundreds to thousands  Whole file
Works in          All major agents   Claude Code only          All major agents       Per agent, own name
Install           npx skills add     /plugin install           Config file entry      Commit the file
Can run code      Only via scripts   Hooks run automatically   Yes, that is the job   No
Read before use   SKILL.md, scripts  Hooks, MCP entries        Source, permissions    The file

Reach for a skill when the problem is that the agent does not know how: it writes tests after the code, it designs generic screens, it reviews with nitpicks. Anything a senior colleague would fix by explaining a procedure is a skill. It is the cheapest option, works everywhere, and can be read in full before installing.

Reach for an MCP server when the problem is that the agent cannot: it needs to read production logs, run queries, open a browser, or file a ticket. If the capability already exists as a CLI the agent can call from a shell, you may not need MCP at all; a skill that explains the CLI is lighter.

Reach for a plugin when you are distributing to a team in Claude Code and the package needs more than instructions: a hook that runs the formatter after every edit, a subagent with its own model, a pre-configured MCP server, plus the skills that use them. One install, one version number.

Reach for the rules file when the constraint is short and always true: the package manager, the branch naming, the language of commit messages. If the rules file is growing past a screen, the long parts are procedures and belong in skills.

Installing an MCP server for knowledge. A "React best practices" MCP server that returns documentation on request pays its tool-definition cost every turn and adds a network round trip; the same content as a skill loads once, when needed, from disk.

Installing thirty skills at once. Each adds a description line to every turn, and skills with overlapping descriptions compete; the agent picks one and you do not see which. Install the few you will actually use, and disable or remove the rest.