Understanding Claude Code's Full Stack: MCP, Skills, Subagents, and Hooks Explained

I’ve been using Claude Code for months. Mostly for quick edits and generating boilerplate. The vibe coding tool everyone talks about.

Then I actually explored what it could do. MCP servers. Slash commands. Plugins. Skills. Hooks. Subagents. CLAUDE.md files.

I was blown away. Claude Code isn’t just a coding assistant. It’s a framework for orchestrating AI agents. It speeds up development in ways I’ve never seen before.

Most people use one or two features. They miss how these features stack together. This guide explains each concept in the order they build on each other — from external connections to automatic behaviors.

Claude Code is, with hindsight, poorly named. It’s not purely a coding tool: it’s a tool for general computer automation. Anything you can achieve by typing commands into a computer is something that can now be automated by Claude Code. It’s best described as a general agent. Skills make this a whole lot more obvious and explicit.

— Simon Willison, Claude Skills are awesome, maybe a bigger deal than MCP

The feature stack

1. Model Context Protocol (MCP) — the foundation for connecting external tools and data sources
2. Claude Code core features — project memory, slash commands, subagents, and hooks
3. Plugins — shareable packages that bundle commands, hooks, and skills
4. Agent Skills — automatic, model-invoked capabilities that activate based on task context

1) Model Context Protocol (MCP) — connecting external systems

What it is. The Model Context Protocol What Is the Model Context Protocol (MCP)? How It Works Learn how MCP (Model Context Protocol) standardizes AI tool integration, enabling LLMs to interact with external services, databases, and APIs through a universal protocol similar to USB-C for AI applications. mcptypescriptai Aug 10, 2025 connects Claude Code to external tools and data sources. Think universal adapter for GitHub, databases, APIs, and other systems.

How it works. Connect an MCP server, get access to its tools, resources, and prompts as slash commands:

# Install a server
claude mcp add playwright npx @playwright/mcp@latest

# Use it
/mcp__playwright__create-test [args]

The gotcha. MCP servers expose their own tools — they don’t inherit Claude’s Read, Write, or Bash unless explicitly provided.

2) Claude Code core features

2.1) Project memory with CLAUDE.md

What it is. Markdown files Claude loads at startup. They give Claude memory about your project’s conventions, architecture, and patterns.

How it works. Files merge hierarchically from enterprise → user (~/.claude/CLAUDE.md) → project (./CLAUDE.md). When you reference @components/Button.vue, Claude also reads CLAUDE.md from that directory and its parents.

Example structure for a Vue app:

When you work on src/components/Button.vue, Claude loads context from:

1. Enterprise CLAUDE.md (if configured)
2. User ~/.claude/CLAUDE.md (personal preferences)
3. Project root CLAUDE.md (project-wide info)
4. src/components/CLAUDE.md (component-specific patterns)

What goes in. Common commands, coding standards, architectural patterns. Keep it concise — reference guide, not documentation.

Here’s my blog’s CLAUDE.md:

# CLAUDE.md

## Project Overview

Alexander Opalic's personal blog built on AstroPaper - Astro-based blog theme with TypeScript, React, TailwindCSS.

**Tech Stack**: Astro 5, TypeScript, React, TailwindCSS, Shiki, FuseJS, Playwright

## Development Commands

```bash
npm run dev              # Build + Pagefind + dev server (localhost:4321)
npm run build            # Production build
npm run lint             # ESLint for .astro, .ts, .tsx
---

2.2) Slash Commands — explicit, reusable prompts

What they are. Markdown files in .claude/commands/ you trigger manually by typing /name [args]. User-controlled workflows.

Key features:

• $ARGUMENTS or $1, $2 for argument passing
• @file syntax to inline code
• allowed-tools: Bash(...) for pre-execution scripts
• XML-tagged prompts XML-Style Tagged Prompts: A Framework for Reliable AI Responses Learn how top AI engineers use XML-style prompts to consistently get structured, accurate responses from ChatGPT, Claude, and other LLMs. Step-by-step guide with real examples aillmprompt-engineering Dec 22, 2024 for reliable outputs

When to use. Repeatable workflows you trigger on demand — code reviews, commit messages, scaffolding.

Example structure:

---
description: Create new slash commands
argument-hint: [name] [purpose]
allowed-tools: Bash(mkdir:*), Bash(tee:*)
---

# /create-command

Generate slash command files with proper structure.

**Inputs:** `$1` = name, `$2` = purpose
**Outputs:** `STATUS=WROTE PATH=.claude/commands/{name}.md`

[... instructions ...]

Commands can create commands. Meta, but powerful.

2.3) Subagents — specialized AI personalities for delegation

What they are. Pre-configured AI personalities with specific expertise areas. Each subagent has its own system prompt, allowed tools, and separate context window. When Claude encounters a task matching a subagent’s expertise, it delegates automatically.

Why use them. Keep your main conversation clean while offloading specialized work. Each subagent works independently in its own context window, preventing token bloat. Run multiple subagents in parallel for concurrent analysis.

Example structure:

---
name: security-auditor
description: Analyzes code for security vulnerabilities
tools: Read, Grep, Bash  # Controls what this personality can access
model: sonnet  # Optional: sonnet, opus, haiku, inherit
---

You are a security-focused code auditor.

Identify vulnerabilities (XSS, SQL injection, CSRF, etc.)
Check dependencies and packages
Verify auth/authorization
Review data validation

Provide severity levels: Critical, High, Medium, Low.
Focus on OWASP Top 10.

The system prompt shapes the subagent’s behavior. The description helps Claude know when to delegate. The tools restrict what the personality can access.

Best practices: One expertise area per subagent. Grant minimal tool access. Use haiku for simple tasks, sonnet for complex analysis. Run independent work in parallel.

2.4) Hooks — automatic event-driven actions

What they are. JSON-configured handlers in .claude/settings.json that trigger automatically on lifecycle events. No manual invocation.

Available events: PreToolUse, PostToolUse, UserPromptSubmit, Notification, Stop, SubagentStop, SessionStart

Two modes:

• Command: Run shell commands (fast, predictable)
• Prompt: Let Claude decide with the LLM (flexible, context-aware)

Example: Auto-lint after file edits.

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{
        "type": "command",
        "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/run-oxlint.sh"
      }]
    }]
  }
}

#!/usr/bin/env bash
file_path="$(jq -r '.tool_input.file_path // ""')"

if [[ "$file_path" =~ \.(js|jsx|ts|tsx|vue)$ ]]; then
  pnpm lint:fast
fi

Common uses: Auto-format after edits, require approval for bash commands, validate writes, initialize sessions.

3) Plugins — shareable, packaged configurations

What they are. Distributable bundles of commands, hooks, skills, and metadata. Share your setup with teammates or install pre-built configurations.

Basic structure:

When to use. Share team configurations, package domain workflows Building My First Claude Code Plugin How I built a Claude Code plugin to generate skills, agents, commands, and more—and stopped copy-pasting boilerplate. claude-codeaitooling +1 Nov 8, 2025 , distribute opinionated patterns, install community tooling.

How it works. Install a plugin, get instant access. Components merge seamlessly — hooks combine, commands appear in autocomplete, skills activate automatically.

4) Agent Skills — automatic, task-driven capabilities

What they are. Folders with SKILL.md descriptors plus optional scripts. Unlike slash commands, skills activate automatically when their description matches the task context.

How Claude discovers them. When you give Claude a task, it reviews available skill descriptions to find relevant ones. If a skill’s description field matches the task context, Claude loads the full skill instructions and applies them. This happens transparently — you never explicitly invoke skills.

Claude Skills are awesome, maybe a bigger deal than MCP

— Simon Willison, Claude Skills are awesome, maybe a bigger deal than MCP

Where to put them:

• ~/.claude/skills/ — personal, all projects
• .claude/skills/ — project-specific
• Inside plugins — distributable

What you need:

• SKILL.md with frontmatter (name, description)
• Optional allowed-tools declaration
• Optional helper scripts

Why they’re powerful. Skills package expertise Claude applies automatically. Style enforcement, doc updates, test hygiene, framework patterns — all without manual triggering.

Skills vs CLAUDE.md. Think of skills as modular chunks of a CLAUDE.md file. Instead of Claude reviewing a massive document every time, skills let Claude access specific expertise only when needed. This improves context efficiency while maintaining automatic behavior.

Key difference. Skills are “always on.” Claude activates them based on context. Commands require manual invocation.

Putting it all together

Here’s how these features work together in practice:

1. Memory (CLAUDE.md) — Establish project context and conventions that Claude always knows
2. Slash commands — Create explicit shortcuts for workflows you want to trigger on demand
3. Subagents — Offload parallel or isolated work to specialized agents
4. Hooks — Enforce rules and automate repetitive actions at key lifecycle events
5. Plugins — Package and distribute your entire setup to others
6. MCP — Connect external systems and make their capabilities available as commands
7. Skills — Define automatic behaviors that activate based on task context

Example: A Task-Based Development Workflow

Here’s a real-world workflow that combines multiple features:

Setup phase:

• CLAUDE.md contains implementation standards (“don’t commit until I approve”, “write tests first”)
• /load-context slash command initializes new chats with project state
• update-documentation skill activates automatically after implementations
• Hook triggers linting after file edits

Planning phase (Chat 1):

• Main agent plans bug fix or new feature
• Outputs detailed task file with approach

Implementation phase (Chat 2):

• Start fresh context with /load-context
• Feed in the plan from Chat 1
• Implementation subagent executes the plan
• update-documentation skill updates docs automatically
• /resolve-task command marks task complete

Why this works: Main context stays focused on planning. Heavy implementation work happens in isolated context. Skills handle documentation. Hooks enforce quality standards. No context pollution.

Decision guide: choosing the right tool

Feature comparison

Real-world examples