Claude Code Plugins: The Complete Guide to Extending Your AI Coding Agent (2026)

What Are Claude Code Plugins?

Claude Code plugins are shareable packages that extend your AI coding agent with new capabilities. A single plugin can bundle slash commands, subagents, MCP servers, hooks, and LSP servers into one installable unit that works across the terminal and VS Code.

Before plugins existed, extending Claude Code meant manually configuring MCP servers in .mcp.json, writing Skills in .claude/skills/, and copying hook configurations between projects. Plugins solve the distribution problem: you install once, get everything, and share with your team.

The plugin system launched in public beta with Claude Code version 1.0.33. It uses a simple directory-based architecture with no build step, no compilation, and no registry approval process. This simplicity is why the ecosystem grew from zero to 9,000+ plugins in under a year.

Plugin Architecture: What Goes Inside a Plugin

A Claude Code plugin is a directory with a manifest file and optional component directories. Understanding the architecture helps you evaluate plugins before installing and build better ones yourself.

my-plugin/
├── .claude-plugin/
│   └── plugin.json          # Required: metadata
├── commands/
│   └── review.md            # Slash command: /my-plugin:review
├── skills/
│   └── code-review/
│       └── SKILL.md          # Auto-invoked skill
├── hooks/
│   └── hooks.json            # Event handlers
└── .mcp.json                 # MCP server configs

{
  "name": "my-plugin",
  "description": "A code review plugin with security scanning",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

MCP Tool Search: The 95% Context Savings That Changes Everything

This is the single most important feature for plugin users in 2026, and most guides do not mention it. MCP Tool Search enables lazy loading for MCP server tools, reducing context usage by up to 95%.

The problem: every MCP server you install adds its tool definitions to Claude's context window. Install ten MCP servers and you burn thousands of tokens on tool descriptions before Claude even starts thinking about your code. This was the #1 complaint from early plugin adopters: too many MCP servers bloated context and degraded quality.

MCP Tool Search fixes this. Instead of loading all tool definitions upfront, Claude discovers tools on demand. When it needs to interact with GitHub, it searches for the GitHub tool. When it needs to query a database, it finds the PostgreSQL tool. Tools you are not using in the current task consume zero context.

How to Install Claude Code Plugins

Installing plugins takes three steps. Claude Code ships with the official Anthropic marketplace pre-configured, so you can start installing curated plugins immediately.

# Install from official marketplace (pre-configured)
/plugin install context7@claude-plugins-official

# Add a community marketplace
/plugin marketplace add ComposioHQ/awesome-claude-plugins

# Install a specific plugin
/plugin install connect-apps@ComposioHQ/awesome-claude-plugins

# Test a local plugin during development
claude --plugin-dir ./my-plugin

# Load multiple plugins
claude --plugin-dir ./plugin-one --plugin-dir ./plugin-two

Plugins require Claude Code version 1.0.33 or later. Run claude --version to check. If the /plugin command is not available, update Claude Code to the latest version.

The 10 Best Claude Code Plugins for 2026

These are the most installed and highest-rated Claude Code plugins as of February 2026, ranked by adoption and developer impact.

Best MCP Server Plugins

MCP (Model Context Protocol) servers are the most powerful plugin component. They connect Claude Code to external tools and APIs. These are the MCP server plugins every developer should evaluate.

How to Build Your Own Claude Code Plugin

Building a plugin takes under five minutes. There is no build step, no toolchain, and no approval process. You create files, test locally, and publish to a marketplace.

Step 1: Create the Plugin Structure

# Create the plugin directory
mkdir my-plugin

# Create the manifest directory
mkdir my-plugin/.claude-plugin

# Create the manifest file
cat > my-plugin/.claude-plugin/plugin.json << 'EOF'
{
  "name": "my-plugin",
  "description": "A custom plugin for my team",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}
EOF

Step 2: Add a Slash Command

# Create commands directory
mkdir my-plugin/commands

# Create a review command
cat > my-plugin/commands/review.md << 'EOF'
---
description: Review the current file for best practices
---

Review the code in the current context for:
1. Code organization and naming conventions
2. Error handling completeness
3. Security vulnerabilities (OWASP Top 10)
4. Test coverage gaps
5. Performance concerns

Provide specific, actionable feedback with line references.
Format issues as: [SEVERITY] file:line - description
EOF

Step 3: Add a Skill (Auto-Invoked)

# Create skills directory
mkdir -p my-plugin/skills/typescript-conventions

# Create the skill
cat > my-plugin/skills/typescript-conventions/SKILL.md << 'EOF'
---
name: typescript-conventions
description: Enforces team TypeScript conventions. Use when
  writing or reviewing TypeScript code.
---

When writing TypeScript code, follow these conventions:
- Use explicit return types on exported functions
- Prefer interfaces over type aliases for object shapes
- Use const assertions for literal types
- Never use 'any' - use 'unknown' with type guards
- Use discriminated unions for state management
EOF

Step 4: Add a Hook

# Create hooks directory
mkdir my-plugin/hooks

# Create hooks configuration
cat > my-plugin/hooks/hooks.json << 'EOF'
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx eslint --fix"
          }
        ]
      }
    ]
  }
}
EOF

Step 5: Test and Publish

# Test locally
claude --plugin-dir ./my-plugin

# Try your slash command
> /my-plugin:review

# Publish: push to a GitHub repo, then others install with:
> /plugin marketplace add your-username/my-plugin
> /plugin install my-plugin@your-username/my-plugin

Plugin Manifest Reference

The plugin.json manifest is the only required file for a plugin. Here are all available fields.

The name field is particularly important: it becomes the namespace prefix for all slash commands in the plugin. A plugin named my-tool will have commands like /my-tool:review and /my-tool:deploy. Choose a short, descriptive name.

Marketplaces and Plugin Discovery

Plugins are distributed through marketplaces, which are GitHub repositories containing curated plugin collections. The ecosystem has three tiers of discovery.

Anyone can create a marketplace. Push a GitHub repository with plugin directories, and others can add it with /plugin marketplace add your-org/your-repo. This decentralized approach is why the ecosystem scaled so quickly, but it also means you should vet plugins before installing, especially those from unknown sources.

Plugins vs Skills vs MCP vs Hooks: When to Use What

Claude Code has five extension mechanisms that overlap. This comparison helps you choose the right one.

WarpGrep: Semantic Codebase Search as a Claude Code Plugin

WarpGrep is an MCP server that adds semantic codebase search to Claude Code. Instead of relying on grep-style pattern matching, WarpGrep understands the meaning of your query and returns relevant code across your entire project.

When used as a Claude Code MCP server, WarpGrep lets Claude find relevant code faster and with better accuracy than the default file search tools. This is particularly valuable on large codebases where the right code may use different terminology than your search query.

# Add to your .mcp.json or plugin's .mcp.json
{
  "mcpServers": {
    "warpgrep": {
      "command": "npx",
      "args": ["warpgrep-mcp"],
      "env": {
        "WARPGREP_API_KEY": "your-api-key"
      }
    }
  }
}

WarpGrep complements plugins like Context7 (which fetches library docs) by searching your own codebase semantically. Together, they give Claude both external knowledge and deep project understanding.

Best Practices: Security, Context Management, and When NOT to Use Plugins

The Claude Code plugin ecosystem is where VS Code extensions were five years ago. Early builders have an outsized advantage, but the ecosystem also has the same growing pains. The community is already discussing trust, auditing, and context management. Here is the mature take.

Security: Every Plugin Gets Access to Your Code

Each plugin and MCP server you install gets access to your codebase, your terminal, and potentially your environment variables. There is no sandboxing between plugins. A malicious or buggy plugin could read sensitive files, exfiltrate code, or execute arbitrary commands. This is not theoretical. It is the same attack surface that npm packages and VS Code extensions have, but with more permissions.

Context Management: The Plugin Fatigue Problem

Twitter users and Reddit threads are already warning about "plugin fatigue": installing too many plugins degrades Claude's performance because each one consumes context. MCP Tool Search (which lazy-loads tools on demand) mitigates this for MCP servers, but Skills and hooks still load into context at session start.

When NOT to Use Plugins

Not every workflow needs a plugin. Start with standalone configuration in .claude/ for personal experiments. Only package a plugin when you need to share across projects or teams. The most common mistake new users make is installing every plugin they find. Start with Context7 and one or two domain-specific plugins, then add as you hit real friction.

Development Tips

"Just shipped /last30days. A Claude Code skill that scans the last 30 days on Reddit, X, and the web for any topic." — @mvanhorn (285 RTs). Skills that do RESEARCH tasks are a hot new category.

Frequently Asked Questions