End-to-end plugin creation and publishing for Claude Code, Cowork, and OpenClaw. Handles the full lifecycle: design the plugin, scaffold it in the correct An...
---
name: plugin-publisher
description: >
End-to-end plugin creation and publishing for Claude Code, Cowork, and OpenClaw.
Handles the full lifecycle: design the plugin, scaffold it in the correct Anthropic
marketplace format, generate an OpenClaw install script, create or connect to a GitHub
repo, push it, and package a .plugin file for direct Cowork installation.
Use this skill whenever the user says "create a plugin", "publish a plugin",
"make a marketplace plugin", "push plugin to GitHub", "package a plugin",
"turn this into a plugin", "make this installable", "publish to marketplace",
or wants to convert existing skills/agents/workflows into a distributable plugin.
Also trigger when the user asks to "update my plugin repo", "restructure my plugin",
or "add a new plugin to my marketplace". Even if they just say "plugin" in the
context of creating or distributing something, this skill is probably what they need.
---
# Plugin Publisher
Create, package, and publish Claude plugins that work across Claude Code, Cowork desktop,
and OpenClaw — with correct Anthropic marketplace structure and GitHub integration.
## Why This Matters
Plugins that don't follow the exact Anthropic marketplace directory convention won't install
correctly in Cowork. The marketplace system expects a specific layout — this skill encodes
that layout so you never have to guess. It also generates OpenClaw compatibility automatically,
so every plugin you create works in both ecosystems.
## Quick Reference: What Goes Where
```
marketplace-repo/ ← GitHub repo (one per marketplace)
├── .claude-plugin/
│ └── marketplace.json ← Catalog listing all plugins in this marketplace
├── my-plugin/ ← Plugin dir AT REPO ROOT (not nested!)
│ ├── .claude-plugin/
│ │ └── plugin.json ← Plugin manifest
│ ├── skills/
│ │ └── skill-name/SKILL.md ← Skills (triggered automatically)
│ ├── commands/
│ │ └── command-name.md ← Slash commands (invoked explicitly)
│ ├── agents/
│ │ └── agent-name.md ← Subagent definitions
│ ├── .mcp.json ← MCP server connections (optional)
│ ├── CONNECTORS.md ← Tool-agnostic placeholders (optional)
│ └── README.md
├── another-plugin/ ← Additional plugins in same marketplace
│ └── ...
├── openclaw-install.sh ← Generated OpenClaw deployer
└── README.md ← Marketplace-level documentation
```
**Critical rule**: Each plugin directory lives at the REPO ROOT, not nested under `plugins/`.
The `marketplace.json` source path is `"./my-plugin"`, never `"./plugins/my-plugin"`.
This matches how Anthropic's own `knowledge-work-plugins` marketplace works.
Read `references/marketplace-structure.md` for the complete format specification before
creating any files.
## Workflow
### Phase 1: Understand What We're Building
Determine the scope through conversation:
1. **What does this plugin do?** — Get a clear description of the plugin's purpose.
2. **What components does it need?** — Skills, commands, agents, hooks, MCP servers?
3. **Is this a new marketplace or adding to an existing one?** — Check if the user already
has a marketplace repo on GitHub.
4. **Who's the audience?** — Internal use only, or shared publicly? This affects whether
to use `~~placeholder` connectors.
If the user already has skills, agents, or workflows in this session or in files, offer to
convert them directly rather than starting from scratch.
### Phase 2: Scaffold the Plugin
Create all files in a working directory, following this exact order:
#### 2a. Plugin manifest
Write `.claude-plugin/plugin.json`:
```json
{
"name": "plugin-name",
"version": "1.0.0",
"description": "What it does in one sentence",
"author": {
"name": "Author Name",
"url": "https://example.com"
},
"homepage": "https://github.com/owner/repo",
"license": "MIT",
"keywords": ["relevant", "keywords"]
}
```
Name rules: kebab-case, lowercase, hyphens only, no spaces.
#### 2b. Skills
Each skill is a directory with a `SKILL.md` file. Skills trigger automatically when Claude
detects a matching user request.
```yaml
---
name: skill-name
description: >
Third-person description with trigger phrases.
"When the user asks to X, Y, or Z, use this skill."
---
```
Body: imperative instructions, under 3,000 words. Use `references/` for detailed content.
#### 2c. Commands
Each command is a `.md` file with optional YAML frontmatter. Commands are invoked explicitly
by the user (e.g., `/plugin-name:command`).
```yaml
---
description: Short description (under 60 chars)
allowed-tools: Read, Write, Edit, Bash, WebSearch
argument-hint: [concept-description]
---
```
Body: directives FOR Claude to follow. Use `$ARGUMENTS` for user input.
#### 2d. Agents
Each agent is a `.md` file with YAML frontmatter. Agents are subagent definitions that run
in isolated context windows.
```yaml
---
name: agent-name
description: When to use this agent, with <example> blocks
model: sonnet
allowed-tools: Read Write WebSearch WebFetch
---
```
Body: system prompt for the subagent.
#### 2e. MCP Servers (if needed)
Write `.mcp.json` at plugin root. Use `${CLAUDE_PLUGIN_ROOT}` for local paths.
Use `${ENV_VAR}` for secrets. Document required env vars in README.
#### 2f. CONNECTORS.md (if sharing externally)
Only create this if the plugin references external tools by category (`~~chat`, `~~project tracker`).
#### 2g. README.md
Write a plugin-level README covering: overview, components, setup, usage.
### Phase 3: Create the Marketplace Wrapper
Wrap the plugin in a marketplace structure. Read `references/marketplace-structure.md` for
the exact `marketplace.json` format.
Write `.claude-plugin/marketplace.json` at the repo root:
```json
{
"name": "marketplace-name",
"owner": { "name": "Owner Name", "email": "email@example.com" },
"metadata": { "description": "What this marketplace offers", "version": "1.0.0" },
"plugins": [
{
"name": "plugin-name",
"source": "./plugin-name",
"description": "Plugin description",
"version": "1.0.0",
"author": { "name": "Author Name" },
"homepage": "https://github.com/owner/repo",
"license": "MIT",
"keywords": ["keyword1", "keyword2"],
"category": "category-name",
"tags": ["tag1", "tag2"]
}
]
}
```
Write a marketplace-level README.md covering:
- What plugins are available
- Install instructions for Cowork, Claude Code, and OpenClaw
- Repo structure diagram
- How the plugin works (architecture overview)
### Phase 4: Generate OpenClaw Compatibility
Every plugin gets an `openclaw-install.sh` at the repo root. Read
`references/openclaw-template.md` for the template and adaptation rules.
The script translates the Claude plugin structure into an OpenClaw agent workspace:
- Skills → `skills/` directory
- Agents → agent prompts inside `skills/[methodology]/agents/`
- Commands → incorporated into AGENTS.md operating instructions
- SOUL.md → personality, boundaries, tone (derived from plugin description)
- AGENTS.md → operating instructions, pipeline logic
- MEMORY.md → continuity structure
Key adaptation: OpenClaw runs everything in a single context window. Agent prompts that
assume independent subagent execution need a "mental isolation" discipline section.
### Phase 5: Push to GitHub
Check if a repo already exists or create a new one:
**If the user has `gh` CLI available (Claude Code / local terminal):**
```bash
# Create new repo
gh repo create owner/repo-name --public --description "Description" --clone
cd repo-name
# ... copy all files ...
git add -A
git commit -m "Initial release: plugin-name marketplace v1.0.0"
git push origin main
```
**If in Cowork (no git access):**
Prepare all files in the outputs directory and generate a PowerShell script the user
can run locally. The script should:
1. Clone or create the repo
2. Copy/restructure files
3. Commit with a descriptive message
4. Stop before pushing (let user review)
5. Print the `git push` command to run
Always detect the user's OS (check for Windows paths, PowerShell indicators) and generate
the appropriate script format (`.ps1` for Windows, `.sh` for Mac/Linux).
**If adding to an existing marketplace repo:**
1. Clone the existing repo
2. Add the new plugin directory at root level
3. Update `marketplace.json` to add the new plugin entry
4. Update the marketplace README
5. Commit and push
### Phase 6: Package as .plugin File
Create a `.plugin` file (a zip) for direct Cowork installation:
```bash
cd /path/to/plugin-dir
zip -r /tmp/plugin-name.plugin . -x "*.DS_Store"
cp /tmp/plugin-name.plugin /path/to/outputs/
```
Always create the zip in `/tmp/` first, then copy to outputs. The `.plugin` file renders
as an interactive card in Cowork where the user can browse files and install with one click.
### Phase 7: Present Everything
Deliver to the user:
1. The `.plugin` file for immediate Cowork installation
2. The push script (if in Cowork) or confirmation that the repo is pushed (if in Claude Code)
3. Install instructions for all three platforms:
- **Cowork**: drag the .plugin file, or `/plugin marketplace add owner/repo`
- **Claude Code**: `/plugin marketplace add owner/repo` then `/plugin install name@marketplace`
- **OpenClaw**: `git clone` + `bash openclaw-install.sh`
## Adding a Plugin to an Existing Marketplace
When the user already has a marketplace repo and wants to add a new plugin:
1. Clone the existing repo
2. Create the new plugin directory at root level
3. Add the plugin entry to the existing `marketplace.json` plugins array
4. Generate/update the OpenClaw install script to handle the new plugin
5. Update the marketplace README with the new plugin
6. Commit, push, and package
## Converting Existing Work to a Plugin
When the user says "turn this into a plugin" or has skills/agents/workflows already built:
1. Identify all components in the current session or provided files
2. Map them to plugin component types (skills → skills/, agents → agents/, etc.)
3. Ensure frontmatter follows the correct schema (read `references/marketplace-structure.md`)
4. Wrap in marketplace structure
5. Proceed with Phase 5-7
## Updating an Existing Plugin
When the user wants to update a published plugin:
1. Clone the marketplace repo
2. Make the changes to the plugin files
3. Bump the version in both `plugin.json` and `marketplace.json`
4. Commit with a descriptive message noting the changes
5. Push and re-package the .plugin file
## Validation Checklist
Before declaring done, verify:
- [ ] `plugin.json` has `name` field (kebab-case)
- [ ] `marketplace.json` has correct `source` path (`"./plugin-name"`, not nested)
- [ ] Plugin directory is at repo root, not under `plugins/`
- [ ] All skills have `name` and `description` in frontmatter
- [ ] All agents have `name`, `description`, and `model` in frontmatter
- [ ] All commands have `description` in frontmatter
- [ ] README exists at both marketplace and plugin level
- [ ] OpenClaw install script references correct paths
- [ ] `.plugin` file contains all expected files
- [ ] No hardcoded absolute paths (use `${CLAUDE_PLUGIN_ROOT}` for intra-plugin refs)
don't have the plugin yet? install it then click "run inline in claude" again.