/create-plugin

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

• **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
• **Follow best practices**: Apply patterns from plugin-dev's own implementation
• **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 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? (hooks API, MCP patterns, etc.)
• **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. For each component type needed, identify:

• How many of each type
• What each one does
• Rough triggering/usage patterns

4. Present component plan to user as table:

   | Component Type | Count | Purpose |
   |----------------|-------|---------|
   | Skills         | 2     | Hook patterns, MCP usage |
   | Commands       | 3     | Deploy, configure, validate |
   | Agents         | 1     | Autonomous validation |
   | Hooks          | 0     | Not needed |
   | MCP            | 1     | Database integration |

5. 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 section per component type)

3. **Wait for answers before proceeding to implementation**

4. If user says "whatever you think is best", provide specific recommendations and get explicit confirmation

**Example questions for a skill**:

• What specific user queries should trigger this skill?
• Should it include utility scripts? What functionality?
• How detailed should the core SKILL.md be vs references/?
• Any real-world examples to include?

**Example questions for an agent**:

• Should this agent trigger proactively after certain actions, or only when explicitly requested?
• What tools does it need (Read, Write, Bash, etc.)?
• What should the output format be?
• Any specific quality standards to enforce?

**Output**: Detailed specification for each component

---

Phase 4: Plugin Structure Creation

**Goal**: Create plugin directory structure and manifest

**Actions**: 1. Determine plugin name (kebab-case, descriptive) 2. Choose plugin location:

• Ask user: "Where should I create the plugin?"
• Offer options: current directory, ../new-plugin-name, custom path

3. Create directory structure using bash:

   mkdir -p plugin-name/.claude-plugin
   mkdir -p plugin-name/skills     # if needed
   mkdir -p plugin-name/commands   # if needed
   mkdir -p plugin-name/agents     # if needed
   mkdir -p plugin-name/hooks      # if needed

4. Create plugin.json manifest using Write tool:

   {
     "name": "plugin-name",
     "version": "0.1.0",
     "description": "[brief description]",
     "author": {
       "name": "[author from user or default]",
       "email": "[email or default]"
     }
   }

5. Create README.md template 6. Create .gitignore if needed (for .claude/*.local.md, etc.) 7. Initialize git repo if creating new directory

**Output**: Plugin directory structure created and ready for components

---

Phase 5: Component I