Claude Code Plugins: Install, Create, Publish

TL;DR

• A Claude Code plugin is a single installable directory that bundles skills, agents, hooks, MCP server connections, LSP servers, commands, and monitors, so one command drops a whole workflow into every project (unlike standalone .claude/ config, which lives in one project).
• Anthropic maintains two public catalogs: the official marketplace (claude-plugins-official), registered automatically, and the community marketplace (claude-community), which you add manually and whose plugins are pinned to a commit SHA after automated safety screening.
• Install via the /plugin manager (Discover, Installed, Marketplaces, Errors tabs) or directly with /plugin install <name>@<marketplace>, choosing user, project, or local scope, then run /reload-plugins to activate without restarting.
• Build your own in about five minutes: create .claude-plugin/plugin.json, add components like skills/<name>/SKILL.md, test with claude --plugin-dir ./my-plugin, run claude plugin validate, then publish to the community marketplace (allow up to 24 hours for the nightly catalog sync).
• Plugins are namespaced (/plugin-name:skill), can run arbitrary code with your privileges so only install from trusted sources, and do not provide cross-session memory or coordinated multi-agent orchestration on their own.

Claude Code plugins let you install, share, and distribute bundled configurations that extend what Claude Code can do. A plugin can contain skills, agents, hooks, MCP server connections, and language server integrations, all packaged into a single installable unit. Install one command and a whole workflow drops into place.

This guide covers the full picture: what a plugin is, how to install from the official Anthropic marketplace or community catalog, how to add third-party marketplaces, and how to build and publish your own plugin.

What Is a Claude Code Plugin?

A plugin is a self-contained directory that bundles one or more Claude Code capabilities. When you install a plugin, everything inside it becomes active in your Claude Code session without any manual file-copying or configuration editing.

A single plugin can contain any combination of the following:

Component	What it adds
Skills	Instruction sets that Claude loads as domain knowledge (/plugin-name:skill-name)
Agents	Custom subagent definitions with their own system prompts and tool restrictions
Hooks	Event handlers that fire on lifecycle events (write, edit, session start, etc.)
MCP servers	Pre-configured connections to external services (GitHub, Linear, Supabase, and more)
LSP servers	Language server connections for real-time code intelligence and diagnostics
Commands	Slash-command shortcuts for common workflows
Monitors	Background watchers for logs, files, or external status feeds

The key difference from standalone configuration (.claude/ directory) is portability. Standalone config lives in one project. A plugin installs with one command and works across every project, and can be shared with teammates or the wider community.

If you are new to the underlying building blocks, the guides on Claude Code skills, hooks, commands, and custom agents cover each component individually.

The Two Plugin Marketplaces

Anthropic maintains two public catalogs:

Official marketplace (claude-plugins-official): Curated by Anthropic, registered automatically when you first start Claude Code. Browse at claude.com/plugins or via the /plugin command. Inclusion is at Anthropic's discretion and there is no public application process.

Community marketplace (claude-community): Third-party plugins that have passed Anthropic's automated validation and safety screening. Plugins are pinned to a specific commit SHA for reproducibility. You add this one manually (covered below).

Third parties and teams can also host private marketplaces via any Git repository, a local directory, or a hosted marketplace.json file.

Installing from the Official Marketplace

The official marketplace is available out of the box. Open the plugin manager:

/plugin

This opens a four-tab interface:

• Discover: browse all available plugins across your configured marketplaces
• Installed: manage your installed plugins
• Marketplaces: add, update, or remove marketplace sources
• Errors: debug plugin load failures

To install the GitHub integration directly from the command line:

/plugin install github@claude-plugins-official

The official marketplace includes several categories worth knowing:

Code intelligence: LSP plugins for TypeScript, Python, Go, Rust, Java, C#, and more. These give Claude real-time type error reporting and code navigation (jump to definition, find references) without running a compiler.

External integrations: Pre-configured MCP server bundles for GitHub, GitLab, Atlassian, Linear, Vercel, Firebase, Supabase, Slack, Sentry, and others. Installing one of these is faster than the manual MCP server setup process.

Development workflows: Git commit workflows, PR review agents, plugin development toolkits.

Security review: The security-guidance plugin reviews each file change Claude makes for common vulnerabilities and instructs Claude to fix issues in the same session.

Installation scope: When you select a plugin in the Discover tab, you choose between three scopes before installing:

• User scope (default): installs for you across all projects
• Project scope: installs for all collaborators on the current repository (written to .claude/settings.json)
• Local scope: installs for you in this repository only, not shared with collaborators

After installing, run /reload-plugins to activate without restarting:

/reload-plugins

Adding the Community Marketplace

The community marketplace requires manual setup because it is not pre-registered:

/plugin marketplace add anthropics/claude-plugins-community

Then install from it using the @claude-community suffix:

/plugin install <plugin-name>@claude-community

If you need to refresh the catalog after new plugins are approved:

/plugin marketplace update claude-plugins-official

Adding Third-Party Marketplaces

A marketplace can live in any Git repository that contains a .claude-plugin/marketplace.json file. This is how teams share internal plugins without going through Anthropic's review process.

From a GitHub repository:

/plugin marketplace add your-org/your-plugins-repo

From a GitLab or Bitbucket URL:

/plugin marketplace add https://gitlab.com/company/plugins.git

From a local directory (useful for testing before publishing):

/plugin marketplace add ./my-local-marketplace

Once a marketplace is added, its plugins appear in the Discover tab alongside official ones.

---

If you want Claude Code configured for serious production use without assembling plugins one by one, Claudify is the pre-built operating system: skills, specialist agents, persistent memory, and quality hooks already wired together and battle-tested across hundreds of real projects.

---

Managing Installed Plugins

List what you have installed:

/plugin list

Disable a plugin without removing it (useful for debugging conflicts):

/plugin disable plugin-name@marketplace-name

Re-enable it:

/plugin enable plugin-name@marketplace-name

Fully remove a plugin:

/plugin uninstall plugin-name@marketplace-name

The --scope flag targets a specific scope when you have a plugin installed at multiple levels:

claude plugin uninstall formatter@your-org --scope project

Building Your Own Plugin

Creating a plugin takes five minutes. You end up with a directory that can be tested locally, shared via a Git repository, or submitted to the community marketplace.

Step 1: Create the directory and manifest

mkdir my-plugin
mkdir my-plugin/.claude-plugin

Create my-plugin/.claude-plugin/plugin.json:

{
  "name": "my-plugin",
  "description": "What this plugin does",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

The name field becomes the namespace prefix for all skills. A skill named review in a plugin named my-plugin invokes as /my-plugin:review.

Step 2: Add your components

Skills live in skills/<skill-name>/SKILL.md at the plugin root (not inside .claude-plugin/):

mkdir -p my-plugin/skills/review

my-plugin/skills/review/SKILL.md:

---
description: Review the current file for code quality issues
---

Review the provided code for:
1. Error handling gaps
2. Missing input validation
3. Security concerns
4. Clarity and naming consistency

Report findings clearly with line references.

The plugin structure at the root level supports all component types:

my-plugin/
  .claude-plugin/
    plugin.json
  skills/
    review/
      SKILL.md
  agents/
    (custom agent definitions)
  hooks/
    hooks.json
  .mcp.json
    (MCP server configurations)

Step 3: Test locally

Run Claude Code with your plugin loaded for this session only:

claude --plugin-dir ./my-plugin

Try your skill:

/my-plugin:review

Make changes and reload without restarting:

/reload-plugins

For development without the --plugin-dir flag on every launch, use the init shortcut. This creates the plugin in your user skills directory and loads it automatically:

claude plugin init my-plugin

Step 4: Validate before sharing

Run the same check the community review pipeline uses:

claude plugin validate

Fix any reported issues, then share via a Git repository or submit to the community marketplace.

Step 5: Publish to the community marketplace

Submit via platform.claude.com/plugins/submit (any user) or claude.ai/admin-settings/directory/submissions/plugins/new (Team or Enterprise accounts).

Approved plugins are pinned to a specific commit SHA in the anthropics/claude-plugins-community catalog. The catalog syncs nightly, so expect up to 24 hours between approval and the plugin appearing as installable.

To host a private plugin for your team without going through the community review, create a marketplace in a private Git repository and add it via:

/plugin marketplace add git@github.com:your-org/private-plugins.git

Plugins vs. Standalone Configuration

It is worth being clear about when to use each approach:

Use case	Right approach
Personal config for one project	Standalone (.claude/ directory)
Experimenting before committing	Standalone, then convert when ready
Sharing with teammates	Plugin in a Git repository
Same capability across multiple projects	Plugin at user scope
Distributing to the wider community	Plugin submitted to community marketplace

Standalone config uses short names like /deploy. Plugin skills are namespaced like /my-plugin:deploy to prevent conflicts between plugins from different authors.

The CLAUDE.md guide covers how standalone project configuration and plugins complement each other. Your CLAUDE.md handles project-specific context; plugins handle reusable capability.

What Plugins Cannot Do

A few boundaries worth noting:

Plugins with LSP servers require the underlying language server binary to be installed separately on your system. The plugin configures the connection; you install the binary (for example, pyright-langserver for Python or typescript-language-server for TypeScript).

Plugin skills are namespaced, so short invocations like /review require standalone configuration. Plugins use /plugin-name:review.

Security: plugins can execute arbitrary code with your user privileges. Only install from sources you trust. Anthropic's automated screening on the community marketplace catches most safety issues, but cannot guarantee every plugin is safe or functions as described.

For teams that want control over which plugins members can add, managed settings let administrators restrict marketplace access and pre-install organization plugins automatically when a project folder is trusted.

The Plugin System vs. a Complete Operating System

Plugins are the right tool for sharing individual, reusable capabilities. They are excellent for distributing a specific workflow, a set of skills for a particular framework, or an MCP integration your team needs.

Where they have limits is in orchestration. A collection of installed plugins does not give you persistent memory across sessions, coordinated multi-agent workflows, quality gates on tool use, or a calibrated system prompt built around your specific workflow. Those require something that knows how the pieces fit together.

Claudify is built for teams and developers who want that complete layer without assembling and tuning it themselves. The skills, agents, hooks, and memory system are pre-wired and tested as a unit. If you find yourself installing many plugins and writing glue to connect them, that is the signal that an operating system approach saves more time.

FAQ

What is the difference between a Claude Code plugin and an MCP server?

An MCP server is a single external tool integration that Claude can call as a tool (for example, a Stripe MCP that lets Claude query transactions). A plugin is a bundle that can include one or more MCP server connections alongside skills, agents, hooks, and other components. The official marketplace includes "external integration" plugins that are essentially pre-configured MCP bundles, making them faster to install than setting up an MCP server manually via .mcp.json.

Do I need to restart Claude Code after installing a plugin?

No. Run /reload-plugins after installing, enabling, or disabling plugins to pick up changes in the current session. Restarting is not required. Note that reloading has a small token cost because newly loaded components announce themselves in context.

Can I use plugins alongside my existing .claude/ configuration?

Yes, and they coexist cleanly. Your standalone .claude/ skills and agents load alongside plugin-provided ones. The only naming consideration: if you have a standalone agent and a plugin agent with the same name, the standalone version takes precedence. Use the namespace prefix to invoke the plugin version explicitly.