What Is the Role of the Plugins Directory in the Knowledge Work Plugins Repository

The plugins directory serves as a modular extension system where each top-level folder represents a self-contained plugin that extends Claude Code or Claude Cowork with domain-specific knowledge, slash commands, and external tool connectors.

The anthropics/knowledge-work-plugins repository implements a file-based plugin architecture that allows teams to customize Claude's behavior without modifying source code. At the root of this system lies the plugins directory, a collection of independent folders that collectively provide specialized workflows for productivity, sales, customer support, and other business functions.

Modular Architecture of the Plugins Directory

The plugins directory functions as a modular extension point where each top-level folder—such as productivity/, sales/, or customer-support/—operates as an isolated plugin unit. Because these plugins are pure-file artifacts containing no compiled code, they can be version-controlled, forked, and customized independently according to the repository's conventions.

Standard Directory Structure

Every plugin within the plugins directory follows a consistent layout defined in the repository README:

plugin-name/
├── .claude-plugin/plugin.json   # Plugin manifest

├── .mcp.json                    # MCP connector definitions

├── commands/                    # Slash-commands invoked explicitly

└── skills/                      # Domain-knowledge files Claude uses automatically

This convention ensures that Claude Code can automatically discover and load capabilities regardless of the specific domain.

Configuration Files

Two critical files define how each plugin integrates with Claude:

• .claude-plugin/plugin.json: The manifest file describing the plugin's name, description, and version. Located at paths like productivity/.claude-plugin/plugin.json, this file registers the plugin with Claude's extension system.
• .mcp.json: The MCP (Model Context Protocol) connector configuration that specifies how Claude communicates with external services such as CRMs, data warehouses, or design applications.

Domain Specialization Through Skills and Commands

Each folder in the plugins directory bundles skills and commands that tailor Claude's behavior to specific professional workflows.

Skills for Automatic Context

The skills/ subdirectory contains Markdown files that encode domain expertise and best-practice workflows. Claude automatically references these files when relevant to the current conversation context, effectively providing implicit domain knowledge without requiring explicit user commands.

Commands for Explicit Invocation

The commands/ subdirectory houses slash-command definitions that users invoke manually. For example, installing the sales plugin enables commands like /sales:call-prep, which launches the "call-prep" command defined in the sales/commands/ directory.

Discovery and Installation Workflow

The plugins directory supports a streamlined installation process through Claude Code's CLI interface.

First, add the marketplace source:

# Add the marketplace (once per Claude Code environment)

claude plugin marketplace add anthropics/knowledge-work-plugins

Then install specific plugins:

# Install a specific plugin (e.g., the sales plugin)

claude plugin install sales@knowledge-work-plugins

Finally, invoke commands provided by the installed plugin:

# Invoke a slash-command provided by a plugin

/sales:call-prep   # launches the "call-prep" command from the sales plugin

These commands reference the individual plugin folders within the plugins directory, pulling configuration from their respective .claude-plugin/plugin.json and .mcp.json files.

Customization and Version Control

Because the plugins directory contains only text files—Markdown for skills and commands, JSON for configuration—teams can customize behavior by editing files directly in their forked repository. Modifying connector URLs in .mcp.json, adjusting terminology in skills/ Markdown files, or updating command definitions requires no compilation; reinstalling the plugin applies changes immediately.

Summary

• The plugins directory contains independent, domain-specific folders that extend Claude Code/Cowork functionality.
• Each plugin follows a strict layout with .claude-plugin/plugin.json, .mcp.json, commands/, and skills/ directories.
• Skills provide automatic domain context through Markdown files, while commands offer explicit slash-command invocation.
• Plugins install via claude plugin install and integrate external tools through MCP connectors defined in .mcp.json.
• The file-based architecture enables easy version control and customization without compiled code.

Frequently Asked Questions

What files are required in each plugin folder?

Every plugin must contain a .claude-plugin/plugin.json manifest file describing the plugin metadata, and typically includes a .mcp.json file for external tool connectors. The skills/ and commands/ directories are optional but recommended for providing domain knowledge and explicit commands respectively.

How do I add a new plugin to the repository?

Create a new top-level directory following the standard plugin structure. Include the manifest file at .claude-plugin/plugin.json, add your Markdown skills to a skills/ folder, and define slash commands in a commands/ folder. No compilation is required—Claude Code reads these files directly.

Can I modify an existing plugin for my team's specific needs?

Yes. Since plugins in the anthropics/knowledge-work-plugins repository are pure-file artifacts, you can fork the repository, edit the Markdown skill files to include company-specific terminology, or adjust the .mcp.json connector configurations to point to your internal systems. Reinstall the modified plugin to apply your customizations.

What is the difference between skills and commands in a plugin?

Skills are Markdown files in the skills/ directory that Claude references automatically when relevant to the conversation context, providing implicit domain expertise. Commands are explicit slash-commands defined in the commands/ directory that users invoke manually, such as /sales:call-prep for preparing sales calls.

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