# Claude Code Plugins: The Complete Guide (2026)

> Claude Code plugins bundle skills, agents, hooks, and MCP servers into one installable package. Learn what they are, how they work, and how to install one.

Source: https://designrevision.com/blog/claude-code-plugins

---

Claude Code plugins are how you install a capability once and carry it everywhere. A plugin is a single package that can bundle skills, subagents, hooks, MCP servers, and more, installed with one command and shared across every project and teammate. Instead of hand-copying a `.claude/` folder between repos, you add a marketplace, run `/plugin install`, and the whole bundle is live.

That packaging is what turned Claude Code into a platform. There is now an official Anthropic marketplace, a public community marketplace, and a fast-growing ecosystem of independent directories — the most-installed plugins already count their installs in the hundreds of thousands. This guide explains what Claude Code plugins are, what they can bundle, how marketplaces work, how to install and manage them, and how to build your own.

## Key Takeaways

> If you remember nothing else:
>
> * A **Claude Code plugin** is a directory that bundles skills, subagents, hooks, MCP servers, LSP servers, and monitors, described by a `.claude-plugin/plugin.json` manifest
> * **Skills are the unit of capability; plugins are the unit of distribution** — a plugin can package many skills plus other components
> * You install with **`/plugin install <name>@<marketplace>`** after adding a marketplace with **`/plugin marketplace add <owner>/<repo>`**
> * A **marketplace is just a git repository** with a `marketplace.json` catalog; Anthropic runs the curated **`claude-plugins-official`** and the reviewed **`claude-community`**
> * Plugin skills are **namespaced** (`/plugin-name:skill-name`) so they never conflict with yours
> * Build one by adding a manifest and component folders, test with **`claude --plugin-dir`**, and share via a marketplace

## Table of Contents

1. [What Are Claude Code Plugins?](#what-are-claude-code-plugins)
2. [What a Plugin Can Bundle](#what-a-plugin-can-bundle)
3. [Plugins vs. Standalone Configuration](#plugins-vs-standalone-configuration)
4. [How Plugins Work: Marketplaces and Namespacing](#how-plugins-work-marketplaces-and-namespacing)
5. [The Official Marketplaces](#the-official-marketplaces)
6. [How to Install and Manage Plugins](#how-to-install-and-manage-plugins)
7. [Anatomy of a Plugin](#anatomy-of-a-plugin)
8. [Creating and Sharing Your Own Plugin](#creating-and-sharing-your-own-plugin)
9. [Which Plugins to Install](#which-plugins-to-install)
10. [Conclusion](#conclusion)

## What Are Claude Code Plugins?

A plugin is a packaged, shareable extension for Claude Code. Where a single skill teaches Claude one procedure, a plugin bundles a whole set of capabilities — skills, agents, hooks, external tool connections — into one directory you can version, publish, and install anywhere.

The problem plugins solve is distribution. You can build powerful custom configuration in a project's `.claude/` folder, but it is stuck in that project. To reuse it, you copy files by hand. A plugin turns that configuration into a proper package: install it with one command, get updates when the author ships them, and share it with your whole team or the wider community.

If you have read our guide to [Claude Code skills](/blog/claude-code-skills), the relationship is straightforward: **a skill is one capability; a plugin is a bundle of capabilities plus a manifest that describes them.** A plugin might contain a dozen skills, or none at all — just an MCP server, or a single hook. The plugin is the wrapper that makes any of it installable.

## What a Plugin Can Bundle

The reason plugins are powerful is the range of things they can carry. A single plugin can include any combination of these components, each in its own directory at the plugin root:

| Component | Directory | What it adds |
|-----------|-----------|--------------|
| **Skills** | `skills/` | Model-invoked procedures (`<name>/SKILL.md`) |
| **Subagents** | `agents/` | Specialized agents with their own tools and prompts |
| **Hooks** | `hooks/hooks.json` | Event handlers that fire on tool use, prompts, etc. |
| **MCP servers** | `.mcp.json` | Connections to external tools and data sources |
| **LSP servers** | `.lsp.json` | Real-time code intelligence for a language |
| **Monitors** | `monitors/monitors.json` | Background watchers for logs, files, or status |
| **Commands** | `commands/` | Legacy flat-file skills (use `skills/` for new work) |
| **Executables** | `bin/` | Binaries added to the Bash tool's `PATH` while enabled |
| **Settings** | `settings.json` | Default settings applied when the plugin is enabled |

This is what makes a plugin more than a bag of skills. A single "GitHub" plugin might ship an MCP server for the API, a few skills for common workflows, and a hook that runs on every commit. A "TypeScript" plugin ships an LSP server that gives Claude real-time type information. The plugin is one install; the capabilities are many.

> **Common mistake:** only `plugin.json` belongs inside the `.claude-plugin/` directory. The component folders — `skills/`, `agents/`, `hooks/`, and the rest — must sit at the plugin **root**, not inside `.claude-plugin/`.

## Plugins vs. Standalone Configuration

Claude Code gives you two ways to add custom skills, agents, and hooks. Knowing which to reach for saves confusion:

| | Standalone (`.claude/`) | Plugin |
|---|---|---|
| **Skill names** | Short: `/deploy` | Namespaced: `/my-plugin:deploy` |
| **Scope** | One project (or personal) | Any project where enabled |
| **Sharing** | Manual file copy | Install from a marketplace |
| **Updates** | None | Versioned, one-command update |
| **Best for** | Personal workflows, quick experiments | Team/community distribution, reuse |

The rule of thumb: **start standalone, package into a plugin when you want to share.** Build a skill in `.claude/skills/` while you iterate on it, and once it earns its keep, convert it into a plugin so your teammates get it too. If you are still deciding between skills, plugins, subagents, and MCP as concepts, our [skills vs. plugins vs. agents vs. MCP breakdown](/blog/claude-code-skills-vs-plugins-vs-agents) lays out the decision in one table.

## How Plugins Work: Marketplaces and Namespacing

Two concepts make the plugin system tick: marketplaces and namespacing.

**A marketplace is a git repository** that contains a `marketplace.json` catalog listing available plugins. That is the whole mechanism — no central registry to gatekeep. You add a marketplace by pointing Claude Code at its repo, and every plugin it lists becomes installable. Teams host private marketplaces in private repos; the community hosts public ones; Anthropic hosts the official ones. To install a plugin you name both the plugin and its marketplace: `plugin-name@marketplace-name`.

**Namespacing** keeps everything conflict-free. When a plugin ships a skill, its command is always prefixed with the plugin name — a `review` skill in a plugin called `my-tools` becomes `/my-tools:review`, never a bare `/review`. This is why you can install plugins from many authors without their commands colliding with each other or with your own `.claude/skills/`.

## The Official Marketplaces

Anthropic maintains two public marketplaces, and this is where most people start.

- **`claude-plugins-official`** — a curated set of first-party and vetted partner plugins. It is **registered automatically the first time you launch Claude Code interactively**, so you can install from it immediately. (A non-interactive script that runs before your first launch can add it explicitly with `claude plugin marketplace add anthropics/claude-plugins-official`.)
- **`claude-community`** — the public community marketplace, where third-party plugins land after review. Add it with `/plugin marketplace add anthropics/claude-plugins-community` and install from it as `@claude-community`.

As of early 2026 the official marketplace lists on the order of 100 plugins — roughly a third are first-party Anthropic Claude Code plugins (language servers, dev-workflow tools like `code-review`, `security-guidance`, and `frontend-design`, and setup helpers) and the rest are vetted partner integrations for tools like GitHub, Playwright, Supabase, Figma, Vercel, Linear, Sentry, and Stripe. Beyond Anthropic's marketplaces, independent directories such as claudepluginhub.com and crossaitools.com index thousands more. For the first-party set specifically, see our guide to the [official Claude Code plugins](/blog/official-claude-code-plugins), and for the community-curated angle, the [awesome Claude Code plugins list](/blog/awesome-claude-code-plugins).

## How to Install and Manage Plugins

Installing a plugin is a one-line command. Because the official marketplace is already registered, this works out of the box:

```text
/plugin install code-review@claude-plugins-official
```

To install from any other marketplace, add it first, then install:

```text
/plugin marketplace add anthropics/claude-plugins-community
/plugin install <plugin-name>@claude-community
```

The plugins Claude Code has enabled all show up in the `/plugin` manager, and a few commands cover day-to-day management:

| Command | What it does |
|---------|-------------|
| `/plugin` | Opens the interactive plugin manager (browse, enable, disable, update) |
| `/plugin install <name>@<marketplace>` | Installs a plugin |
| `/plugin marketplace add <owner>/<repo>` | Registers a marketplace from a git repo |
| `/plugin marketplace update <name>` | Refreshes a marketplace's catalog |
| `/reload-plugins` | Applies plugin changes without restarting |

If an install fails with "not found," your marketplace is usually stale — run `/plugin marketplace update <name>` and try again. For the full step-by-step with troubleshooting, see [how to install Claude Code plugins](/blog/how-to-install-claude-code-plugins).

## Anatomy of a Plugin

Under the hood, a plugin is refreshingly simple: a directory with a manifest and some component folders.

The manifest lives at `.claude-plugin/plugin.json`:

```json
{
  "name": "my-plugin",
  "description": "A short summary shown in the plugin manager",
  "version": "1.0.0",
  "author": { "name": "Your Name" }
}
```

| Field | Purpose |
|-------|---------|
| `name` | Unique identifier **and** the skill namespace (`/my-plugin:…`) |
| `description` | Shown when browsing or installing the plugin |
| `version` | Optional. Bump it to ship updates; omit it and the git commit SHA is used |
| `author` | Optional, for attribution |

A fuller plugin directory looks like this:

```text
my-plugin/
├── .claude-plugin/
│   └── plugin.json      # manifest (the ONLY thing in here)
├── skills/
│   └── code-review/
│       └── SKILL.md
├── agents/
│   └── reviewer.md
├── hooks/
│   └── hooks.json
└── .mcp.json
```

Every component folder sits at the root. A plugin that ships exactly one skill can even skip the `skills/` folder and place `SKILL.md` at the plugin root directly.

## Creating and Sharing Your Own Plugin

Building a plugin takes three moves: scaffold, test, publish.

**Scaffold.** The fastest start is `claude plugin init`, which creates a plugin in your skills directory with a manifest and a starter skill:

```bash
claude plugin init my-tool
```

Or create the directory by hand: a `.claude-plugin/plugin.json` manifest plus whatever component folders you need. If you already have useful configuration in `.claude/`, you can convert it — copy `.claude/skills/` and `.claude/agents/` into the plugin, and move your hooks into `hooks/hooks.json`.

**Test locally** without installing, using the `--plugin-dir` flag:

```bash
claude --plugin-dir ./my-plugin
```

Make changes, run `/reload-plugins` to pick them up, and confirm your skills respond under their `/my-tool:...` names.

**Publish** by putting your plugin in a marketplace — again, just a git repository with a `marketplace.json` catalog. Run `claude plugin validate` before you ship, add a `README.md`, and decide on a versioning strategy. Once it is in a marketplace, anyone can install it with `/plugin install`. To keep it internal, host the marketplace in a private repo. The official `skill-creator` plugin is a good model to study for structure and can even scaffold skills for you.

## Which Plugins to Install

The ecosystem is large, so start with high-leverage plugins and add from there. A sensible default stack:

1. **A language server (LSP) plugin** for your stack — real-time code intelligence for TypeScript, Python, Rust, and more.
2. **GitHub** — repository context, issues, and PRs where Claude already works.
3. **`security-guidance` or Semgrep** — makes Claude's edits safer by flagging risky patterns.
4. **Tool integrations** where your team lives — Linear, Vercel, Sentry, Supabase, Figma, Notion.

By install count, the most popular plugins in the ecosystem are **Frontend Design** (which pushes Claude toward distinctive, production-grade UI), **Superpowers** (a full multi-agent development workflow), and **Context7** (up-to-date library documentation on demand) — each with hundreds of thousands of installs. These are a starting point, not a ranking. For our tested, regularly updated shortlist with install commands and honest keep-or-skip verdicts, see the [best Claude Code plugins](/blog/best-claude-code-plugins) roundup, and browse the marketplace landscape in our [Claude Code plugins marketplace guide](/blog/claude-code-plugins-marketplace). If you are weighing AI coding tools more broadly, our [best AI tools for coding](/blog/best-ai-for-coding) roundup gives the wider context.

## Conclusion

Claude Code plugins turn one-off configuration into shareable, versioned capability. A plugin bundles skills, agents, hooks, and external tool connections behind a single manifest; a marketplace — nothing more than a git repository — distributes it; and namespacing keeps a hundred installed plugins from ever colliding. That combination is what let the ecosystem grow from a handful of first-party tools to a marketplace with hundreds of plugins and community catalogs indexing thousands more.

Start by adding the official marketplace (it registers itself on first launch), install a language server and GitHub, and layer in the integrations your team already uses. When your own configuration proves its worth, package it into a plugin so everyone gets it. From there, the rest of this cluster — [installing plugins](/blog/how-to-install-claude-code-plugins), the [official set](/blog/official-claude-code-plugins), and the [best plugins to try](/blog/best-claude-code-plugins) — builds on exactly what you set up here.

---

## Related Resources

- [Best Claude Code Plugins (2026): Tested & Ranked](/blog/best-claude-code-plugins)
- [How to Install Claude Code Plugins](/blog/how-to-install-claude-code-plugins)
- [Official Claude Code Plugins: The Complete List](/blog/official-claude-code-plugins)
- [Awesome Claude Code Plugins: The Curated List](/blog/awesome-claude-code-plugins)
- [Claude Code Plugins Marketplace: How It Works](/blog/claude-code-plugins-marketplace)
- [Claude Code Skills vs. Plugins vs. Agents vs. MCP](/blog/claude-code-skills-vs-plugins-vs-agents)
- [Claude Code Skills: The Complete Guide](/blog/claude-code-skills)