How to Share Plugins Across Projects and Teams in Claude Code

Claude Code supports three complementary methods for sharing plugins: marketplace installation for global availability, project-level configuration for repository-specific tools, and managed settings for organization-wide enforcement.

The anthropics/claude-code repository provides a flexible plugin architecture that enables teams to distribute functionality across multiple projects and developers. Because the discovery mechanism is file-system based, you can share plugins through the built-in marketplace, version-controlled configuration files, or centralized policy management.

Understanding Plugin Discovery

When Claude Code starts, it walks plugin directories in a specific order of precedence. This hierarchy determines which plugins load and allows fine-grained control over activation.

The discovery sequence follows three tiers:

1. User-wide cache (~/.claude/plugins/) – plugins installed via /plugin install from the marketplace
2. Project-specific settings (.claude/settings.json) – plugins listed in the enabledPlugins array
3. Managed settings (managed-settings.json or fragments in managed-settings.d/) – organization-enforced policies

This order lets projects explicitly disable globally installed plugins by omitting them from enabledPlugins or through managed policy overrides. According to the source documentation in plugins/README.md, plugins "can be shared across projects and teams" through these complementary mechanisms.

Method 1: Share Plugins via the Marketplace

The Marketplace provides the simplest distribution method for public or widely used internal plugins. The marketplace manifest lives in .claude-plugin/marketplace.json and defines available plugins that can be installed with a single command.

To install a plugin globally:

/plugin install commit-commands@claude-code-marketplace

This command copies the plugin into the user-wide cache at ~/.claude/plugins/, making it available to every Claude Code session on the machine. The marketplace approach works best for tools that every developer in your organization should have access to, such as security guidance or standardized commit helpers.

Method 2: Share Plugins at the Project Level

For private or repository-specific tools, use project-level configuration. This method stores plugin references in .claude/settings.json at the repository root, ensuring any teammate pulling the code gets the same plugin version.

Create or edit .claude/settings.json:

{
  "enabledPlugins": [
    "./plugins/feature-dev",
    "https://github.com/my-org/extra-plugin.git#v1.2.3"
  ]
}

Claude Code loads plugins from relative paths or Git URLs when the project opens. The examples/settings/settings-lax.json file in the repository demonstrates the minimal structure required for project-level enablement.

As noted in CHANGELOG.md (v2.1.80), project configurations are now shared across git worktrees of the same repository. This means a single .claude/settings.json at the monorepo root automatically applies to every worktree, simplifying plugin distribution for large codebases.

Method 3: Enforce Plugins Organization-Wide with Managed Settings

Organization administrators can enforce plugin policies across entire teams using managed settings. This approach guarantees consistent behavior by loading configuration after user and project settings, effectively overriding individual preferences.

Create a managed-settings.json file:

{
  "enabledPlugins": [
    "security-guidance",
    "pr-review-toolkit"
  ],
  "permissions": {
    "disableBypassPermissionsMode": "disable"
  }
}

Store this file in a central location (such as a shared repository or network-mounted directory) and reference it when launching Claude Code:

claude --managed-settings /path/to/managed-settings.json

You can also use the managed-settings.d/ directory to compose policies from multiple fragment files, enabling different teams to maintain their own plugin manifests while sharing a common base configuration.

Practical Implementation Examples

Installing from the Marketplace

For plugins listed in .claude-plugin/marketplace.json, use the install command:

# Install the bundled security-guidance plugin globally

/plugin install security-guidance@claude-code-marketplace

Configuring Project-Level Plugins

Reference the example in examples/settings/settings-lax.json to structure your project configuration:

{
  "enabledPlugins": [
    "./internal-tools",
    "https://github.com/anthropics/claude-code-plugins.git#main"
  ]
}

Setting Up Organization-Wide Policies

Force specific plugins for all team members while restricting certain permissions:

{
  "enabledPlugins": ["compliance-checker", "internal-docs"],
  "permissions": {
    "webSearch": "disable",
    "disableBypassPermissionsMode": "disable"
  }
}

Sharing Across Git Worktrees

In monorepos with multiple worktrees, plugin configurations propagate automatically:

git worktree add ../feature-branch feature

# .claude/settings.json from the main worktree applies to the new worktree

This behavior, introduced in v2.1.80 per CHANGELOG.md, ensures that adding a worktree does not require reconfiguring plugins.

Summary

• Marketplace installation (/plugin install) stores plugins in ~/.claude/plugins/ for global availability across all sessions.
• Project-level configuration (.claude/settings.json) enables repository-specific plugins through the enabledPlugins array, with support for relative paths and Git URLs.
• Managed settings (managed-settings.json or managed-settings.d/) allow administrators to enforce plugin policies across organizations using the --managed-settings CLI flag.
• The three-tier discovery hierarchy (user cache → project settings → managed settings) provides flexible scoping while allowing overrides.
• Git worktrees of the same repository automatically share project configurations, simplifying plugin management in monorepos.

Frequently Asked Questions

Can I disable a globally installed plugin for a specific project?

Yes. Because Claude Code loads project-specific .claude/settings.json after the user-wide cache, you can omit the plugin from the enabledPlugins array in that project. The plugin remains installed in ~/.claude/plugins/ but will not activate for that specific repository.

How do I version control custom plugins for my team?

Store your plugin code in a shared repository (such as my-org/claude-plugins), then reference it in each project's .claude/settings.json using a Git URL with a specific tag or commit hash: "https://github.com/my-org/claude-plugins.git#v1.2.3". This ensures every teammate uses the same plugin version without requiring manual installation steps.

What is the difference between managed settings and project settings?

Project settings (.claude/settings.json) live in the repository and apply to anyone opening that project, making them ideal for repository-specific tools. Managed settings (managed-settings.json) are loaded via the --managed-settings CLI flag and apply organization-wide, overriding both user and project configurations to enforce compliance or standardization policies.

Do plugins work across git worktrees in a monorepo?

Yes. As documented in CHANGELOG.md for version 2.1.80, Claude Code shares project configurations and auto-memory across git worktrees of the same repository. When you create a new worktree with git worktree add, the same .claude/settings.json from the repository root applies automatically, ensuring consistent plugin availability without duplication.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}