Build a Claude Cowork Plugin: Step-by-Step Guide

Most plugin tutorials stop at "here's the manifest format." That's the easy part. The hard part is going from a vague request — "give the revenue-ops team a Claude Cowork plugin that drafts renewal summaries" — to a bundle that actually loads the right skill, calls the right connector, and hands off the heavy lifting to a sub-agent without melting the context window. This is that walkthrough. I'll build a single, realistic plugin step by step, in the order an engineer actually works, and call out the decision at each stage.

The scenario: a revenue-operations team wants Claude Cowork to pull account data, draft a renewal summary, and write a follow-up task back into the CRM. We'll build it as one plugin with one skill, one MCP connector, and one sub-agent for batch runs.

Step 1: Scope the plugin before writing anything

Start by writing, in plain English, the three or four things the plugin must do and the systems each touches. For ours: (1) fetch an account's contract and usage, (2) draft a renewal summary in our house style, (3) create a follow-up task in the CRM, (4) optionally run steps 1–3 across a list of accounts. That list directly maps to the bundle: the drafting know-how becomes a skill, the CRM access becomes a connector, and the batch case becomes a sub-agent.

Resist the urge to add a second skill "while you're here." Every extra skill is another description the router has to consider and another thing to keep current. A plugin that does one job cleanly is worth far more to a department than a sprawling one that does six jobs unpredictably.

Step 2: Lay out the bundle

Create the folder structure. At the root sits the plugin manifest; under it, a skills directory, a connectors reference, and a sub-agents directory. The manifest names the plugin, lists its components, and declares which org units may install it. Keep file names descriptive — the directory layout is documentation that the next engineer (or Claude itself) will read.

flowchart TD
  A["Scope the plugin"] --> B["Lay out bundle & manifest"]
  B --> C["Write SKILL.md with trigger"]
  C --> D["Define MCP connector tools"]
  D --> E["Add sub-agent for batch runs"]
  E --> F{"Test in sandbox?"}
  F -->|Fails| C
  F -->|Passes| G["Package & version bundle"]
  G --> H["Publish to org catalog"]

The loop back from testing to the skill body is the part beginners skip. You will almost never get the skill trigger and instructions right on the first pass; budget for two or three iterations against real requests.

Step 3: Write the skill

The skill is a folder whose entry file carries two things in its metadata: a tight name and a one-line description that doubles as the trigger. Make the description specific — "Draft renewal summaries from contract and usage data" — not vague — "Help with renewals." The router reads only that line when deciding relevance, so a fuzzy trigger means the skill loads at the wrong times or not at all.

The body of the skill is the actual instruction set: the structure of a good renewal summary, the tone, the required sections, the rule that every number must come from the connector and never be invented. Put reference material — a sample summary, a glossary of plan tiers — alongside the entry file so the model can pull it in when needed. Write the body as if onboarding a sharp new hire: assume competence, give the specifics they can't guess.

Step 4: Define the MCP connector

Now the tools. The connector is an MCP server exposing a small, named tool surface. For ours: get_account, get_usage, and create_task. Each gets a JSON schema describing inputs and outputs precisely — required fields, types, enums for things like task priority. The schema is the contract the model codes against, so invest in it; a vague schema produces malformed calls.

Critically, the connector — not the skill — holds the CRM credential and applies the role scope. create_task should reject a write if the caller's role is read-only. Build the connector so that the worst a confused model can do is call a tool it isn't allowed to and get a clean refusal, rather than corrupt a record. Return structured errors the model can read and recover from, not stack traces.

Step 5: Add the sub-agent for batch work

For the "run across a list of accounts" case, define a sub-agent with a narrow brief: take one account ID, produce one renewal summary, stop. The orchestrator will fan out one sub-agent per account, collect the compact results, and assemble them. Give the sub-agent only the skill and the read tools it needs — not the whole plugin — so each run stays focused and the parallel runs don't trip over each other.

Be deliberate here. A batch of forty accounts in parallel is fast but spends several times the tokens of a serial pass. Make batch mode an explicit user choice, not the default, and cap the fan-out so one request can't launch hundreds of sub-agents at once.

Step 6: Test, package, and publish

Test against real requests in a sandbox before anyone in revenue-ops sees it. Watch three things: does the skill load when it should and stay quiet when it shouldn't; do the tool calls validate against the schema on the first try; does the sub-agent return clean summaries without leaking intermediate chatter. Fix the skill trigger and schema until all three hold.

Then package the bundle with a version number and publish it to your org's plugin catalog with the install scope set to the revenue-ops unit. Version every change — when you tighten the skill body next month, bump the version so installs can be tracked and rolled back. A plugin without versioning is a plugin you can't safely fix.

Frequently asked questions

How small should my first plugin be?

One skill, one connector, and at most one sub-agent. A tightly scoped plugin loads predictably and is easy to debug. Add capability only after the first job is solid in real use.

What makes a good skill trigger description?

Specificity. The router decides relevance from that one line alone, so name the concrete task and its inputs — "Draft renewal summaries from contract and usage data" — rather than a broad category like "renewals help."

Why put credentials in the connector instead of the skill?

Because the connector is the security boundary. It holds the token, applies role scopes, and can refuse disallowed writes. Keeping secrets and authorization out of the prompt means a confused model can't leak or misuse them.

Should batch mode be on by default?

No. Parallel sub-agents are fast but cost several times the tokens of a serial run. Make batch an explicit choice with a capped fan-out so a single request can't spawn an unbounded swarm.

Bringing agentic AI to your phone lines

CallSphere takes this same build-once, scope-tightly discipline and applies it to voice and chat: agents that follow a clear brief, call your systems mid-call, and book work without supervision. Watch one handle a live call at callsphere.ai.

---

Source & attribution: This is an independent, original explainer inspired by Anthropic's coverage on the Claude blog. Claude, Claude Code, Claude Cowork, Claude Opus, and the Model Context Protocol are products and trademarks of Anthropic. CallSphere is not affiliated with or endorsed by Anthropic.