What Is a Claude Plugin? How Cowork and Claude Code Plugins Bundle MCPs, Skills, and Tools

A Claude Plugin is Anthropic’s packaging format that bundles Model Context Protocol (MCP) servers, skills, and custom slash commands into a single installable unit. Plugins run in both Claude Code (the CLI agent) and Cowork mode (the desktop app), letting individuals and organizations ship one bundle that works across developer and end-user environments. You should note that plugins can be distributed as standalone .plugin archives or through a plugin marketplace, making them a first-class way to extend Claude across teams. This unified packaging approach reduces friction for both creators and consumers of Claude extensions, and is rapidly becoming the preferred way to distribute sophisticated AI workflows.

Think of a plugin as the Claude equivalent of a browser extension or a mobile application. When you install a Chrome extension, you click Add, grant permissions, and the extension is immediately available across every webpage. The same applies to Claude Plugins: install once, and every component inside (integrations, instructions, commands) becomes available at the same time without requiring any manual configuration. Keep in mind that this is fundamentally different from manually registering an MCP server or writing individual skill files: plugins wrap MCPs together with skills and commands so that end users do not have to stitch the pieces together themselves. They simply install and start using the capabilities.

What Is a Claude Plugin?

A Claude Plugin is an extension package format introduced by Anthropic for Claude Code and Cowork. It contains everything needed to extend Claude’s capabilities — MCP servers for external tool integrations, skills for specialized task workflows, and slash commands for custom shortcuts — all bundled into a single archive that users can install with one step. Important: plugins unify the experience for engineers using the CLI and for non-engineers using the desktop app, eliminating the gap between those two audiences that has long plagued AI tooling.

To put it simply, if you have ever installed a browser extension from the Chrome Web Store, you already understand the user experience of a Claude Plugin. Instead of editing configuration files by hand to register a new MCP server or copying skill files into a directory, you install a plugin and everything inside it becomes available immediately. This dramatically lowers the barrier for teams to share AI workflows internally or publicly. It is important to note that this design reflects a broader industry shift: AI platforms are moving from raw API access toward packaged, discoverable, and shareable extension ecosystems, and Claude Plugins are Anthropic’s flagship answer to that demand.

The plugin format also solves a real operational problem that teams encountered in the early days of MCP: onboarding. Before plugins existed, setting up a new engineer with the right AI tooling meant walking them through a lengthy configuration process that often involved git clones, dependency installations, and manual token configuration. With plugins, that onboarding compresses to a single install command, which is a massive improvement for large organizations.

How to Pronounce Claude Plugin

How Claude Plugins Work

A Claude Plugin is packaged as a .plugin archive, which is a ZIP-formatted container. Inside, a manifest file named plugin.json declares metadata such as the plugin’s name, version, author, permissions, and the components it contains. The remaining directories hold the actual implementations: MCP server configurations, skill definitions, and command templates. When you install a plugin, Claude reads the manifest, resolves dependencies, registers each component in the right subsystem, and makes the plugin’s functionality available to the agent. This process is completely transparent to the end user and typically completes in under a second.

The three building blocks you should understand are these. First, MCP servers connect Claude to external tools and APIs through the standardized Model Context Protocol. An MCP server might expose GitHub issue management, Slack messaging, Google Drive file operations, or any other capability you can imagine. Second, skills are Markdown-based instruction sets that teach Claude how to handle specialized tasks, complete with trigger conditions and step-by-step procedures. Skills encode domain expertise that would otherwise live only in engineers’ heads. Third, slash commands are lightweight shortcuts that let users invoke common actions by typing a single command. It is important to remember that a plugin does not have to include all three components — many useful plugins contain only an MCP server or only a skill. The flexibility of the format means plugins can be as simple or as complex as the problem requires.

The Claude runtime also enforces isolation between plugins. Each plugin’s MCP servers run in their own process, which prevents one plugin from accidentally corrupting the state of another. Skills and commands are namespaced so they can coexist even when plugins have overlapping concerns. You should keep this isolation model in mind when designing plugins: treat your plugin as a self-contained module that does not need to communicate with other plugins except through standard Claude interfaces.

Plugin Directory Layout

Here is the standard directory layout that Claude Code expects when it loads a plugin. Note that each subdirectory is optional — include only the components your plugin actually provides. If your plugin only ships a skill, you can omit the mcp/ and commands/ directories entirely.

my-plugin.plugin/
├── plugin.json          # Manifest file (required)
├── mcp/
│   └── my-mcp-server.json  # MCP server definition
├── skills/
│   └── my-skill/
│       └── SKILL.md     # Skill trigger and procedure
└── commands/
    └── my-command.md    # Custom slash command

When Claude loads the plugin, it parses plugin.json first and uses the declared components as an index into the directories. This means you can inspect any plugin’s manifest to understand its surface area before installing, which is an important security practice that you should always follow.

Claude Plugin Usage and Examples

Let us walk through a minimal plugin that wraps the official GitHub MCP server and adds a custom triage command. This example assumes you already have a personal access token for GitHub stored in an environment variable named GITHUB_TOKEN. In practice, teams often manage this token through a secret management system rather than requiring each user to provision their own.

Example plugin.json

{
  "name": "github-issue-helper",
  "version": "1.0.0",
  "description": "Operate GitHub issues from Claude",
  "author": "example@company.com",
  "mcp_servers": [
    {
      "name": "github",
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  ],
  "skills": ["issue-triage"],
  "commands": ["triage-issues"]
}

Example Skill File (skills/issue-triage/SKILL.md)

---
name: issue-triage
description: Triage GitHub issues by applying labels, milestones, and assignments
---

When the user asks to triage issues:
1. List open issues without labels using the github MCP server.
2. For each issue, infer the most appropriate label based on the title and body.
3. Suggest an assignee from the team list when the issue topic matches.
4. Apply labels, milestones, and assignments only after user confirmation.

Installing and Using the Plugin

# Install the plugin in Claude Code
claude plugin install ./my-plugin.plugin

# Verify it is registered
claude plugin list

# Run the custom command
/triage-issues owner/repo

For Cowork, the flow is different but simpler: open the plugin marketplace inside the desktop app, search for the plugin, and click install. Note that Cowork currently exposes a subset of CLI-only features (such as direct terminal execution), so some plugins may only work fully in Claude Code. In practice, teams often build plugins that gracefully degrade — providing full functionality in Claude Code and a read-only or simplified experience in Cowork. You should document these differences clearly in your plugin’s README so users know what to expect in each environment.

Advantages and Disadvantages of Claude Plugins

Advantages

• One-step installation: A single .plugin file bundles every component, so users do not have to copy MCP configs and skill files separately. This is a dramatic improvement over the pre-plugin workflow, which required users to follow multi-page setup guides.
• Works across Claude Code and Cowork: You write the plugin once and it runs in both environments, unifying developer and knowledge-worker experiences. Organizations with mixed engineering and non-engineering audiences benefit the most from this cross-environment compatibility.
• Marketplace distribution: Plugins can be published, discovered, and rated through Anthropic’s plugin marketplace or through private organization marketplaces. Discoverability is a real value multiplier compared with sharing raw MCP configurations through wikis.
• Version control: Because the manifest declares semantic versions, organizations can roll out consistent versions across their workforce and pin to specific releases when breaking changes ship.
• Centralized permissions: Permission requirements are declared once in the manifest, making security audits straightforward. Security teams can review a plugin’s declared permissions before approving it for organizational use.
• Composable architecture: Multiple plugins can co-exist, and users can mix and match them to build a personalized Claude setup tailored to their specific workflow.
• Isolation: Plugin MCP servers run in separate processes, which prevents one plugin from destabilizing another. This improves reliability compared with monolithic integrations.

Disadvantages

• Security exposure: Installing a plugin from an untrusted source can leak credentials or make unintended network calls. You should always review the manifest before installing, and treat plugins from the open marketplace with the same caution you apply to any third-party software.
• Runtime dependencies: If an MCP server uses Node.js or Python, those runtimes must be available locally, which may require additional setup for users on restricted machines.
• Command collisions: If two plugins define the same slash command, they will collide. Prefixing commands with a namespace is a recommended practice, but not yet strictly enforced.
• Marketplace maturity: As of 2026, the Claude plugin marketplace is still maturing, so discoverability outside of official channels is limited compared with mature ecosystems like VS Code extensions or npm packages.
• Documentation burden: A good plugin requires clear documentation covering installation, configuration, and usage. This is more work than simply publishing an MCP server.

Claude Plugin vs MCP: What Is the Difference?

Plugins and MCP are related but operate at different layers of the stack. You should keep this distinction in mind when designing: a plugin is a distribution unit, while MCP is the communication protocol that a plugin may (or may not) use internally. Think of MCP as analogous to HTTP — a wire protocol that enables communication — and a plugin as analogous to a browser extension that uses HTTP to talk to servers but bundles UI, settings, and behavior into a distributable package.

In practice, the usual pattern is: build or find an MCP server, then wrap it in a plugin with relevant skills and commands for distribution. Important: if you only need to expose tool integrations to yourself on the CLI, a plain MCP server is fine; if you want to distribute a full workflow to a team, a plugin is the right abstraction. The two concepts complement each other rather than competing, and most production Claude deployments use both.

Common Misconceptions

Misconception 1: Plugins only work in Claude Code

This is incorrect. Claude Plugins are designed to run in both Claude Code and Cowork. Some CLI-specific capabilities (such as terminal execution) may be unavailable in Cowork, but the plugin structure itself is portable and the majority of components work identically in both environments. The confusion often arises because Claude Code launched plugin support first.

Misconception 2: A plugin is just an MCP server

MCP servers are only one of three components. A plugin may contain MCPs, skills, slash commands, or any combination of the three. Bundling them together is what makes plugins more powerful than raw MCP registrations, because it lets plugin authors encode both the connection and the usage patterns.

Misconception 3: Plugins must be approved by Anthropic

Private and local plugins do not require review. Only plugins published to Anthropic’s official marketplace go through a guideline-based review. Organizations can freely ship plugins internally, and hobby developers can distribute plugins through GitHub without any approval process.

Misconception 4: Installing a plugin automatically activates everything

Installation does not always mean activation. Many environments require explicit activation, and you can toggle individual features of a plugin on and off after installation. This is especially useful when a plugin contains optional components that not every user needs.

Misconception 5: Plugins lock you into a specific Claude model

Plugins are model-agnostic. They work with Claude Opus, Sonnet, and Haiku, and the same plugin will function even when Anthropic releases newer model versions. The plugin format specifies what capabilities to expose, not which model to use.

Real-World Use Cases

Several use cases have emerged since plugins launched. The first is the internal engineering plugin, which bundles GitHub, Jira, and Slack MCP servers with skills that encode the organization’s coding standards. Engineers install it once and instantly get a Claude tuned for their company’s workflow. Large engineering organizations report significant onboarding-time reductions after rolling out an internal plugin.

A second pattern is the marketing operations plugin, which combines Google Analytics, Search Console, and ad platform integrations with report-generation skills. Marketing teams run weekly reports without touching a spreadsheet. Keep in mind that these plugins often encode domain-specific metrics and terminology that off-the-shelf tools cannot capture. Marketing leaders find this particularly valuable because it lets their analysts focus on interpretation rather than data wrangling.

A third category is vertical plugins for regulated industries: HL7 FHIR integrations for healthcare, case-law databases for legal teams, and patient-intake workflows for clinics. Some startups now ship Claude plugins as a primary go-to-market channel, effectively building Vertical SaaS on top of Claude. This model has particular appeal for small teams because it lets them leverage Anthropic’s infrastructure while focusing their own efforts on domain expertise.

A fourth pattern is the customer-support plugin, which connects to help desk systems like Zendesk or Intercom, pulls context from CRM systems, and applies company-specific response templates. Support teams use this to generate draft replies that agents then review and send, reducing average handle time while maintaining quality.

A fifth emerging pattern is the research-and-analysis plugin, which combines web search, data extraction, and document-generation skills. Knowledge workers in consulting, journalism, and academic research use these plugins to compress what was previously multi-day research into a few hours of guided exploration. The plugin bundles sources the organization trusts, prompts that enforce citation discipline, and templates that match the team’s preferred output format. You should note that research plugins are one of the highest-value use cases because they codify the tacit knowledge that distinguishes expert researchers from beginners, and they make that knowledge available to every team member.

Finally, consider the onboarding plugin category. Large organizations increasingly ship a plugin to every new employee on day one. That plugin contains MCPs for the internal knowledge base, skills that explain company-specific jargon, and commands that automate common new-hire tasks like requesting equipment or booking training sessions. New hires reach productivity much faster when they have a Claude configured to their company from the moment they log in. Important: this pattern has strategic value beyond productivity, because it shapes how new employees form their mental models of the organization.

Frequently Asked Questions (FAQ)

Q1. What skills do I need to build a plugin?

A. At minimum, JSON editing and Markdown writing are all that is required. You can reach for Node.js or Python if you need to build a custom MCP server, but using existing MCP servers only requires configuration. Many successful plugins consist entirely of existing MCPs plus a well-written skill.

Q2. How do I secure my plugin?

A. Install plugins only from trusted sources, review the manifest’s permissions section before approving installation, and pass credentials through environment variables rather than hard-coding them. Plugins that handle sensitive data should publish clear threat models that document what data is accessed and where it is sent.

Q3. How can I distribute a plugin?

A. You have several options: (1) share the .plugin file directly via email or file share, (2) publish to a GitHub repository where users can download releases, (3) list on Anthropic’s official marketplace, or (4) run a private marketplace inside your organization that only your employees can access.

Q4. Are plugins free?

A. Most plugins available today are free, but the plugin format supports paid distribution. Anthropic has indicated that paid plugin monetization will be available on the marketplace in the future, which will open up opportunities for commercial plugin vendors.

Q5. How do I update a plugin?

A. Run claude plugin update <name> or click Update in the management UI. You should version your manifest with semantic versioning so downstream users can pin to specific releases when needed. Marketplace plugins typically offer automatic update prompts.

Q6. Can I build a plugin without writing code?

A. Yes. If the MCP servers you want already exist, and your skill content is prose-based rather than programmatic, you can ship a useful plugin with only configuration and Markdown files. This is a major accessibility improvement over older integration formats.

Q7. Do plugins share data with each other?

A. Not directly. Each plugin runs in isolation and communicates with Claude, not with other plugins. If you need cross-plugin workflows, you compose them at the Claude level by using outputs from one plugin as inputs to another.

Conclusion

• A Claude Plugin is an installable package that bundles MCP servers, skills, and slash commands into a single .plugin archive.
• Plugins run in both Claude Code and Cowork, giving developers and end users a unified extension model that works across environments.
• The manifest file (plugin.json) declares metadata, components, and permissions, and serves as the entry point for installation.
• MCP is the protocol; plugins are the distribution unit. They complement each other rather than compete.
• Security, dependency management, and command namespacing are the most important practical considerations for plugin authors.
• Real-world plugins cover internal engineering tools, marketing operations, vertical industry workflows, and customer-support automation.
• You can start building a plugin with nothing more than a text editor and existing MCP servers, making the format accessible to non-developers.
• The plugin ecosystem is still maturing, so early adopters have an opportunity to shape best practices and establish leadership in the space.

References