Claude Code Extensions: The Complete Guide (2026)

The Four Extension Types

MCP Servers

MCP (Model Context Protocol) is how Claude Code connects to external systems. You configure an MCP server, and Claude gains new tools it can call: search GitHub repos, query a Postgres database, control a browser, read from Slack.

MCP servers run as separate processes. They expose tools over a protocol that Claude Code understands. Claude decides when to call them based on context, the same way it decides when to use its built-in Bash or Read tools.

Setup

Add MCP server configuration to .mcp.json in your project root (shared with team) or ~/.claude.json (personal, all projects):

{
  "mcpServers": {
    "morph": {
      "command": "npx",
      "args": ["@morphllm/morphmcp"],
      "env": {
        "MORPH_API_KEY": "sk-...",
        "ALL_TOOLS": "true"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    }
  }
}

After saving, restart Claude Code. Ask: "What MCP tools are available?" to confirm the servers loaded.

For a full guide to MCP in Claude Code, including the best servers to install and how they work together, see the Claude Code MCP Servers guide.

Skills and Slash Commands

Skills are Markdown files that inject instructions into Claude's context. Every skill becomes a slash command. A file at ~/.claude/skills/deploy/SKILL.md creates /deploy. A file at .claude/skills/pr-review/SKILL.md creates /pr-review for the current project.

Claude also loads skill descriptions automatically at session start. If a skill's description matches what you're asking, Claude can invoke it without you typing the slash command. Use disable-model-invocation: true in the frontmatter to prevent this and require explicit invocation.

---
name: deploy
description: Deploy the application to production. Use when deploying or releasing.
disable-model-invocation: true
---

Deploy the application:

1. Run bun run test and confirm all tests pass
2. Run bun run build
3. Commit any pending changes with message "chore: pre-deploy cleanup"
4. Push to main branch
5. Wait for CI to pass, then confirm deployment succeeded

Do not proceed if tests fail. Report what failed instead.

Skills support $ARGUMENTS substitution, so /fix-issue 123 becomes "Fix issue 123 following our conventions" when the skill contains Fix issue $ARGUMENTS.

Skill directory structure

~/.claude/skills/           # Personal skills, all projects
  deploy/
    SKILL.md              # Required entry point
    checklist.md          # Supporting docs Claude can reference
  pr-review/
    SKILL.md
    examples/
      good-pr.md

.claude/skills/            # Project skills, current project only
  db-migrate/
    SKILL.md
    scripts/
      validate.sh

For the full skills reference including context: fork (run in a subagent), dynamic context injection, and sharing skills via plugins, see the Claude Code Plugins guide.

Custom Agents

Custom agents are specialized AI assistants that run in their own context window. Each agent has a custom system prompt, specific tool access, and optionally a different model. When Claude encounters a task matching an agent's description, it delegates automatically.

Creating a custom agent

Agent files use Markdown with YAML frontmatter. The body becomes the system prompt. Store them in .claude/agents/ (project) or ~/.claude/agents/ (personal).

---
name: code-reviewer
description: Expert code review. Use after writing or modifying code to check for issues.
tools: Read, Grep, Glob, Bash
model: haiku
---

You are a senior code reviewer. When invoked:

1. Run git diff to see recent changes
2. Focus review on modified files only
3. Check for: security issues, error handling gaps, naming clarity, test coverage

Organize feedback as:
- Critical (must fix before merge)
- Warnings (should fix)
- Suggestions (optional improvements)

Include specific file:line references and show the fix, not just the problem.

Key agent frontmatter fields

Claude Code includes built-in agents you can rely on: Explore (read-only, Haiku, for codebase search), Plan (read-only, used in plan mode), and general-purpose (all tools, for complex tasks). Custom agents stack on top of these.

Hooks

Hooks run shell commands, HTTP endpoints, or LLM prompts automatically at specific points in Claude Code's lifecycle. They provide deterministic control over Claude Code's behavior, something the LLM alone cannot guarantee.

If you want code formatted after every edit, hooks do this reliably. If you want to block writes to .env files, a hook enforces this every time. If you want a desktop notification when Claude needs your attention, hooks handle that.

Hook events

Setup

Hooks go in the hooks section of .claude/settings.json (project) or ~/.claude/settings.json (global). Use the /hooks interactive menu in Claude Code to create them without editing JSON by hand.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ],
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification "Claude Code needs attention" with title "Claude Code"'"
          }
        ]
      }
    ]
  }
}

How hooks communicate

Hooks receive event data as JSON on stdin. They communicate back via exit codes: exit 0 to allow, exit 2 to block (stderr becomes feedback to Claude). For example, blocking writes to .env:

#!/bin/bash
INPUT=$(cat)
FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')

if [[ "$FILE_PATH" == *".env"* ]]; then
  echo "Blocked: .env files are protected. Edit manually." >&2
  exit 2
fi

exit 0

Hooks also support type: prompt (single-turn LLM evaluation) and type: agent (multi-turn with tool access) for decisions that need judgment rather than deterministic rules.

For the complete hooks reference including all event schemas, JSON output format, and advanced patterns, see the Claude Code Hooks guide.

Plugins: Packaging and Sharing

A plugin is a directory with a .claude-plugin/plugin.json manifest. It can contain any combination of skills, agents, hooks, and MCP servers. Install a plugin once and all its components become available.

Minimal plugin structure

my-plugin/
├── .claude-plugin/
│   └── plugin.json       # Manifest (name, description, version)
├── skills/
│   └── deploy/
│       └── SKILL.md
├── agents/
│   └── code-reviewer.md
├── hooks/
│   └── hooks.json
└── .mcp.json             # MCP server config for this plugin

{
  "name": "my-team-tools",
  "description": "Shared tools for the engineering team",
  "version": "1.2.0",
  "author": { "name": "Engineering Team" }
}

Test locally with claude --plugin-dir ./my-plugin. Plugin skills are namespaced: /my-team-tools:deploy to avoid conflicts.

To distribute, create a marketplace repository and share it. Team members install via /plugin in Claude Code.

For full plugin development coverage, see the Claude Code Plugins guide. For how MCP, Skills, and Plugins relate, see Claude Code Skills vs MCP vs Plugins.

Which Extension to Use

Most Claude Code workflows fit one of four patterns. Here is which extension applies to each:

How to Build Your Own Claude Code Extension

The fastest path depends on what you're building. Here is the minimum viable setup for each type:

Build a Skill (5 minutes)

# Create a global skill
mkdir -p ~/.claude/skills/commit
cat > ~/.claude/skills/commit/SKILL.md << 'EOF'
---
name: commit
description: Create a conventional commit with a clear message
disable-model-invocation: true
---

Review staged changes with git diff --staged, then create a commit with:
- Type prefix: feat, fix, refactor, docs, chore, test
- Concise subject under 72 characters
- Body explaining the why, not the what, if needed

Stage all changed files first. Use git commit -m with the message.
EOF

Build a Custom Agent (10 minutes)

# Create a project-level agent
mkdir -p .claude/agents
cat > .claude/agents/security-reviewer.md << 'EOF'
---
name: security-reviewer
description: Security review specialist. Use after auth changes or before releases.
tools: Read, Grep, Glob
model: sonnet
---

You are a security reviewer focused on OWASP Top 10 vulnerabilities.

When invoked:
1. Run git diff to identify recent changes
2. Check for: hardcoded secrets, SQL injection, XSS, insecure dependencies
3. Report by severity: Critical, High, Medium, Low

Include file:line references and recommend fixes.
EOF

Build a Hook (2 minutes)

# Add a Prettier hook via /hooks menu in Claude Code
# Or edit .claude/settings.json directly:
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

Build an MCP Server (requires coding)

MCP servers are Node.js or Python processes that implement the Model Context Protocol. Anthropic provides an SDK for both languages. Most developers use an existing community server rather than building from scratch.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-tools", version: "1.0.0" });

server.tool("get_ticket", { id: z.string() }, async ({ id }) => {
  const ticket = await fetchTicket(id);
  return { content: [{ type: "text", text: JSON.stringify(ticket) }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);

Popular Community Extensions

The extension ecosystem grew from zero to over 9,000 community entries in under a year. A few categories dominate actual usage:

Frequently Asked Questions