How to Develop Your Own Plugin Using the Knowledge-Work-Plugins Framework

You can develop custom Claude plugins for any role or workflow using the knowledge-work-plugins framework by creating a folder structure with a JSON manifest, optional MCP connectors, and markdown files that define commands and skills.

The anthropics/knowledge-work-plugins repository provides a fully-documented, file-based system that enables you to extend Claude Cowork and Claude Code without writing compiled code. Every plugin follows a minimal conventional layout using plain markdown and JSON, making it easy to version-control and iterate on domain-specific workflows.

Plugin Architecture Overview

All knowledge-work-plugins share a standardized directory structure that Claude recognizes automatically:

plugin-name/
├── .claude-plugin/plugin.json   # manifest describing the plugin

├── .mcp.json                    # optional MCP connector definitions

├── commands/                    # slash-command markdown files

└── skills/                      # domain-specific skill markdown files

The Manifest File

The manifest (.claude-plugin/plugin.json) declares your plugin's metadata. Claude reads this file to list the plugin in the marketplace and understand its purpose. As seen in [cowork-plugin-management/.claude-plugin/plugin.json](https://github.com/anthropics/knowledge-work-plugins/blob/main/cowork-plugin-management/.claude-plugin/plugin.json), this file contains the name, version, description, and author information.

MCP Connectors

The optional .mcp.json file maps logical tool identifiers (like "slack" or "notion") to MCP server endpoints. This allows your skills to call external APIs. For example, [product-management/.mcp.json](https://github.com/anthropics/knowledge-work-plugins/blob/main/product-management/.mcp.json) demonstrates how to configure connections to external services.

Commands Directory

Files in the commands/ directory define explicit slash commands (e.g., /write-spec) that users invoke directly in Claude sessions. These are typically one-line markdown files specifying the command syntax and arguments.

Skills Directory

The skills/ directory contains structured markdown files that encode domain knowledge and workflows. According to the source code, these files use front-matter blocks with name, description, and argument-hint fields, followed by plain text describing the workflow. A complete example is available in [product-management/skills/write-spec/SKILL.md](https://github.com/anthropics/knowledge-work-plugins/blob/main/product-management/skills/write-spec/SKILL.md).

Step-by-Step Guide to Developing Your Plugin

Follow these steps to develop your own plugin using the knowledge-work-plugins framework:

1. Create a new top-level folder (e.g., my-plugin) in your repository.

2. Add a manifest at .claude-plugin/plugin.json with your plugin's metadata, including name, version, and description.

3. (Optional) Add .mcp.json if your plugin needs to call external services like Google Drive or Slack.

4. Add a commands/ directory and write markdown files for any slash commands you want exposed (format: /my-command $ARG).

5. Add a skills/ directory and create skill markdown files with front-matter blocks describing the workflow logic in plain text.

6. Test locally by loading the plugin in Claude Cowork or Claude Code using claude plugin install my-plugin@knowledge-work-plugins.

7. Iterate on prompts, connector URLs, or command names until the behavior matches your expectations.

8. Commit and PR to share the plugin with the community.

Complete Plugin Example

Below is a minimal skeleton for a custom plugin called my-plugin that extracts quarterly sales numbers from CSV data.

Manifest Configuration

Create .claude-plugin/plugin.json:

{
  "name": "my-plugin",
  "version": "0.1.0",
  "description": "A custom plugin that extracts quarterly sales numbers from a CSV stored in Google Drive.",
  "author": {
    "name": "Your Name"
  }
}

Connector Setup

Create .mcp.json to enable Google Drive access:

{
  "mcpServers": {
    "googleDrive": {
      "type": "http",
      "url": "https://mcp.googledrive.com/mcp",
      "oauth": {
        "clientId": "<YOUR_CLIENT_ID>",
        "callbackPort": 3118
      }
    }
  }
}

Command Definition

Create commands/get-sales.md:

/get-sales $ARGUMENTS

Skill Implementation

Create skills/get-sales/SKILL.md:

---
name: get-sales
description: Retrieve quarterly sales figures from a CSV on Google Drive.
argument-hint: "<quarter e.g., Q1-2024>"
---

# Get Sales

1. **Validate the quarter argument** – make sure it matches `Q[1-4]-\d{4}`.  
2. **Locate the CSV** – use the Google Drive connector to search for a file named `sales-data.csv`.  
3. **Parse the CSV** – read the rows, filter for the requested quarter, and sum the `amount` column.  
4. **Return** a markdown table showing total sales and a brief trend comment.

```

/get-sales Q2-2024

```

```

| Metric | Value |
|--------|-------|
| Total Sales (Q2-2024) | $1,237,000 |
| YoY Growth | +12 % |

```

How Claude Processes Your Plugin

When Claude processes a user request with your plugin installed, it follows this workflow:

• Matches the request to a skill based on the name field in the skill's front-matter.
• Runs the scripted workflow defined in the skill markdown, including any questions or data formatting steps.
• Invokes any connectors defined in .mcp.json to fetch real-time data from external tools.
• Returns the result to the user, or exposes a slash command for manual triggering if the user prefers direct invocation.

Because the framework is deliberately "code-free", you only write structured prompts in skill files without managing build steps or compiled binaries.

Summary

• The knowledge-work-plugins framework uses a file-based architecture with JSON manifests and markdown skills.
• Every plugin requires .claude-plugin/plugin.json and at least one skill in the skills/ directory.
• MCP connectors in .mcp.json enable real-time data fetching from external APIs like Google Drive or Slack.
• Slash commands live in commands/ as simple markdown files, while skills contain the workflow logic.
• You can develop, test, and deploy plugins without build steps using standard git workflows.

Frequently Asked Questions

Do I need to know how to code to develop a knowledge-work-plugin?

No, the framework is designed to be code-free. You only need to write JSON for the manifest and connectors, and markdown for commands and skills. The logic is expressed through structured prompts in the skill files rather than compiled code, making it accessible to domain experts who understand workflows but don't write software.

How does Claude know which skill to use for a given request?

Claude matches user requests against the name and description fields in your skill's front-matter block. When the request context aligns with a skill's declared purpose, Claude runs the scripted workflow defined in that skill's markdown file. For explicit control, users can invoke commands directly from the commands/ directory.

Can my plugin integrate with external tools like Notion or Slack?

Yes, by adding a .mcp.json file to your plugin root, you can map logical tool identifiers to MCP server endpoints. When a skill needs external data, Claude invokes these connectors to fetch real-time information. Examples in the repository, such as product-management/.mcp.json, demonstrate how to configure these integrations.

What is the difference between a command and a skill?

Commands are explicit slash commands (like /write-spec) that users invoke manually by typing them in the Claude interface. Skills are automated workflows that Claude runs automatically when it detects a matching request context. Commands live in the commands/ directory as simple one-line markdown files, while skills reside in skills/ with detailed workflow logic and front-matter metadata.

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