Claude Code Plugins: The Complete Guide (2026)

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?
2. What a Plugin Can Bundle
3. Plugins vs. Standalone Configuration
4. How Plugins Work: Marketplaces and Namespacing
5. The Official Marketplaces
6. How to Install and Manage Plugins
7. Anatomy of a Plugin
8. Creating and Sharing Your Own Plugin
9. Which Plugins to Install
10. 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, 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:

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:

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 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, and for the community-curated angle, the awesome Claude Code plugins list.

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:

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

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

/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:

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.

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:

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

A fuller plugin directory looks like this:

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:

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:

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 roundup, and browse the marketplace landscape in our Claude Code plugins marketplace guide. If you are weighing AI coding tools more broadly, our best AI tools 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, the official set, and the best plugins to try — builds on exactly what you set up here.

Related Resources

• Best Claude Code Plugins (2026): Tested & Ranked
• How to Install Claude Code Plugins
• Official Claude Code Plugins: The Complete List
• Awesome Claude Code Plugins: The Curated List
• Claude Code Plugins Marketplace: How It Works
• Claude Code Skills vs. Plugins vs. Agents vs. MCP
• Claude Code Skills: The Complete Guide