Skills vs Subagents vs Plugins vs Hooks vs Commands vs MCP: Which Do You Need?

Claude Code has six extension points. A skill is a Markdown instruction file Claude loads on demand; a subagent is a separate Claude with its own context window and tool list; a plugin is a versioned bundle that ships skills, agents, hooks and MCP servers together; a hook is a shell command or endpoint that runs deterministically at a lifecycle event; a slash command is the older, single-file form of a skill; and an MCP server is an external process that gives Claude new tools. They overlap in what they achieve, but not in where they run or who triggers them, and that is the axis to decide on.

How do the six extension points compare?

What is a Claude Code skill?

A skill is a folder whose SKILL.md carries YAML frontmatter and Markdown instructions. The folder name is the command: release-notes/ becomes /release-notes. Only the description is loaded at startup; the body enters the conversation when the skill is invoked, which is why a long skill costs almost nothing until you use it. Claude reads that description to decide whether to invoke the skill on its own, and you can steer that with disable-model-invocation: true (only you can run it) or user-invocable: false (only Claude can).

---
name: release-notes
description: Draft release notes from merged PRs. Use when the user asks for a changelog or release notes.
allowed-tools: Bash(git log:*), Read
---

Collect the PRs merged since the last tag with `git log`, group them by
area, and write the notes in the style of CHANGELOG.md.

The frontmatter is where the interesting decisions are. allowed-tools pre-approves tools for the turn the skill runs, context: fork runs it inside a subagent so the search results never land in your main window, and hooks attaches lifecycle hooks scoped to that skill. Supporting files (reference.md, scripts/) sit beside SKILL.md and are read only when the instructions point at them. That is the reason the site's install command clones the whole folder rather than fetching one file.

Reach for a skill when the thing you want is a repeatable procedure with judgement in it: how this repo writes migrations, how to review a PR, how to run and interpret the flaky end-to-end suite. Browse the skills directory or start with a category such as testing or security.

What is a subagent, and how is it different from a skill?

A subagent is a specialised Claude that handles a task in its own context window and returns a summary. Its file is Markdown with frontmatter: a required name and description, then optional tools, disallowedTools, model, permissionMode, skills to preload, hooks, and memory.

---
name: test-runner
description: Runs the test suite and reports only the failures. Use after any code change.
tools: Bash, Read, Grep
model: sonnet
---

Run the project's test command. Report each failing test with the assertion
message and the file it lives in. Do not paste passing output.

The deciding factor between a skill and a subagent is context isolation. A skill's instructions and the work it produces stay in your conversation; a subagent's exploration, logs and false starts stay in the subagent's, and only its report comes back. If the job will flood your window with output you will never reference again, that is a subagent. If the job needs everything you have already discussed, that is a skill. Claude Code ships built-in subagents (Explore, Plan, general-purpose) and community ones are listed in the agents directory. Note that as of Claude Code v2.1.198 the /agents command no longer opens a creation wizard; you write or ask Claude to write the file directly.

What is a plugin?

A plugin is the distribution wrapper. It is a directory with a .claude-plugin/plugin.json manifest and any combination of skills/, agents/, hooks/hooks.json, .mcp.json, .lsp.json and bin/. Installing one installs everything inside it, versioned together, and its skills are namespaced so hello/ in my-plugin is /my-plugin:hello.

my-plugin/
├── .claude-plugin/plugin.json   name, description, version
├── skills/<name>/SKILL.md       becomes /my-plugin:<name>
├── agents/<name>.md
├── hooks/hooks.json
└── .mcp.json

Plugins are installed from marketplaces: /plugin marketplace add owner/repo registers a catalog, then /plugin install name@marketplace installs from it at user, project or local scope. Anthropic runs an official marketplace (claude-plugins-official, added automatically) and a reviewed community one (anthropics/claude-plugins-community). Choose a plugin when you are sharing: with a team, with the public, or with yourself across many machines. For a personal workflow in one repo, a bare .claude/skills/ folder is less ceremony. Cult of Claude indexes the skills and agents themselves, not plugin manifests, so an entry here may come from a plugin's skills/ directory and still install as a plain skill.

What is a hook, and why is it the only deterministic one?

Hooks are user-defined shell commands, HTTP endpoints, MCP tool calls, prompts or subagents that Claude Code runs at fixed points in its lifecycle: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, and a long tail of others. Everything else on this page is probabilistic: Claude decides whether to invoke a skill, whether to delegate to a subagent, whether to call an MCP tool. A hook fires every time its event fires, whether or not the model would have chosen to. That makes hooks the right tool for guarantees: format every file after every edit, block rm -rf before it runs, refuse to stop until the tests pass.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          { "type": "command", "command": "npx prettier --write \"$(jq -r .tool_input.file_path)\"" }
        ]
      }
    ]
  }
}

They are configured in ~/.claude/settings.json (all projects), .claude/settings.json (committed, shared), .claude/settings.local.json (gitignored), a plugin's hooks/hooks.json, or the frontmatter of a skill or subagent. A command hook reads JSON on stdin; exit code 0 lets the action proceed, exit code 2 blocks it regardless of anything else the hook printed. Type /hooks to see what is configured. Because a hook runs shell with your credentials on every matching event, read one before you install it, which is a large part of why this site shows what an entry reaches for before you copy the command.

What is a slash command, and should I still write one?

A slash command is a single Markdown file in ~/.claude/commands/ or .claude/commands/; typing /name pastes its contents as your prompt, with $ARGUMENTS substituted. They still work, and the same /name menu lists them next to skills. Anthropic's docs now say to prefer skills for new work, because a skill can carry supporting files, restrict tools, fork into a subagent and be invoked by Claude automatically. Roughly one in six skill entries in this directory is a slash-command file rather than a skill folder; the site detects that from the source path and prints the ~/.claude/commands/ install target so you are not told to put a command where skills go.

What is an MCP server?

MCP, the Model Context Protocol, is the open standard Claude Code uses to talk to external tools and data: issue trackers, databases, browsers, design tools. An MCP server is a separate process (local over stdio, or remote over HTTP) that advertises tools, and Claude calls them as mcp__<server>__<tool>. You add one with claude mcp add --transport http name https://… or claude mcp add --transport stdio name -- npx -y some-server, at local, project (checked-in .mcp.json) or user scope, and inspect it with /mcp.

The distinction from a skill is capability versus procedure. An MCP server gives Claude something it could not do before, such as querying Postgres. A skill tells Claude how to use what it already has. They combine well: a skill that says "use the sentry tools to triage the newest issue" is only useful once the Sentry MCP server exists. Cult of Claude does not index MCP servers; entries whose description turns out to be an MCP server rather than a Claude Code skill are filtered out by the quality gate.

Which one do I need?

1. Must it happen every time, with no model in the loop? A hook.
2. Does Claude need a capability it does not have (an API, a database, a browser)? An MCP server, possibly delivered by a plugin.
3. Is it a procedure Claude should follow, and the result belongs in your conversation? A skill. If you only need a prompt template with no files or tool rules, a slash command still does the job.
4. Will the work produce a lot of noise you do not want in your context (searching, running suites, reading logs)? A subagent, or a skill with context: fork.
5. Do you need to hand the whole setup to someone else, versioned? Wrap it in a plugin and publish a marketplace.

Most real setups use several at once: an MCP server for the tool, a skill for the procedure, a hook to enforce the one rule that must never be skipped, and a plugin so the team installs all three with one command. Start with the skills and agents already published, read the file before you install it, and see how to install a skill for the exact commands.