Plugins — Extensible Plugin Ecosystem

13 Official Plugins for Every Development Workflow

The Claude Code plugin system extends the CLI with custom slash commands, specialized agents, reusable skills, event-driven hooks, and MCP server integrations. Each plugin follows a standard structure with a .claude-plugin/plugin.json manifest and auto-discovered components.

Plugins

20+

Commands

Agents

Multi

Languages

🔌 Plugin System 🤖 Multi-Agent 🔒 Hook Engine 🛠️ MCP Integration

📚 What is this & why does it exist?

The plugin ecosystem is the extensibility layer of Claude Code. Instead of building every feature into the core CLI, plugins provide modular capabilities that can be installed, combined, and customized. Each plugin can contribute slash commands (user-triggered), agents (AI specialists), skills (auto-invoked knowledge), and hooks (event interceptors).

💡 Real-world analogy

Think of Claude Code as a smartphone and plugins as apps. The phone has basic capabilities (calling, texting), but apps add specialized functions (navigation, banking, photo editing). Similarly, the core CLI handles file operations and bash commands, while plugins add specialized workflows like code review, feature development, and security scanning. Just as apps can communicate with each other, plugins can invoke agents from other plugins.

Plugin Architecture

flowchart LR
    subgraph PluginSystem["Plugin System"]
        Manifest["plugin.json
Manifest"]
        Commands["commands/
Slash Commands"]
        Agents["agents/
AI Specialists"]
        Skills["skills/
Auto-Invoked"]
        Hooks["hooks/
Event Handlers"]
        MCPSrv["MCP Servers"]
    end

    subgraph Triggers["Activation"]
        UserCmd["/slash-command"]
        AutoTrig["Auto-detect"]
        Events["PreToolUse
PostToolUse
Stop
SessionStart"]
    end

    subgraph Core["Claude Code Core"]
        CLI["CLI Engine"]
        Tools["Tool System"]
        Session["Session Manager"]
    end

    UserCmd -->|invokes| Commands
    AutoTrig -->|activates| Skills
    Events -->|fires| Hooks
    Commands -->|orchestrates| Agents
    Agents -->|uses| Tools
    Skills -->|enhances| CLI
    Hooks -->|intercepts| Tools
    MCPSrv -->|extends| Tools
    Manifest -->|registers| Commands
    Manifest -->|registers| MCPSrv

Plugin Lifecycle

sequenceDiagram
    participant User
    participant CLI as Claude Code
    participant Manifest as plugin.json
    participant Hook as Hook Engine
    participant Cmd as Command Handler
    participant Agent as Agent Runtime
    participant Skill as Skill Loader

    User->>CLI: Start session
    CLI->>Manifest: Discover plugins
    Manifest-->>CLI: Register commands, hooks, MCP
    CLI->>Hook: Fire SessionStart hooks
    Hook-->>CLI: Inject context

    User->>CLI: /code-review
    CLI->>Cmd: Resolve command
    Cmd->>Agent: Launch 4 review agents (parallel)
    Agent->>CLI: Use Read, Grep, Bash tools
    Note over Hook,CLI: PreToolUse hooks validate each tool call
    Agent-->>Cmd: Review findings
    Cmd-->>User: Filtered results (confidence >= 80)

    User->>CLI: Write code
    CLI->>Skill: Auto-detect frontend-design skill
    Skill-->>CLI: Inject design guidance
    CLI->>Hook: PreToolUse: security check
    Hook-->>CLI: Allow/warn/block

🚶 Step-by-Step: Feature Development Workflow

Follow a /feature-dev "add user authentication" command through the plugin system:

Command Resolution — CLI finds feature-dev/commands/feature-dev.md and loads the command definition.
Discovery Phase — The command asks clarifying questions about the feature requirements.
Parallel Exploration — 2-3 code-explorer agents launch simultaneously, each analyzing different aspects of the codebase.
File Reading — Agents use Read, Grep, and Glob tools to find relevant code. PreToolUse hooks validate each operation.
Architecture Design — 2-3 code-architect agents propose different approaches (minimal, clean, pragmatic).
User Decision — User selects preferred architecture from presented options.
Implementation — Agents write code using Edit/Write tools. Security hooks check for credentials and dangerous patterns.
Quality Review — 3 code-reviewer agents scan for bugs, style issues, and convention violations in parallel.
Confidence Filtering — Only issues scoring ≥80 confidence are reported, eliminating false positives.
Summary — Plugin produces a summary of changes, files modified, and suggested next steps.

Key Components

Component	File Pattern	Role
`plugin.json`	`.claude-plugin/plugin.json`	Plugin manifest with name, version, description, author, MCP servers
Commands	`commands/*.md`	Markdown-defined slash commands with YAML frontmatter and execution instructions
Agents	`agents/*.md`	Specialized AI agents with model/color/tools configuration and system prompts
Skills	`skills/*/SKILL.md`	Auto-invoked knowledge with progressive disclosure (SKILL.md + references/ + examples/)
Hooks	`hooks/hooks.json`	Event handlers (PreToolUse, PostToolUse, Stop, SessionStart) with Python/Shell scripts
MCP Servers	`plugin.json mcpServers`	External tool integrations via stdio, SSE, HTTP, or WebSocket protocols
Settings	`.claude/plugin.local.md`	Per-project YAML frontmatter configuration with local overrides
Scripts	`scripts/*.sh`	Utility scripts for hook validation, setup, and testing
References	`skills//references/.md`	Detailed reference documentation loaded on-demand by skills
Examples	`skills//examples/.md`	Working code examples for skill features and patterns

Plugin Catalog

Development Workflow Plugins

🛠️ plugin-dev

Comprehensive plugin development toolkit with 7 skills, 3 agents, and guided 8-phase creation workflow.

58 files · 7 skills · 3 agents
Plugin structure, hooks, MCP, settings

🎯 feature-dev

7-phase structured feature development with parallel code exploration, architecture design, and quality review.

6 files · 3 agents · 1 command
Explorer · Architect · Reviewer

🤖 agent-sdk-dev

Agent SDK scaffolding and verification for Python and TypeScript applications.

5 files · 2 agents · 1 command
Project setup · Best practices

📦 commit-commands

Git workflow automation with style-aware commits, branch management, and PR creation.

5 files · 3 commands
/commit · /commit-push-pr · /clean_gone

Code Quality & Review Plugins

🔍 pr-review-toolkit

6 specialized review agents for PR analysis: comments, tests, errors, types, code quality, and simplification.

9 files · 6 agents · 1 command
Confidence scoring ≥80 threshold

✅ code-review

Automated multi-agent PR review with parallel compliance, bug, and history analysis.

3 files · 4+ agents · 1 command
CLAUDE.md compliance · Bug detection

Security & Safety Plugins

🔐 hookify

Python rule engine for custom event-driven hooks. Create validation rules in markdown with YAML frontmatter.

24 files · Python core · 4 hook types
Pattern matching · Regex · Conditions

🛡️ security-guidance

PreToolUse hook monitoring 9 vulnerability patterns: command injection, XSS, unsafe deserialization.

3 files · Python hook
9 security patterns · Context-aware

Style, Learning & Migration Plugins

🎨 frontend-design

Bold, distinctive frontend design guidance that avoids generic AI aesthetics.

3 files · 1 skill
Typography · Color · Motion · Layout

🔄 claude-opus-4-5-migration

Automated migration from Claude 4.x to Opus 4.5 across Anthropic, AWS, GCP, Azure.

5 files · 1 skill
Model strings · Prompt adjustments

💡 explanatory-output-style

Educational insights about implementation choices injected at session start.

4 files · SessionStart hook

🎓 learning-output-style

Interactive learning mode with code contribution requests at decision points.

4 files · SessionStart hook

🔄 ralph-wiggum

Continuous self-referential AI loops. Claude works iteratively on a task, reading its own previous output.

8 files · Stop hook · 3 commands
Autonomous iteration · Completion promises

Cross-Plugin Interactions

Plugin A	Interface	Plugin B	Data Exchanged
feature-dev	Agent invocation	(internal agents)	code-explorer, code-architect, code-reviewer agents used in 7-phase workflow
hookify	PreToolUse hook	All plugins	Validates every tool call against user-defined rules before execution
security-guidance	PreToolUse hook	All plugins	Scans file edits for 9 vulnerability patterns, emits warnings
code-review	GitHub CLI	commit-commands	Reviews PRs created by commit-push-pr workflow
plugin-dev	Skill knowledge	All plugins	Provides structure/hook/MCP guidance used when building any plugin
explanatory-output-style	SessionStart hook	All sessions	Injects educational context at start of every session

Directory Map

Source tree for Plugins

plugins/
├── README.md                      ← Role: Plugin ecosystem overview
├── plugin-dev/                    ← Role: Plugin development toolkit (58 files)
│   ├── commands/create-plugin.md  ← Role: 8-phase guided creation
│   ├── agents/                    ← Role: 3 specialized agents
│   └── skills/ (7 skills)         ← Role: Progressive-disclosure knowledge
├── pr-review-toolkit/             ← Role: 6-agent PR review
├── hookify/                       ← Role: Python rule engine
│   ├── core/                      ← Role: config_loader.py, rule_engine.py
│   ├── hooks/                     ← Role: Event handler scripts
│   └── matchers/                  ← Role: Pattern matching utils
├── feature-dev/                   ← Role: 7-phase feature workflow
├── code-review/                   ← Role: Multi-agent code review
├── commit-commands/               ← Role: Git workflow automation
├── agent-sdk-dev/                 ← Role: SDK scaffolding
├── ralph-wiggum/                  ← Role: Autonomous loop runner
├── frontend-design/               ← Role: Design guidance skill
├── claude-opus-4-5-migration/     ← Role: Model migration
├── explanatory-output-style/      ← Role: Educational insights hook
├── learning-output-style/         ← Role: Interactive learning hook
└── security-guidance/             ← Role: Security pattern detection

Plugin Configuration Reference

Parameter	Default	Description
`plugin.json name`	(required)	Plugin identifier used for registration and command namespacing
`plugin.json version`	"1.0.0"	Semantic version of the plugin
`plugin.json mcpServers`	{}	MCP server definitions (stdio, SSE, HTTP, WebSocket)
`agent.model`	inherit	AI model: inherit, sonnet, opus, haiku
`agent.tools`	all	Allowed tools: Read, Grep, Bash, Edit, Write, WebFetch, etc.
`hook.type`	command	Hook type: command (shell/python) or prompt (inline)
`hook.matcher`	*	Tool name regex matcher for PreToolUse/PostToolUse hooks
`skill.description`	(required)	Trigger phrase description for auto-invocation matching
`settings bypass`	true	Allow/disallow bypass mode for permissions
`settings sandbox`	false	Enable bash sandboxing with network isolation