D3 · Claude Code › Cluster 5 · Skills

5.4 · Skills vs Commands vs Subagents vs MCP

Choosing the right primitive

CONCEPT Four primitives, four jobs

Claude Code gives you several extension points that are easy to confuse. The clean way to keep them apart is to ask two questions: who triggers it and what it adds.

PrimitiveWho invokesWhat it addsContext
Skill (SKILL.md)Claude (model-invoked) — also typable as /nameInstructions, bundled files & scripts loaded on demandRuns inline in the main conversation (unless context: fork)
Slash command (.claude/commands/*.md)You (user-invoked) by typing /nameA saved prompt / procedureInline. Now merged into skills — same mechanism
Subagent (.claude/agents/*.md)Claude delegates, or you target itA separate agent with its own system prompt, tools & permissionsSeparate / isolated context — returns a summary
MCP serverClaude calls the exposed toolsExternal tools & data (APIs, DBs, services) over a protocolTools appear in the main loop
🔑 In Claude Code today, custom commands have been merged into skills. A file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both create /deploy and work the same way. Old commands/ files keep working; skills just add extras (a folder for supporting files, invocation-control frontmatter, and automatic model invocation). If a skill and a command share a name, the skill takes precedence.

CONCEPT The distinctions that get tested

Skill vs. slash command — the axis is who invokes. A pure slash command is user-invoked: nothing happens until you type it. A skill is model-invoked: Claude fires it by matching the description. Since commands are now skills, you get user-invocation by adding disable-model-invocation: true to a skill — that is a "slash command."

Skill vs. subagent — the axis is context. A skill runs inline, in your current conversation, adding instructions to what Claude already sees. A subagent runs in a separate context window with its own tools and permissions, then returns only a summary — good for isolating a big, noisy task (research, exploration) so it doesn't flood the main thread. The two compose: a skill with context: fork runs as a subagent, and a subagent can preload skills as reference material.

Skill vs. MCP — the axis is internal knowledge vs. external capability. A skill is instructions and bundled files that shape how Claude works. MCP (Model Context Protocol) connects Claude to external tools and data — a Jira API, a database, a company service. Reach for a skill to teach a procedure; reach for MCP to plug in a system Claude otherwise can't touch. They're complementary: a skill can document how to use the tools an MCP server exposes.

DIAGRAM Which primitive do I need?

flowchart TD Q0["I want to extend Claude Code"] --> Q1{"Need to reach an
external system / API / DB?"} Q1 -->|"yes"| MCP["🔌 MCP server
external tools & data"] Q1 -->|"no"| Q2{"Need an isolated
context / separate tools?"} Q2 -->|"yes"| SUB["🧭 Subagent
own context, returns a summary"] Q2 -->|"no"| Q3{"Should Claude trigger it
automatically by task?"} Q3 -->|"yes"| SK["🟢 Skill (default)
model-invoked SKILL.md"] Q3 -->|"no, only when I type it"| CMD["🟠 Skill with
disable-model-invocation: true
(a slash command)"] classDef ok fill:#d4edda,stroke:#28a745,color:#155724; classDef gate fill:#ffe8cc,stroke:#ff9f40,color:#9a4a0a; classDef bad fill:#f8d7da,stroke:#dc3545,color:#721c24; class SK ok; class CMD gate; class SUB gate; class MCP bad;

CODE The same intent, three framings

Notice how "deploy" can be a user-only command or a forked subagent just by changing frontmatter — the file is a skill either way.

# 1) Model-invoked skill: Claude loads it when the task matches.
---
name: api-conventions
description: API design patterns for this codebase
---
When writing API endpoints, use RESTful naming and consistent error formats.

# 2) User-only "slash command": add disable-model-invocation.
---
name: deploy
description: Deploy the application to production
disable-model-invocation: true
---
Deploy $ARGUMENTS to production: run tests, build, push, verify.

# 3) Skill that runs AS a subagent: context: fork + an agent type.
---
name: deep-research
description: Research a topic thoroughly
context: fork
agent: Explore
---
Research $ARGUMENTS: find files, read code, summarize with file references.

TRADE-OFFS Inline skill vs. forked subagent

✅ Inline skill

  • Sees your full conversation context
  • Instructions apply alongside ongoing work
  • Cheapest way to add a procedure or convention

✅ Forked subagent (context: fork)

  • Isolated context — keeps the main thread clean
  • Own tools/permissions/model
  • But: no conversation history; needs an explicit task, not just guidelines

EXAM TRAPS

Trap: "Slash commands and skills are separate systems." → In current Claude Code they've merged: a command file and a SKILL.md both make a /name. A "slash command" is just a skill with disable-model-invocation: true.
Trap: "Use a subagent to add a procedure to the current chat." → A subagent runs in a separate context and returns a summary. To inject instructions into the current conversation, use a skill.
Trap: "Use a skill to connect to an external API." → External tools/data are the job of an MCP server. A skill supplies instructions and bundled files; it can document how to use MCP tools but isn't the connector.
Trap: "Skills and subagents don't mix." → They compose both ways: a skill with context: fork runs as a subagent, and a subagent can preload skills as reference material.

PRACTICE

Q1 · What single frontmatter field turns a model-invoked skill into a user-only "slash command"?

disable-model-invocation: true. Claude will no longer auto-trigger it; it runs only when you type /name. Since commands are now skills, this is exactly the slash-command behavior.

Q2 · You want a research task that won't clutter your main conversation. Skill or subagent?

A subagent (or a skill with context: fork, which runs as one). It executes in an isolated context with its own tools and returns just a summary, keeping the main thread clean. An inline skill would run in your current context.

Q3 · Jira, a Postgres database, and an internal HTTP service — which primitive?

MCP servers. MCP is the primitive for connecting Claude to external tools and data. A skill could then document the procedure for using those MCP tools, but the connection itself is MCP.