Plugin Creation Workflow

Guide end-to-end plugin creation from initial concept through component design, implementation, validation, and testing. Follow a systematic multi-phase approach to produce high-quality Claude Code plugins.

Core Principles

• Ask clarifying questions: Identify all ambiguities about plugin purpose, triggering, scope, and components before implementing.
• Load relevant skills: Use the Skill tool to load plugin-dev skills when needed (plugin-structure, hook-development, agent-development, skill-development, mcp-integration, plugin-settings).
• Use specialized agents: Leverage agent-creator, plugin-validator, and skill-reviewer agents.
• Follow best practices: Apply patterns from plugin-dev's own implementation.
• Use TodoWrite: Track progress throughout all phases.

Phase 1: Discovery

Goal: Understand the plugin's purpose and target users.

1. Create a todo list with all phases
2. If plugin purpose is clear, summarize understanding and identify plugin type (integration, workflow, analysis, toolkit)
3. If unclear, ask:
   • What problem does this plugin solve?
   • Who will use it and when?
   • What should it do?
   • Any similar plugins to reference?
4. Confirm understanding with the user before proceeding

Phase 2: Component Planning

Goal: Determine which plugin components are needed.

Load plugin-structure skill before this phase.

Analyze requirements and determine needed components:

• Skills: Specialized knowledge? (hooks API, MCP patterns)
• 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)

Present a component plan table to the user and get confirmation.

Phase 3: Detailed Design

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

CRITICAL: Do not skip this phase.

For each component, identify underspecified aspects:

• Skills: Trigger conditions, knowledge scope, detail level
• Commands: Arguments, tools, interactive vs automated
• Agents: Trigger mode (proactive/reactive), tools, output format
• Hooks: Events, prompt vs command type, validation criteria
• MCP: Server type, authentication, tools exposed
• Settings: Fields, required vs optional, defaults

Present all questions organized by component type. Wait for answers.

Phase 4: Plugin Structure Creation

Goal: Create the directory structure and manifest.

1. Determine plugin name (kebab-case, descriptive)
2. Choose plugin location (ask the user)
3. Create directory structure:
   bashCopy

   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
5. Create README.md template
6. Initialize git repo if creating new directory

Phase 5: Component Implementation

Goal: Create each component following best practices.

Load relevant skills before implementing each component type:

• Skills: Load skill-development skill
• Commands: Load command-development skill
• Agents: Load agent-development skill
• Hooks: Load hook-development skill
• MCP: Load mcp-integration skill
• Settings: Load plugin-settings skill

Skills Implementation

• Plan resources (scripts/, references/, examples/)
• Write SKILL.md with third-person description and specific trigger phrases
• Lean body (1,500-2,000 words) in imperative form
• Create reference files for detailed content
• Validate with skill-reviewer agent

Commands Implementation

• Write markdown with frontmatter (description, argument-hint, allowed-tools)
• Instructions written FOR Claude, not TO the user
• Reference relevant skills if applicable

Agents Implementation

• Use agent-creator agent to generate: identifier, whenToUse with examples, systemPrompt
• Create agent markdown with frontmatter (name, description, model, color, tools)
• Validate with validate-agent.sh

Hooks Implementation

• Create hooks/hooks.json with hook configuration
• Prefer prompt-based hooks for complex logic
• Use ${CLAUDE_PLUGIN_ROOT} for portability
• Test with validate-hook-schema.sh and test-hook.sh

MCP Implementation

• Create .mcp.json with server configuration
• Use ${CLAUDE_PLUGIN_ROOT} in command paths
• Document required environment variables

Phase 6: Validation

Goal: Ensure the plugin meets quality standards.

1. Run plugin-validator agent (checks manifest, structure, naming, components, security)
2. Fix critical issues
3. Run skill-reviewer for each skill
4. Run validate-agent.sh on agent files
5. Run validate-hook-schema.sh on hooks configuration
6. Present findings and ask the user whether to fix now or proceed

Phase 7: Testing

Goal: Test that the plugin works correctly in Claude Code.

Provide installation instructions:

cc --plugin-dir /path/to/plugin-name

Verification checklist:

• Skills load when triggered (test with trigger phrases from descriptions)
• Commands appear in /help and execute correctly
• Agents trigger on appropriate scenarios
• Hooks activate on events
• MCP servers connect
• Settings files work

Phase 8: Documentation

Goal: Ensure complete documentation and distribution readiness.

1. Verify README completeness (overview, features, installation, usage)
2. Add marketplace entry if publishing (marketplace.json)
3. Create summary: components created, files, structure, next steps

Key Decision Points (Wait for User)

1. After Phase 1: Confirm plugin purpose
2. After Phase 2: Approve component plan
3. After Phase 3: Proceed to implementation
4. After Phase 6: Fix issues or proceed
5. After Phase 7: Continue to documentation