The Complete Guide to Claude Code Plugins

A Claude Code plugin is a distributable bundle that can contain commands, agents, skills, hooks, and MCP server configuration, installed as a single versioned unit and shared across a team through a marketplace. Plugins are how a capability set moves from one developer's machine to an entire team in one command. The ecosystem has grown fast: the official Anthropic marketplace hosts 100-plus reviewed plugins, and the community directory claudemarketplaces.com tracks 6,700-plus skills, 840-plus MCP servers, and 2,500-plus marketplaces as of mid-2026.

The problem is no longer finding plugins. It is knowing which ones earn the context-window space they consume at every session start, and understanding how the three primitives -- plugins, skills, and MCP servers -- actually relate. This guide covers all of it: the definition, the ecosystem in 2026, the anatomy of a plugin, why one well-built plugin can beat a dozen, how to evaluate before you install, a short-list of extensions worth keeping, and the FAQ.

What Is a Claude Code Plugin?

Claude Code is Anthropic's agentic coding tool, and plugins are its extension mechanism. Per the official plugins documentation, a plugin is a bundle defined by a manifest that can ship several kinds of capability at once. It is best understood as a container, not a single feature: it packages many things and installs them together.

That container framing matters because the three terms people use interchangeably -- plugin, skill, MCP server -- are not the same. A skill answers "what should the model know how to do." An MCP server answers "what external systems can the model reach." A plugin answers "how do I distribute a bundle of capabilities to a team." The full disambiguation, with a scope-and-lifecycle table, lives in Claude Code Plugin vs Skill vs MCP.

The Plugin Ecosystem in 2026

Two years after Claude Code launched, the extension ecosystem has three tiers. The first is Anthropic's official marketplace, with internal and partner plugins held to a review bar. The second is the broad community layer aggregated by directories like claudemarketplaces.com, which indexes thousands of skills and hundreds of MCP servers. The third is the independent review layer -- pieces like Firecrawl's best-plugins roundup -- that tries to separate signal from volume.

The supply problem is solved. The curation problem is not. With thousands of options, the binding constraint is your context window: every plugin you install loads at session start and competes with your actual project for the model's attention. That makes evaluation -- not discovery -- the skill that matters in 2026.

How the Marketplaces Compare

Where you source a plugin shapes how much you have to trust it. Three channels dominate, and each makes a different trade between volume and vetting.

The official marketplace is the safest default because the review bar filters the obvious risks. Community directories are where breadth lives, but a self-listed plugin carries no warranty -- you inherit the evaluation work. Independent reviews are useful precisely because they do that work for you, but they age fast in a field moving this quickly. A practical rule: start from the official marketplace, reach into the community layer only for a specific need, and treat every third-party plugin as code you are running, because it is.

Anatomy of a Plugin: Commands, Agents, Skills, Hooks, MCP

A plugin can bundle five kinds of capability, each documented by Anthropic:

• Commands -- custom slash commands that trigger a defined workflow on demand.
• Agents -- specialized sub-agents with their own context and role, dispatched for a focused task.
• Skills -- packaged procedural knowledge (a SKILL.md plus assets) loaded on demand when relevant.
• Hooks -- lifecycle hooks that run shell commands at defined events, such as session start or before a tool call.
• MCP configuration -- wiring for MCP servers the plugin's agents rely on, so external systems connect automatically on install.

The five compose. A single plugin can ship a slash command that dispatches an agent, which applies a skill, which uses tools exposed by an MCP server the same plugin configured. That composability is why "plugin versus skill versus MCP" is the wrong question -- they live at different layers of the same stack.

How a Plugin Loads: The Context Lifecycle

Understanding when each capability enters the context window is the difference between a fast session and a sluggish one. The five capability types load on different schedules, and that schedule is the whole game for context economy.

• At session start, the plugin's manifest, its command definitions, and its agent and skill descriptions load so Claude knows what is available. Descriptions are cheap; full bodies are not, which is why well-built plugins keep descriptions terse.
• On demand, a skill's full instructions load only when the task makes it relevant, and an agent's full context loads only when it is dispatched. This lazy loading is what lets a large plugin stay light at rest.
• Per event, hooks fire at defined lifecycle moments -- before a tool call, at session start -- running shell commands rather than consuming model context.
• Per session connection, an MCP server runs as a separate process and exposes its tools for the duration of the session, so its cost is the tool definitions it advertises, not the work it does.

The lesson for evaluation: a plugin that front-loads heavy instructions at session start taxes every conversation, while one that defers detail until it is needed costs almost nothing at rest. When two plugins offer the same capability, the one that loads lazily wins.

The Compound Case: Why One Plugin Can Beat Many

The instinct with a thousand plugins available is to install many. The better instinct is to install few that compound. Each plugin costs context budget at every session start, and that cost is not theoretical -- it compresses the project context the model can actually hold. A dozen single-purpose plugins that do not share state will collectively consume more context than they return in capability.

The alternative is a plugin built as an organization rather than a feature. Soleur is the reference example: it ships 67 agents and 83 skills across 8 departments, plus the MCP configuration its agents rely on, as one install. The agents share a compounding knowledge base, so the capability is not the sum of the parts -- it is the parts plus the memory between them. This is the discipline of agentic engineering applied to plugin design, and the broader category it enables is Company-as-a-Service.

How to Evaluate a Plugin Before Installing

Run any plugin through three questions before it earns a slot:

• Does it earn its context cost? A plugin that loads heavy instructions at every session start but is used occasionally is a bad trade. Prefer plugins that load on demand.
• Does it compose or conflict? Check whether it shares state with what you already run, or duplicates and fights it. Overlapping plugins quietly degrade each other.
• Is it maintained and verifiable? Open source, active commits, clear documentation, and inspectable behavior. A plugin you cannot audit is a plugin you cannot trust with delegated work.

Anthropic's own Claude Code best practices reinforce the same principle: keep the context lean and let capability load when it is relevant, not by default.

Extensions Worth Keeping in 2026

Independent reviews converge on a short list of extensions that earn their keep. The categories below are durable even as specific names rotate; verify current options against the official marketplace and the Firecrawl roundup.

• Documentation reach -- an MCP server that pulls current library and framework docs into context, so the model is not guessing against stale training data.
• Browser and web automation -- MCP tooling that lets agents drive a real browser or fetch live pages for testing and research.
• Workflow loops -- plugins that structure iterative build-test-fix cycles rather than one-shot generation.
• Connect-apps integrations -- MCP servers that wire agents into the SaaS products a team already uses.
• Organization layer -- a plugin like Soleur that ships a full agent organization with shared memory, for teams that want to extend Claude Code beyond engineering into every business function.

For ranked, opinionated picks, the existing Best Claude Code Plugins 2026 post tours the field, and Skill Libraries vs Workflow Plugins covers the two dominant shapes a plugin takes.

Where Soleur Fits

Soleur is a Claude Code plugin -- installed the same one-command way as any other. What makes it different is scope: most plugins add a workflow, while Soleur adds an organization. It is the right choice when the goal is not "make my coding faster" but "run the other 70% of my company -- marketing, legal, finance, operations -- with the same leverage AI already brought to code." For founders whose problem is engineering velocity alone, a lighter plugin is the better fit, and this guide is written to help you tell the difference.

Install and Try It

Plugins install from a marketplace in one command. To see what a full organization-layer plugin feels like, install Soleur and run a real task through its agents and skills.

claude plugin install soleur

Frequently Asked Questions

Related Reading

• Claude Code Plugin vs Skill vs MCP
• Best Claude Code Plugins 2026
• Skill Libraries vs Workflow Plugins
• Agentic Engineering
• Glossary