Claude Code Plugins vs Skills vs MCP: What to Use When

A plugin is a distribution unit — a zip of skills, commands, agents and hooks your team installs with one command. A skill is a playbook that loads when a task matches its description. An MCP server is a live connection to an external system — a database, an API, a SaaS tool — that the model can query or act on mid-conversation. Most real setups use all three together, not one instead of the others. Last updated 2026-10-29 by Rakshit Yadav.

The three primitives, one paragraph each

Plugins are an installable bundle: a marketplace entry that drops a set of skills, commands, subagents and hooks into a repo in one shot, versioned and shareable across a team. A plugin doesn't add new capability on its own — it's packaging for the other primitives, so a team doesn't hand-copy a dozen files between repos or Slack a zip around.

Skills (.claude/skills/<name>/SKILL.md) are on-demand playbooks: a short description loads first, and the full body loads into context only when the current task matches it. A skill holds knowledge and procedure — how to structure a Stripe webhook, how this repo's lint rule works — not a live connection to anything.

MCP servers are the opposite of static: they're a running process the model talks to over a protocol, giving it tools and resources backed by something that changes between calls — a database's current schema, a ticket tracker's open issues, a production API. An MCP server needs its own process, auth, and usually network access; a skill needs none of that because it's just markdown.

Decision table

PluginSkillMCP server
What it actually isA bundle of skills/commands/agents/hooksA markdown playbookA running server process
DistributionOne install command via a marketplaceCopy a folder, or installed as part of a pluginRegistered in config, often per-machine
State accessNone by itselfNone — static textLive — queries the real system each call
Auth needsNoneNoneUsually yes — API key, OAuth, or a DB connection string
Team-sharingBest — one command, versionedGood — commit the folder to the repoHarder — each teammate needs their own credentials wired up
Use whenYou want to hand a teammate your whole setup at onceThe task needs a procedure the model doesn't already knowThe task needs a fact that's only true right now, not at write-time

The split between "teach it" and "connect it" mirrors the Cursor-side question — see Cursor Skills vs MCP Servers.

Scenario 1: shipping a Stripe webhook flow

This is a skill job. The procedure — read the raw body before parsing, verify the signature, insert the event id under a unique constraint before running side effects — is fixed; it doesn't change between calls, so there's nothing to connect to live. Write it once as .claude/skills/stripe-webhooks/SKILL.md, and it loads whenever a task touches app/api/webhooks/stripe. If this same playbook needs to ship to every project your team starts, wrap it (plus the matching lint rule and command) into a plugin so new repos get it with one install instead of a copy-paste.

Scenario 2: enforcing a lint rule

Also a skill, but a thin one — or a hook if it must be unskippable. A lint convention ("no raw SQL in a route handler", "always use the shared logger") is static knowledge, so a short skill or a CLAUDE.md line covers the common case. If the rule has to hold even when the model forgets or disagrees — say, blocking a commit that touches .env — that's a job for a hook, not a skill, because hooks run unconditionally on an event instead of being something the model chooses to consult. Neither needs an MCP server: there's no live external state involved.

Scenario 3: reading live DB schema

This is an MCP server job, and only an MCP server. A skill can describe your schema as of the day someone wrote it, but a migration two weeks later makes that description wrong, and the model has no way to know. An MCP server that connects to the actual database returns the current schema on every call, so a generated query is checked against what's really there instead of a stale snapshot. Package the connection details once and the whole team gets the same live view — the thing a static file can never provide.

Where AgenticKit fits

AgenticKit's 34 subagents ship with the skills and commands they call, installed as one unit the same way a plugin would be — so a new repo gets the whole set in one command instead of thirty small files copied by hand. It doesn't ship MCP servers itself, because those need your own credentials and your own external systems; wire up the ones you need (a database, a ticket tracker, a deploy API) alongside the agents, and the agents will reach for them when a task needs live state instead of a static playbook.

Related pages

Frequently asked questions

  • Can a plugin include an MCP server?
    A plugin bundles skills, commands, agents and hooks for distribution, but an MCP server is a running process with its own auth and config, not a static file — a plugin's install step can point at an MCP server's config, but it can't carry the server's credentials for you. You still wire those up per machine.
  • Do I need an MCP server if I already have a skill describing my API?
    Only if the API's state changes between calls. A skill describing fixed conventions (auth header format, error envelope shape) is fine as static text. A skill describing current data (today's open tickets, current inventory) will go stale — that's what an MCP server is for.
  • Is a plugin just a folder of skills?
    It can include skills, but also commands, subagents and hooks together, versioned and installed as one unit through a marketplace. A lone skill folder works too — a plugin just makes sharing that bundle across repos or teammates a single command instead of a copy-paste.
  • Which one should I reach for first on a new project?
    Start with skills for anything that's a procedure, not a live fact. Add MCP servers only when a task genuinely needs real-time external state. Reach for a plugin once you're copying the same skill/command/hook bundle into a second or third repo.

Ship all three in one install

AgenticKit's 34 agents come packaged with the skills, commands and hooks they call — add your own MCP servers alongside them.