/create-plugin — 8-phase guided workflow command

A long-form slash command that walks plugin creation from concept to tested implementation. Study the anatomy: scoped allowed-tools, $ARGUMENTS seeding, per-phase goal/actions/output structure, and mandatory gates.

Parameters

Parameter	What to supply
`$ARGUMENTS`	optional plugin description typed after /create-plugin

The artifact

---
description: Guided end-to-end plugin creation workflow with component design, implementation, and validation
argument-hint: Optional plugin description
allowed-tools: ["Read", "Write", "Grep", "Glob", "Bash", "TodoWrite", "AskUserQuestion", "Skill", "Task"]
---

# Plugin Creation Workflow

Guide the user through creating a complete, high-quality Claude Code plugin from initial concept to tested implementation. Follow a systematic approach: understand requirements, design components, clarify details, implement following best practices, validate, and test.

## Core Principles

- **Reuse before generating**: Search installed plugins, first-party plugins in anthropics/claude-code, community catalogs, curated indexes, and the user's own orgs before scaffolding anything. Merge and adapt existing components; generate only the glue.
- **Ask clarifying questions**: Identify all ambiguities about plugin purpose, triggering, scope, and components. Ask specific, concrete questions rather than making assumptions. Wait for user answers before proceeding with implementation.
- **Load relevant skills**: Use the Skill tool to load plugin-dev skills when needed (plugin-structure, hook-development, agent-development, etc.)
- **Use specialized agents**: Leverage agent-creator, plugin-validator, and skill-reviewer agents for AI-assisted development
- **Progressive disclosure**: Create lean skills with references/examples
- **Use TodoWrite**: Track all progress throughout all phases

**Initial request:** $ARGUMENTS

---

## Phase 1: Discovery

**Goal**: Understand what plugin needs to be built and what problem it solves

**Actions**:
1. Create todo list with all 7 phases
2. If plugin purpose is clear from arguments:
   - Summarize understanding
   - Identify plugin type (integration, workflow, analysis, toolkit, etc.)
3. If plugin purpose is unclear, ask user:
   - What problem does this plugin solve?
   - Who will use it and when?
   - What should it do?
   - Any similar plugins to reference?
4. Summarize understanding and confirm with user before proceeding

**Output**: Clear statement of plugin purpose and target users

---

## Phase 1.5: Prior-Art Discovery (mandatory)

**Goal**: Find existing plugins, skills, and components to merge instead of generating from scratch

**Actions**:
1. Walk the discovery ladder: installed plugins and skills, first-party plugins, community catalogs and registries, curated indexes, GitHub topic search, and the user's own orgs
2. Stage every relevant hit in a working directory
3. Present the harvest to the user: candidate list, what each contributes, what remains to be generated. Let them veto or add sources
4. If fewer than five usable sources surface after walking the full ladder, declare the shortfall explicitly before generating anything

**Rules**:
- A partial match is a base to extend, not a miss
- Target five to ten merged upstream artifacts per plugin; net-new content is glue only
- Distill, do not paste: strip instance-specific content, keep portable patterns, respect licenses
- Record every merged source in the plugin's SOURCES.md

**Output**: Staged harvest directory, user-approved source list, and a declared generation scope

---

## Phase 2: Component Planning

**Goal**: Determine what plugin components are needed

**MUST load plugin-structure skill** using Skill tool before this phase.

**Actions**:
1. Load plugin-structure skill to understand component types
2. Analyze plugin requirements and determine needed components:
   - **Skills**: Does it need specialized knowledge?
   - **Commands**: User-initiated actions? (deploy, configure, analyze)
   - **Agents**: Autonomous tasks? (validation, generation, analysis)
   - **Hooks**: Event-driven automation? (validation, notifications)
   - **MCP**: External service integration? (databases, APIs)
   - **Settings**: User configuration? (.local.md files)
3. Present component plan to user as a table
4. Get user confirmation or adjustments

**Output**: Confirmed list of components to create

---

## Phase 3: Detailed Design & Clarifying Questions

**Goal**: Specify each component in detail and resolve all ambiguities

**CRITICAL**: This is one of the most important phases. DO NOT SKIP.

**Actions**:
1. For each component in the plan, identify underspecified aspects:
   - **Skills**: What triggers them? What knowledge do they provide? How detailed?
   - **Commands**: What arguments? What tools? Interactive or automated?
   - **Agents**: When to trigger (proactive/reactive)? What tools? Output format?
   - **Hooks**: Which events? Prompt or command based? Validation criteria?
   - **MCP**: What server type? Authentication? Which tools?
   - **Settings**: What fields? Required vs optional? Defaults?
2. Present all questions to user in organized sections (one per component type)
3. Wait for answers before proceeding to implementation

[... phases 4–7 continue: Structure Creation, Component Implementation,
 Validation with plugin-validator, Testing & Documentation ...]