/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**: Specialized knowledge OR user-initiated actions (deploy, configure, analyze). Skills are the preferred format for both — see note below.
• **Agents**: Autonomous tasks? (validation, generation, analysis)
• **Hooks**: Event-driven automation? (validation, notifications)
• **MCP**: External service integration? (databases, APIs)
• **Settings**: User configuration? (.local.md files)

> **Note:** The `commands/` directory is a legacy format. For new plugins, user-invoked slash commands should be created as skills in `skills/<name>/SKILL.md`. Both are loaded identically — the only difference is file layout. `commands/` remains an acceptable legacy alternative.

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         | 5     | Hook patterns, MCP usage, 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? For user-invoked skills: 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/<skill-name>   # one dir per skill, each with a SKILL.md
   mkdir -p plugin-name/agents                # if needed
   mkdir -p plugin-name/hooks                 # if needed
   # Note: plugin-name/commands/ is a legacy alternative to skills/ — prefer skills/

4. Create plugin.json manifest using Write tool:

   {
     "name": "plugin-name",
     "version": "0.1.0",