Anthropic’s Skills announcement created confusion about when to use which Claude Code feature. I’ve seen the same mistake repeatedly: engineers converting all their slash commands to skills, thinking that’s the “advanced” approach. This is backwards. Skills should compose slash commands, not replace them.

The Problem

Claude Code offers multiple features for different use cases:

• Agent Skills - Modular, agent-invoked solutions for managing related operations
• MCP Servers - Model Context Protocol for external integrations
• Sub-agents - Isolated context windows for parallel work
• Custom Slash Commands - Manual prompt triggers for one-off tasks
• Hooks - Lifecycle event automation
• Plugins - Distribution mechanism for extensions
• Output Styles - Customizable response formatting

The question I keep getting: “When do I use which one?”

The Core Foundation

Everything in agentic coding reduces to four fundamentals: context, model, prompt, and tools. Every feature builds on these. Understanding this foundation makes feature selection obvious.

How I Decide

Here’s the decision tree I use:

Feature Hierarchy

I think of these as layers, not interchangeable options:

Skills (Orchestration Layer)

• Manage multiple related operations
• Compose slash commands, MCP servers, and sub-agents
• Use progressive disclosure to preserve context
• Automatic invocation by agent

Slash Commands (Primitive Layer)

• One-off tasks
• Closest to bare metal: agent + LLM + prompt
• Manual triggers (this is a feature, not a limitation)
• Building blocks for skills

MCP Servers (Integration Layer)

• External integrations only
• Third-party APIs, databases, external data sources
• Context-heavy but necessary for external data

Sub-agents (Parallelization Layer)

• Parallelization and context isolation
• Independent tasks that don’t share state
• No context persistence (by design)

Practical Examples

Example 1: Git Worktree

Wrong Approach: Create a skill for creating a worktree

Right Approach: Use a slash command for single operation

1
2
3

# .claude/commands/create-worktree.md
Create a new Git worktree for isolated development work.
Check for existing worktrees first, then create with proper naming.

Single operation = slash command.

When to Upgrade to Skill: When managing multiple worktree operations

1
2
3
4
5
6
7

skills/worktree-manager/
├── SKILL.md           # Orchestrates all operations
└── docs/
    ├── create.md      # Creation logic
    ├── remove.md      # Removal logic
    ├── list.md        # Listing logic
    └── switch.md      # Switching logic

The skill composes operations. It doesn’t replace the underlying commands.

Rule: If you can accomplish the task with a slash command or sub-agent as a one-off job, don’t use a skill.

Example 2: Parallel Test Failures

Task: “Investigate three independent test failures in parallel”

Key word: “parallel”

Right Approach: Sub-agent dispatch

1
2
3
4

# Launch three isolated investigations
claude-code subagent investigate-test-1 &
claude-code subagent investigate-test-2 &
claude-code subagent investigate-test-3 &

Independent failures, no shared state, concurrent investigation = sub-agent pattern.

Wrong Approach: Create a skill or use sequential slash commands (loses parallelization benefit).

Example 3: Database Integration

Task: “Query customer data from PostgreSQL for analysis”

Right Approach: MCP Server

1
2
3
4
5
6
7
8

{
  "mcpServers": {
    "postgres": {
      "command": "mcp-server-postgres",
      "args": ["--connection-string", "postgresql://..."]
    }
  }
}

External data source = MCP Server.

Wrong Approach: Slash command with hardcoded queries (not reusable) or skill (wrong layer).

Quick Reference

Key insight: Only sub-agents lack context persistence by design. Use them for isolation or parallelization, not for context continuity.

Context Management: Progressive Disclosure

The key innovation in Skills: progressive disclosure vs loading everything upfront.

MCP Servers: Load all context at boot, consuming significant context window space upfront.

Skills: Load information as needed, preserving context for actual work.

When chaining multiple operations, context management becomes the bottleneck. Progressive disclosure solves this.

Composition Architecture

Skills compose other features. Other features don’t compose skills.

Valid compositions:

• Skill uses slash commands
• Skill calls MCP servers
• Skill dispatches sub-agents
• Skill composes other skills

Invalid compositions:

• MCP server uses skill
• Slash command orchestrates skills
• Sub-agent manages skills

There’s a clear hierarchy.

Keywords That Signal Which Feature

Certain words in task descriptions signal which feature to use:

Implementation Guidelines

Start Simple: Every new task begins as a slash command. Not a skill. Not an MCP server. Well-crafted prompt in .claude/commands/.

Bias Toward Primitives: Most tasks stay as slash commands. Graduate to skills only when genuinely managing multiple related operations.

Use Sub-agents Correctly: Only for parallelization or context isolation. Not as a fancy way to run a single task.

MCP for External Only: Database connections, API integrations, third-party services. Not for internal workflow management.

Master Prompts First: Before reaching for compositional features, ensure the underlying prompts are solid. Prompt quality determines everything.

Avoid prompt engineering avoidance: Understanding how to write effective prompts is fundamental to agentic engineering. No feature replaces this skill.

The Graduation Path

Steps:

1. Start with slash command - Every task begins as a simple command
2. Test frequency - Is this truly one-off or repeatedly used?
3. Check operation count - Does it manage multiple related operations?
4. Graduate when necessary - Create skill that composes slash commands
5. Never skip primitives - Don’t jump to skills because they seem “advanced”

Patterns I keep seeing:

• Skill to format commit messages (one operation → should be slash command)
• Skill to run tests (one operation → should be slash command)
• Skill to check git status (one operation → should be slash command)

I see this over-engineering when features with marketing momentum (Skills) seem to obsolete fundamentals (slash commands). They don’t.

What Skills Actually Provide

The innovation in Skills isn’t revolutionary. It’s opinionated structure for repeat problems in an agent-first way, plus progressive disclosure for context management, plus modularity through dedicated file structure.

That’s valuable. But it’s not magic. And it doesn’t obsolete the fundamentals.

Skills don’t introduce fundamentally new capabilities. They provide:

1. Structure - Organized directory layout for complex workflows
2. Progressive disclosure - Context-efficient information loading
3. Modularity - Dedicated file structure for maintainability
4. Agent invocation - Automatic triggering based on task patterns

When deciding between a skill and a slash command for a one-off task, the answer is always slash command. No debate.

How to Use Each Feature

Slash Commands

Creation:

1
2
3

# .claude/commands/command-name.md
Your prompt text here.
Can include instructions, context, and examples.

Usage: Type /command-name in Claude Code

When to use:

• One-off tasks
• Manual triggers needed
• Building blocks for skills
• Testing new workflows

Skills

Creation:

1
2
3
4
5
6

skills/skill-name/
├── SKILL.md              # Main skill logic
├── docs/
│   ├── operation1.md     # Individual operations
│   └── operation2.md
└── README.md             # Documentation

Usage: Agent automatically invokes when pattern matches

When to use:

• Managing multiple related operations
• Repeated workflows
• Need progressive disclosure
• Orchestrating other features

MCP Servers

Configuration:

1
2
3
4
5
6
7
8

{
  "mcpServers": {
    "server-name": {
      "command": "mcp-server-package",
      "args": ["--config", "path/to/config"]
    }
  }
}

When to use:

• External API integrations
• Database connections
• Third-party service access
• External data sources

Sub-agents

Usage Pattern:

1
2
3
4

# Launch parallel investigations
claude-code subagent task-1 &
claude-code subagent task-2 &
wait

When to use:

• Parallel execution needed
• Context isolation required
• Independent tasks
• No shared state needed

Action Items

Audit: Review your .claude/ directory for over-engineered skills that should be slash commands

Refactor: Convert single-operation skills to slash commands

Build: Create a library of well-crafted slash commands as primitives

Study: Master the Core Four (context, model, prompt, tools)

Practice: Follow the graduation path - start simple, graduate when complexity demands it

Ship: Don’t let feature complexity block productivity. Use what works. Graduate when actually needed.

At least for me, the fundamental primitive is the prompt. Master that, and the rest becomes obvious.