create-plugin

name	Create Plugin
description	Copilot CLI plugin scaffolding and creation workflow. Covers requirements gathering, component planning, directory structure, implementation, validation, and testing. Use for new plugin projects or guided plugin development.
version	0.1.0

Plugin Creation Workflow

Create a complete, high-quality Copilot CLI 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 sql: Track all progress throughout all phases

---

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 context:
   • 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.)
   • Skills: 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 |
   | Skills         | 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?
   • Skills (actions): What tools needed? Interactive or automated?
   • Agents: When to trigger (proactive/reactive)? What tools? Output format?
   • Hooks: Which events? 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, edit, execute, 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

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:

   plugin-name/
   ├── skills/          # if needed
   ├── agents/          # if needed
   ├── hooks/           # if needed
   ├── extensions/      # if needed
   └── README.md
   

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

Output: Plugin directory structure created and ready for components

---

Phase 5: Component Implementation

Goal: Create each component following best practices

LOAD RELEVANT SKILLS before implementing each component type:

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

Actions for each component:

For Skills:

1. Load skill-development skill using skill tool
2. For each skill:
   • Ask user for concrete usage examples (or use from Phase 3)
   • Plan resources (scripts/, references/, examples/)
   • Create skill directory structure
   • Write SKILL.md with:
     • Third-person description with specific trigger phrases
     • Lean body (1,500-2,000 words) in imperative form
     • References to supporting files
   • Create reference files for detailed content
   • Create example files for working code
   • Create utility scripts if needed
3. Use skill-reviewer agent to validate each skill

For Agents:

1. Load agent-development skill using skill tool
2. For each agent, use agent-creator agent:
   • Provide description of what agent should do
   • Agent-creator generates: identifier, whenToUse, systemPrompt
   • Create agent .agent.md file with frontmatter and system prompt
   • Add appropriate model and tools
   • Validate with validate-agent.sh script

Agent frontmatter format:

---

description: What this agent does
tools: [read, edit, execute, grep, glob]
---

For Hooks:

1. Load hook-development skill using skill tool
2. For each hook:
   • Create hooks/hooks.json (version 1 format) with hook configuration
   • Only command type hooks are supported (no prompt type)
   • Use relative path references for portability
   • Create hook scripts if needed (in examples/ not scripts/)
   • Test with validate-hook-schema.sh and test-hook.sh utilities

Hook events: preToolUse, postToolUse, agentStop, subagentStop, sessionStart, sessionEnd, userPromptSubmitted

For MCP:

1. Load mcp-integration skill using skill tool
2. Create .mcp.json configuration with:
   • Server type (stdio for local, SSE for hosted)
   • Command and args (with relative path references)
   • extensionToLanguage mapping if LSP
   • Environment variables as needed
3. Document required env vars in README
4. Provide setup instructions

For Settings:

1. Load plugin-settings skill using skill tool
2. Create settings template in README
3. Create example .github/plugin-name.local.md file (as documentation)
4. Implement settings reading in hooks/skills as needed
5. Add to .gitignore: .github/*.local.md

Progress tracking: Update todos as each component is completed

Output: All plugin components implemented

---

Phase 6: Validation & Quality Check

Goal: Ensure plugin meets quality standards and works correctly

Actions:

1. Run plugin-validator agent:

   • Use plugin-validator agent to comprehensively validate plugin
   • Check: structure, naming, components, security
   • Review validation report

2. Fix critical issues:

   • Address any critical errors from validation
   • Fix any warnings that indicate real problems

3. Review with skill-reviewer (if plugin has skills):

   • For each skill, use skill-reviewer agent
   • Check description quality, progressive disclosure, writing style
   • Apply recommendations

4. Test agent triggering (if plugin has agents):

   • For each agent, verify triggering conditions are specific
   • Run validate-agent.sh on agent files

5. Test hook configuration (if plugin has hooks):

   • Run validate-hook-schema.sh on hooks/hooks.json
   • Test hook scripts with test-hook.sh
   • Verify relative path references

6. Present findings:

   • Summary of validation results
   • Any remaining issues
   • Overall quality assessment

7. Ask user: "Validation complete. Issues found: [count critical], [count warnings]. Would you like me to fix them now, or proceed to testing?"

Output: Plugin validated and ready for testing

---

Phase 7: Testing & Verification

Goal: Test that plugin works correctly in Copilot CLI

Actions:

1. Installation instructions:

   • Show user how to test locally:

     /plugin install /path/to/plugin-name
     

2. Verification checklist for user to perform:

   • Skills load when triggered (ask questions with trigger phrases)
   • Skills execute correctly when invoked
   • Agents trigger on appropriate scenarios
   • Hooks activate on events (if applicable)
   • MCP servers connect (if applicable)
   • Settings files work (if applicable)

3. Testing recommendations:

   • For skills: Ask questions using trigger phrases from descriptions
   • For skills (actions): Invoke with various inputs
   • For agents: Create scenarios matching agent descriptions
   • For hooks: Use copilot --debug to see hook execution
   • For MCP: Verify servers and tools are accessible

4. Ask user: "I've prepared the plugin for testing. Would you like me to guide you through testing each component, or do you want to test it yourself?"

5. If user wants guidance, walk through testing each component with specific test cases

Output: Plugin tested and verified working

---

Phase 8: Documentation & Next Steps

Goal: Ensure plugin is well-documented and ready for distribution

Actions:

1. Verify README completeness:

   • Check README has: overview, features, installation, prerequisites, usage
   • For MCP plugins: Document required environment variables
   • For hook plugins: Explain hook activation
   • For settings: Provide configuration templates

2. Add marketplace entry (if publishing):

   • Show user how to add to marketplace.json
   • Help draft marketplace description
   • Suggest category and tags

3. Create summary:

   • Mark all todos complete
   • List what was created:
     • Plugin name and purpose
     • Components created (X skills, Y agents, etc.)
     • Key files and their purposes
     • Total file count and structure
   • Next steps:
     • Testing recommendations
     • Publishing to marketplace (if desired)
     • Iteration based on usage

4. Suggest improvements (optional):

   • Additional components that could enhance plugin
   • Integration opportunities
   • Testing strategies

Output: Complete, documented plugin ready for use or publication

---

Important Notes

Throughout All Phases

• Use sql to track progress at every phase
• Load skills with skill tool when working on specific component types
• Use specialized agents (agent-creator, plugin-validator, skill-reviewer)
• Ask for user confirmation at key decision points
• Follow plugin-dev's own patterns as reference examples
• Apply best practices:
  • Third-person descriptions for skills
  • Imperative form in skill bodies
  • Strong trigger phrases
  • Relative path references for portability
  • Progressive disclosure
  • Security-first (HTTPS, no hardcoded credentials)

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

Skills to Load by Phase

• Phase 2: plugin-structure
• Phase 5: skill-development, agent-development, hook-development, mcp-integration, plugin-settings (as needed)
• Phase 6: (agents will use skills automatically)

Quality Standards

Every component must meet these standards:

• ✅ Follows plugin-dev's proven patterns
• ✅ Uses correct naming conventions
• ✅ Has strong trigger conditions (skills/agents)
• ✅ Includes working examples
• ✅ Properly documented
• ✅ Validated with utilities
• ✅ Tested in Copilot CLI

---

Example Workflow

User Request

"Create a plugin for managing database migrations"

Phase 1: Discovery

• Understand: Migration management, database schema versioning
• Confirm: User wants to create, run, rollback migrations

Phase 2: Component Planning

• Skills: 1 (migration best practices)
• Skills (actions): 3 (create-migration, run-migrations, rollback)
• Agents: 1 (migration-validator)
• MCP: 1 (database connection)

Phase 3: Clarifying Questions

• Which databases? (PostgreSQL, MySQL, etc.)
• Migration file format? (SQL, code-based?)
• Should agent validate before applying?
• What MCP tools needed? (query, execute, schema)

Phase 4-8: Implementation, Validation, Testing, Documentation

---

Begin with Phase 1: Discovery