Prerequisites for Developing Plugins for Knowledge Work: The Complete Setup Guide

Developing knowledge-work plugins requires only a Git-compatible editor, Claude Cowork or Claude Code access, and basic Markdown knowledge—no compilation or runtime environment is necessary because plugins are pure-data packages consisting of Markdown skill files, JSON manifests, and optional connector definitions.

The anthropics/knowledge-work-plugins repository provides customizable AI assistants for specific professional roles. Understanding the prerequisites for developing plugins for knowledge work allows you to tailor these lightweight packages to your organization's unique processes without managing complex technical infrastructure.

Essential Prerequisites for Developing Plugins

Knowledge-work plugins are pure-data packages. You do not need a compiler, runtime environment, or advanced programming skills to create or customize them.

Claude Cowork or Claude Code Access

Plugins execute exclusively within Anthropic's Cowork or Claude Code products. You must maintain an active subscription that includes these capabilities. According to the repository's README.md, this access provides the execution environment that interprets your plugin's skill files and connector configurations.

Git-Compatible Editor

Because plugins are simply files in a Git repository, any text editor capable of handling Markdown, JSON, and optional YAML suffices. Popular choices include VS Code, Neovim, or JetBrains IDEs. The file structure, documented in README.md (lines 51-59), requires no specialized IDE plugins or build configuration.

Basic Markdown Knowledge

Skills are authored in Markdown with specific front-matter requirements. You should understand how to create headings, lists, code blocks, and YAML front-matter fields. The format specification in README.md (lines 53-59) defines how Claude parses these files to trigger automatic behaviors when users interact with the plugin.

Domain Expertise Requirements

Understanding the target role is as critical as technical setup.

Role-Specific Process Knowledge

Effective plugins require intimate knowledge of the workflows, terminology, and tools used by the professional role you are automating—whether finance, marketing, or customer support. The "Making Them Yours" section of README.md (lines 69-73) emphasizes that skills must reflect actual organizational processes rather than generic templates.

Optional Development Components

While not strictly required, these tools streamline development and extend functionality.

Connector Configuration via .mcp.json

If your plugin must interface with internal tools like Slack, Notion, or Snowflake, you must provide an .mcp.json file. This configuration points the plugin's named connectors to a running Model Context Protocol (MCP) server. As noted in README.md (line 63), this file maps connectors to specific endpoints and authentication tokens, enabling Claude to query external data sources.

cowork-plugin-management Plugin

For scaffolding new projects, the cowork-plugin-management plugin contains the create-cowork-plugin skill. Located at cowork-plugin-management/skills/create-cowork-plugin/SKILL.md, this helper provides step-by-step guidance for generating directory structures and boilerplate files that adhere to repository standards.

Local Testing Tools

When validating connectors against local endpoints, tools like ngrok expose your development server over HTTPS. Documentation in partner-built/zoom-plugin/skills/general/use-cases/testing-development.md outlines this workflow for validating MCP integrations before cloud deployment.

Plugin Architecture and File Structure

Knowledge-work plugins follow a strict directory convention. Below is the minimal scaffold produced by the create-cowork-plugin skill or created manually:

my-plugin/
├── .claude-plugin/
│   └── plugin.json        # Manifest describing the plugin

├── .mcp.json              # (optional) Connector configuration

├── commands/
│   └── hello.md           # Example slash command

└── skills/
    └── introduction.md    # Core skill content

The .claude-plugin/plugin.json manifest defines the plugin's metadata:

{
  "name": "my-plugin",
  "version": "0.1.0",
  "description": "A starter plugin for the Knowledge‑Work ecosystem.",
  "author": { "name": "Your Name" }
}

Skill files contain role-specific instructions in Markdown. The introduction.md file automatically activates when users engage with the domain:

# Introduction

You are an expert assistant for XYZ Corp’s **Customer‑Support** team.  
Your responsibilities include:

- Triage tickets via the `/customer-support:triage` command.  
- Draft standard replies using the `/customer-support:draft-response` command.  

Refer to the company‑specific terminology in the **Glossary** section of this file.

Explicit slash commands reside in the commands/ directory. Here is an example hello.md:

# /my-plugin:hello

**Purpose:** Verify that the plugin is installed and active.

**Behaviour:** Claude replies with a friendly greeting and a brief description of what the plugin does.

Optional tool connections require .mcp.json:

{
  "connectors": {
    "slack": {
      "url": "https://your-mcp.example.com/slack",
      "auth": "Bearer <YOUR_TOKEN>"
    }
  }
}

Development Workflow

Once prerequisites are met, follow this six-step process to develop and deploy your plugin:

1. Clone the repository using git clone https://github.com/anthropics/knowledge-work-plugins.git.

2. Select a base plugin from existing examples like finance/ or marketing/ to serve as your template.

3. Generate the scaffold using the cowork-plugin-management skill to create a new plugin directory structure.

4. Edit skill files in the skills/ directory, customizing Markdown content to reflect your organization's specific processes and terminology.

5. Configure connectors by editing .mcp.json to point to your MCP server endpoints, or omit this file for standalone plugins.

6. Commit and install by pushing changes to a branch, opening a pull request, and installing via Claude Cowork using /plugin install my-plugin@knowledge-work-plugins.

Summary

• No compilation required: Knowledge-work plugins are pure-data packages composed of Markdown, JSON, and optional YAML files.
• Minimal tooling: You need only Claude Cowork/Code access, a Git-compatible editor, and basic Markdown knowledge.
• Domain knowledge critical: Successful plugins require understanding the target role's workflows, not just technical configuration.
• Optional extensibility: Add MCP connectors via .mcp.json and use the cowork-plugin-management plugin for scaffolding.
• Simple deployment: Install finished plugins directly through Claude Cowork commands.

Frequently Asked Questions

Do I need programming experience to develop knowledge-work plugins?

No. Developing these plugins requires no source-code compilation or runtime environment. You only need to edit Markdown files for skills and JSON files for manifests. Basic Markdown proficiency—understanding headings, lists, and front-matter—is sufficient to create functional plugins that Claude can execute.

What is the purpose of the .mcp.json file?

The .mcp.json file contains optional connector definitions that map your plugin to external tools like Slack, Notion, or Snowflake. It specifies Model Context Protocol (MCP) server URLs and authentication tokens, enabling Claude to interact with your organization's internal systems. If your plugin operates without external data sources, you can omit this file entirely.

How do I create a new plugin from scratch?

Use the cowork-plugin-management plugin, which includes the create-cowork-plugin skill documented at cowork-plugin-management/skills/create-cowork-plugin/SKILL.md. This tool generates the required directory structure—including .claude-plugin/plugin.json, skills/, and commands/ directories—ensuring your scaffold adheres to the repository's architectural standards.

Can I test plugins locally before installing them in Claude Cowork?

Yes, particularly for connector development. You can use tools like ngrok to expose local MCP server endpoints over HTTPS, allowing you to validate .mcp.json configurations before deployment. The repository includes testing documentation, such as partner-built/zoom-plugin/skills/general/use-cases/testing-development.md, which outlines patterns for local validation.

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