Build Skill

# Build Claude Code Skill

Create comprehensive Claude Code Skills through elicitation-driven development

## Instructions

This command orchestrates four specialized agents to build production-ready Claude Code Skills from user requirements. Follow this structured workflow:

### Phase 1: Requirements Elicitation

**Agent**: `skill-elicitation-agent`

1. **Activate Elicitation Agent**
   - Launch the skill-elicitation-agent using the Task tool
   - Provide context: "The user wants to create a new Claude Code Skill"
   - Include any initial requirements or ideas the user has shared

2. **Elicitation Questions**
   - The agent will ask 3-5 targeted questions to understand:
     - Purpose and scope of the skill
     - Complexity and structure requirements
     - Tool permissions needed
     - Context and references
     - Success criteria

3. **Specification Creation**
   - Agent will create a comprehensive skill specification document
   - Includes: metadata, structure, instructions outline, code needs, examples, dependencies
   - Uses progressive disclosure strategy
   - Validates completeness before proceeding

4. **User Approval**
   - Present the specification to the user
   - Confirm understanding and agreement
   - Make adjustments if needed
   - Get explicit approval to proceed to generation

### Phase 2: Skill Generation

**Agent**: `skill-generator-agent`

1. **Activate Generator Agent**
   - Launch the skill-generator-agent using the Task tool
   - Pass the approved specification document
   - Specify target location (personal, project, or plugin skill)

2. **Directory Structure Creation**
   - Agent creates appropriate directory structure:
     ```
     skill-name/
     ├── SKILL.md (required)
     ├── reference.md (if needed)
     ├── examples.md (if needed)
     ├── scripts/ (if needed)
     └── templates/ (if needed)
     ```

3. **SKILL.md Generation**
   - Creates main skill file with proper frontmatter
   - Includes clear instructions and examples
   - Follows progressive disclosure principles
   - Links to supporting files

4. **Supporting Files Generation**
   - Creates reference documentation
   - Generates example files
   - Writes scripts with proper error handling
   - Creates reusable templates

5. **Dependency Documentation**
   - Documents all required packages
   - Provides installation instructions
   - Notes version requirements

6. **Quality Checks**
   - Validates YAML frontmatter
   - Checks file structure
   - Verifies code syntax
   - Tests progressive disclosure

### Phase 3: Validation and Testing

**Agent**: `skill-validator-agent`

1. **Activate Validator Agent**
   - Launch the skill-validator-agent using the Task tool
   - Provide path to generated skill
   - Request comprehensive validation

2. **YAML Validation**
   - Check frontmatter syntax
   - Verify required fields
   - Validate optional fields
   - Test YAML parsing

3. **Description Analysis**
   - Assess discoverability
   - Check trigger keywords
   - Verify clarity and completeness
   - Compare to best practices

4. **Structure Validation**
   - Verify file organization
   - Check all references
   - Test script execution
   - Validate permissions

5. **Code Testing**
   - Syntax validation
   - Security checks
   - Dependency verification
   - Error handling tests

6. **Integration Testing**
   - Test skill loading
   - Verify triggering
   - Check execution flow
   - Validate outputs

7. **Validation Report**
   - Generate comprehensive report
   - Score each category
   - List issues by severity
   - Provide actionable fixes

8. **Issue Resolution**
   - If issues found, work with generator agent to fix
   - Re-validate after fixes
   - Iterate until validation passes

### Phase 4: Documentation Enhancement

**Agent**: `skill-documenter-agent`

1. **Activate Documenter Agent**
   - Launch the skill-documenter-agent using the Task tool
   - Provide skill path and specification
   - Request comprehensive documentation

2. **SKILL.md Enhancement**
   - Refine instructions for clarity
   - Add comprehensive examples
   - Include best practices
   - Create troubleshooting section

3. **Reference Documentation**
   - Create detailed technical reference (if needed)
   - Document API and configuration
   - Provide advanced patterns
   - Include performance tuning tips

4. **Example Collection**
   - Generate beginner to advanced examples
   - Include troubleshooting examples
   - Show integration patterns
   - Provide case studies

5. **README Creation**
   - Create skill directory README (if distributing)
   - Document installation
   - Provide quick start
   - Link to full documentation

6. **Documentation Quality Check**
   - Verify clarity and completeness
   - Test all code examples
   - Check organization
   - Validate accuracy

### Phase 5: Final Delivery

1. **Generate Summary**
   - List all files created
   - Document location (personal/project/plugin)
   - Provide usage instructions
   - Include test scenarios

2. **Installation Verification**
   - Confirm skill is in correct location
   - Verify file permissions
   - Check dependencies documented
   - Test skill loading

3. **Usage Guide**
   - Explain how to trigger the skill
   - Provide example prompts
   - Show expected behavior
   - Link to documentation

4. **Next Steps**
   - Suggest testing approach
   - Recommend improvements
   - Explain maintenance
   - Note future enhancements

## Agent Coordination

### Sequential Flow

User Request ↓ skill-elicitation-agent (Requirements) ↓ User Approval ↓ skill-generator-agent (Creation) ↓ skill-validator-agent (Testing) ↓ Fixes if needed (loop back to generator) ↓ skill-documenter-agent (Enhancement) ↓ Final Delivery

### Agent Communication

**Between Agents**:
- Elicitation → Generator: Pass specification document
- Generator → Validator: Pass skill location and files
- Validator → Generator: Pass validation issues (if any)
- Generator → Document