Skip to content

Skills, Plugins, MCP, and LSP

Claude Code is extensible. Out of the box it can read and edit code; the real leverage comes from teaching it workflows, giving it new tools, and connecting it to external systems. Four terms come up constantly — skills, MCP, LSP, plugins — and people mix them up because they sound like four parallel options. They're not. Three of them are capabilities — different axes along which you make the agent more useful — and the fourth, the plugin, is the container that ships them. Get that one distinction and the rest falls into place.

Who this is for. This page is the vocabulary — the mental model everyone should share. Already fluent and just want to know what to install and reach for? Skip to Catalog.

Skills, MCP, LSP, plugins — three capabilities and one container, untangled — 1 min 46 s.

The mental model: three capabilities + one container

Each capability extends the agent along a different axis. The plugin isn't a fourth axis — it's the box the other three arrive in.

  • Skill → extends its know-how. Teaches the agent a procedure it could technically do anyway, but should do a specific way, every time.
  • MCP → extends its reach. Connects it to an external system it otherwise can't see or touch.
  • LSP → extends its code intelligence. Gives it real compiler/type diagnostics instead of inferring correctness from text.
  • Plugin → packages the above. A shareable, versioned bundle that ships any mix of skills, MCP servers, LSP servers (plus subagents and hooks).

Skills — know-how

A skill is a packaged procedure: a SKILL.md file with instructions Claude follows when a task calls for it. Each skill has a short description in its frontmatter, and Claude auto-invokes the skill when your request matches that description — or you can run it directly as a slash command (/skill-name). Because a skill's body loads only when it's used, you can keep long checklists and reference material around at almost no context cost until they're needed.

A skill adds no new capability — the agent could already write the code or run the command. What it adds is judgment: do it this way, in this order, with these guardrails. Reach for one when you keep pasting the same multi-step procedure into chat, or when a section of CLAUDE.md has grown from a fact into a procedure.

Skills follow the open Agent Skills standard, so the same skill format works across multiple AI tools. Slash commands and skills have effectively merged: a file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both create /deploy.

MCP servers — reach

An MCP server connects Claude to an external tool or data source — live documentation, a browser, a database, an internal API. This is the axis of reach: a skill changes how the agent behaves with what it already has, while MCP hands it something new to act on — a system it genuinely cannot see without the connector. MCP gets its own page: MCP and Config.

LSP servers — code intelligence

An LSP server (Language Server Protocol) gives the agent the same live code intelligence your editor has: real type errors, go-to-definition, unused-symbol warnings, and precise symbol resolution — straight from the language's actual tooling (tsc, Pyright, rust-analyzer) rather than inferred from reading the text. The payoff is fewer hallucinated APIs and faster correct fixes, because the agent knows a call is wrong instead of guessing.

LSP is easy to confuse with MCP — both connect the agent to a separate background process. The difference is what that process is: MCP is an open, do-anything protocol you point at any system; LSP is a fixed, code-only protocol the editor world standardized years ago, and it does exactly one thing — answer questions about your source code. Reach for the LSP plugin that matches your language; reach for MCP when you need to touch something outside the code.

Plugins — the container

A plugin is a distributable bundle. One plugin can ship any combination of: skills, subagents (custom agents), hooks (commands that run at lifecycle events), MCP servers, and LSP servers. Plugins install from a marketplace, are versioned, and namespace their skills (/plugin-name:skill-name) so two plugins never collide. Crucially, a plugin is not itself a capability — it's how you ship the three above to a whole team at once instead of copying files around. That's why the same MCP server can arrive either hand-configured or bundled inside a plugin: the plugin is just the delivery mechanism.

Slash commands — the trigger, not a capability

One more term that belongs on the invocation side, not the capability side. A slash command is just how you call something by name — /plan, /code-review, /memory. Some are built in; most others are skills (yours or a plugin's) surfaced as a command. Mentally: slash command = the trigger; skill = the thing it triggers.

Recap

Term Kind What it extends Reach for it when
Skill Capability Know-how — a procedure done a specific way You keep repeating the same multi-step routine
MCP Capability Reach — access to an external tool or data source The agent needs to touch a system it can't see
LSP Capability Code intelligence — real diagnostics, not guessed You want type errors caught precisely in your language
Plugin Container Nothing itself — packages the three above You want to share a capability across the team
Slash command Invocation Nothing — it's the /name trigger You want to fire a skill or built-in by name

Subagents

A subagent is a separate Claude instance with its own context window, system prompt, and tool set, spawned to handle a scoped task and report just its result back — which keeps the main thread's context clean. Plugins ship them (the codex-rescue agent from the codex plugin is one), and you can define your own: run /agents to create, edit, and manage subagents interactively, or drop a Markdown file under .claude/agents/. Reach for one when a task is self-contained and noisy — a broad codebase search, a verification pass, or a parallel workstream you don't want cluttering the main session.

Handy built-in slash commands

Beyond skills, a set of commands is built into Claude Code itself. The ones worth memorizing:

Command What it does
/agents Create, edit, and manage subagents
/clear Wipe the context window and start fresh
/compact Summarize the conversation to reclaim context and keep going
/rewind Roll back the session to an earlier checkpoint (undo recent turns and edits)
/resume Reopen a previous session and continue where you left off
/config View and change settings from inside the session
/context Show what's currently filling the context window
/model Switch the active model

How skills get auto-invoked

You rarely need to remember skill names. Each skill's description tells Claude when it applies; when your prompt matches, Claude loads and follows it automatically. That's why a good description is half the value of a skill. Some skills are marked so that only you can invoke them (disable-model-invocation), which is useful for destructive or explicit actions. When in doubt, /help lists everything available, grouped by plugin namespace.

Next: what to actually install

That's the vocabulary. The companion page, Catalog, turns it into a shopping list: how to install plugins from a marketplace, every plugin this team runs (grouped by job), and a "want X → use Y" router for picking the right one under pressure.

Sources

  • Skills — https://code.claude.com/docs/en/skills
  • Create plugins — https://code.claude.com/docs/en/plugins
  • Commands reference — https://code.claude.com/docs/en/commands
  • MCP — https://code.claude.com/docs/en/mcp