Claude Code Plugins: How to Build, Discover, and Install Plugins

Anthropic's official Claude Code marketplace shipped with 101 plugins by early 2026, split between 33 first-party and 68 partner integrations, according to a Build to Launch review that tested 11 of them in depth. Community registries have since indexed over 14,000 additional plugins. The gap between "available" and "useful" is real, but the ecosystem is growing fast enough that understanding the plugin system is worth the investment.

A Claude Code plugin is a self-contained directory that extends Claude Code with custom functionality. According to the official plugins reference, plugins can include skills, agents, hooks, MCP servers, LSP servers, background monitors, themes, and default settings. The key difference between a plugin and standalone configuration in your .claude/ directory is distribution: plugins are namespaced, versioned, and shareable through marketplaces.

Here is the taxonomy that most existing coverage gets wrong:

Standalone skills live in your .claude/ directory. You invoke them with short names like /deploy or /review. They work for personal workflows and project-specific customizations.

Plugin skills are packaged inside a plugin directory with a manifest file. They get namespaced names like /my-plugin:deploy to prevent conflicts when multiple plugins define skills with the same name. They are designed for sharing with teammates and distributing to the community.

IDE extensions (VS Code, JetBrains) are a separate system entirely. They modify the editor UI and integrate Claude into the IDE workflow, but they do not use the plugin manifest format or marketplace system described here.

A plugin can bundle any combination of these components:

• Skills in skills/ directories, each containing a SKILL.md file with YAML frontmatter and instructions
• Agents in agents/ as markdown files that define specialized subagents with their own system prompts, model preferences, and tool restrictions
• Hooks in hooks/hooks.json that respond to lifecycle events like PostToolUse, SessionStart, or PreToolUse
• MCP servers in .mcp.json that connect Claude to external tools and services
• LSP servers in .lsp.json for real-time code intelligence (diagnostics, go-to-definition, find-references)
• Background monitors in monitors/monitors.json that watch logs or external status and notify Claude as events arrive
• Themes in themes/ for custom color schemes
• Default settings in settings.json for activating a custom agent as the main thread

Every plugin starts with a directory and an optional manifest file. The manifest lives at .claude-plugin/plugin.json inside the plugin folder. If you skip the manifest, Claude Code auto-discovers components in their default locations and derives the plugin name from the directory name.

Start by creating the directory structure:

mkdir -p my-plugin/.claude-plugin
mkdir -p my-plugin/skills/code-review

Create the manifest at my-plugin/.claude-plugin/plugin.json:

{
  "name": "my-plugin",
  "description": "Code review and formatting tools",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

The name field does double duty: it serves as the unique identifier and becomes the namespace prefix for all skills. Setting version explicitly means users only receive updates when you bump it. If you leave version out and distribute via git, every commit counts as a new version.

Now create a skill. Each skill is a folder inside skills/ containing a SKILL.md file:

---
description: Reviews code for best practices and common issues
---

When reviewing code, check for:
1. Code organization and structure
2. Error handling patterns
3. Security concerns (injection, XSS, auth)
4. Test coverage gaps
5. Performance bottlenecks

Provide specific line references and suggest fixes.

Test it locally using the --plugin-dir flag:

claude --plugin-dir ./my-plugin

Once Claude Code starts, invoke your skill with /my-plugin:code-review. Run /help to confirm it appears in the skill list. As you iterate, use /reload-plugins to pick up changes without restarting the session.

Skills accept dynamic input through the $ARGUMENTS placeholder. If your SKILL.md contains Review the file at "$ARGUMENTS", then running /my-plugin:code-review src/auth.ts passes the file path into the prompt.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/lint.sh"
          }
        ]
      }
    ]
  }
}

{
  "mcpServers": {
    "project-api": {
      "command": "npx",
      "args": ["@company/mcp-server", "--plugin-mode"],
      "cwd": "${CLAUDE_PLUGIN_ROOT}"
    }
  }
}

Claude Code ships with the official Anthropic marketplace pre-registered. Run /plugin to open the plugin manager, then navigate to the Discover tab to browse what is available. You can also install directly from the command line:

/plugin install github@claude-plugins-official

The official marketplace includes several categories worth knowing about:

Code intelligence plugins configure LSP connections for languages like TypeScript, Python, Rust, Go, Swift, and C++. Once installed, Claude gets instant diagnostics after every edit and can jump to definitions, find references, and see type information. These require the language server binary to be installed on your system.

Integration plugins bundle pre-configured MCP servers for external services. The current lineup includes GitHub, GitLab, Atlassian (Jira/Confluence), Asana, Linear, Notion, Figma, Vercel, Firebase, Supabase, Slack, and Sentry.

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

Workflow plugins add skills for common development tasks: commit-commands for git workflows, pr-review-toolkit for pull request review, and plugin-dev for building your own plugins.

Beyond the official marketplace, add the community marketplace for third-party plugins:

/plugin marketplace add anthropics/claude-plugins-community

Install from it using the claude-community name:

/plugin install some-plugin@claude-community

Marketplaces also support private git repositories, GitLab, Bitbucket, local directories, and remote URLs. A team lead can host an internal marketplace in a private GitHub repo and share it with the team through the project's .claude/settings.json:

{
  "extraKnownMarketplaces": {
    "team-tools": {
      "source": {
        "source": "github",
        "repo": "your-org/claude-plugins"
      }
    }
  }
}

When team members trust the repository folder, Claude Code prompts them to install these marketplaces and plugins automatically.

Give your Claude Code plugins persistent file storage

Fast.io provides shared storage with MCP access at /mcp, auto-indexed files for semantic search, and ownership transfer from agent to human. Starts with a 14-day free trial.

Start 14-Day Trial

Understanding the full manifest schema helps when building plugins that go beyond simple skills. The .claude-plugin/plugin.json file supports these fields:

{
  "name": "deployment-tools",
  "displayName": "Deployment Tools",
  "version": "2.1.0",
  "description": "CI/CD automation for production deploys",
  "author": {"name": "Dev Team"},
  "homepage": "https://docs.example.com",
  "repository": "https://github.com/team/plugin",
  "license": "MIT",
  "keywords": ["deployment", "ci-cd"],
  "dependencies": [
    "helper-lib",
    {"name": "secrets-vault", "version": "~2.1.0"}
  ],
  "userConfig": {
    "api_token": {
      "type": "string",
      "title": "API Token",
      "description": "Your deployment service API token",
      "sensitive": true
    }
  }
}

The dependencies array declares other plugins that yours requires. When a user installs your plugin, dependencies are auto-installed alongside it. Version constraints follow semver syntax.

The userConfig field defines values that Claude Code prompts for when the plugin is enabled. Sensitive values (API tokens, secrets) are stored in the system keychain rather than settings.json. Non-sensitive values are available for substitution as ${user_config.KEY} in MCP configs, hook commands, and monitor commands.

Three environment variables are available across all plugin components:

• ${CLAUDE_PLUGIN_ROOT} points to the plugin's installation directory. Use it to reference bundled scripts and configs.
• ${CLAUDE_PLUGIN_DATA} is a persistent directory that survives plugin updates. Store installed dependencies (node_modules, virtual environments) and caches here.
• ${CLAUDE_PROJECT_DIR} points to the project root where Claude Code was launched.

claude plugin init my-tool

A marketplace is a git repository (or a hosted JSON file) containing a .claude-plugin/marketplace.json catalog. Each entry in the catalog points to a plugin source, either a subdirectory in the same repository or an external git URL.

To submit a plugin to the official community marketplace, use one of Anthropic's submission forms:

• claude.ai: Navigate to Admin Settings, then Directory, then Submissions, then Plugins
• Console: Go to platform.claude.com/plugins/submit

Run claude plugin validate locally before submitting. The review pipeline runs the same validation along with automated safety screening. Approved plugins are pinned to a specific commit SHA in the community catalog, and CI bumps the pin automatically as you push new commits.

For private distribution, create your own marketplace repository:

1. Create a git repository with a .claude-plugin/marketplace.json file
2. Add entries pointing to your plugin directories or external repos
3. Share the marketplace with your team using extraKnownMarketplaces in the project's .claude/settings.json

Users add your marketplace and install plugins from it:

/plugin marketplace add your-org/your-marketplace
/plugin install your-plugin@your-marketplace

Marketplace auto-updates are configurable per marketplace. Official marketplaces have auto-updates enabled by default. When an update is available, Claude Code refreshes the marketplace data at startup and prompts users to run /reload-plugins.

The MCP server bundling capability makes plugins the natural distribution mechanism for workspace integrations. Rather than asking every developer on a team to manually configure MCP connections, a plugin packages the server config once and distributes it through a marketplace.

For local file management, agents using Claude Code already have direct filesystem access. But when teams need persistent storage that survives across sessions, shared workspaces where agents and humans collaborate on the same files, or structured handoff from agent to human, a cloud workspace adds a layer that local storage cannot provide.

Options for persistent agent storage include S3 buckets (cheap, no collaboration features), Google Drive or Dropbox (familiar but limited API access for agents), and purpose-built agent workspaces like Fast.io that expose MCP endpoints for direct agent access.

Fast.io's MCP server provides Streamable HTTP at /mcp and legacy SSE at /sse, with 19 consolidated tools covering workspace operations, file management, AI queries, and workflow automation. A plugin could bundle this as a pre-configured MCP server, giving every team member's Claude Code instance workspace access on install. Every org starts with a 14-day free trial, with storage, monthly credits, and workspaces scaled to each plan, which removes the friction of getting a team started.

Intelligence Mode auto-indexes uploaded files for semantic search and citation-backed chat, so agents can query project documentation without setting up a separate vector database. Ownership transfer lets an agent build workspaces and shares, then hand them off to a human client while retaining admin access.