---

name: skill-builder description: Create new Claude Code agent skills. Automatically analyzes requirements and generates complete skill with proper structure, triggers, and tools. Use when you want to "create a skill", "build a new skill", "make a skill for", or automate repetitive tasks. allowed-tools: Read, Write, Glob, Bash

Skill Builder

Autonomously create new Claude Code agent skills with intelligent analysis and generation.

When to Activate

• "create a skill for...", "build a new skill"
• "make a skill that...", "I need a skill to..."
• "generate a skill for..."

Autonomous Creation Process

Step 1: Analyze User Request

Automatically infer from the request:

1. Task Type Detection:

   • Review/Check → Code Review Skill (Read, Grep, Glob)
   • Generate/Create → Code Generator (Read, Write, Glob)
   • Analyze/Report → Analyzer (Read, Grep, Glob, Bash)
   • Refactor/Improve → Refactoring Assistant (Read, Write, Grep, Glob)
   • Test → Test Assistant (Read, Write, Bash)
   • Document → Documentation Generator (Read, Write, Glob)

2. Skill Name Derivation:

   • Extract key technology/concept from request
   • Format: [technology]-[action] (e.g., "check iOS performance" → ios-performance-check)
   • Keep lowercase with hyphens, max 64 chars

3. Trigger Keywords Extraction:

   • Parse user's language for natural phrases
   • Add common variations and synonyms
   • Include file type mentions if applicable

4. Tool Requirements:

   • Read-only tasks → Read, Grep, Glob
   • Generation tasks → Read, Write, Glob
   • Command/build tasks → Read, Write, Bash
   • Complex workflows → No restrictions

5. Output Format Selection:

   • Review/Check → Report with issues and fixes
   • Generate → File creation confirmation with examples
   • Analyze → Metrics report with visualizations
   • Refactor → Proposal with before/after
   • Test → Test results and coverage report
   • Document → Generated documentation preview

Step 2: Smart Question Strategy

Only ask if truly ambiguous:

• Multiple valid approaches? → Ask which approach
• Unclear scope? → Ask for scope clarification
• Critical choices? → Ask for user preference

Never ask if inferable:

• Skill name → Auto-generate from request
• Basic tools → Auto-select based on task type
• Common triggers → Auto-generate from context
• Output format → Auto-select based on skill type

Step 3: Auto-Generate Skill Structure

Automatically create complete skill with:

Auto-Generated Skill Name

Format: [technology]-[action] Examples:

• "check iOS naming" → ios-naming-check
• "generate React component" → react-component-generator
• "analyze dependencies" → dependency-analyzer

Auto-Generated Description

Template:

Copy[Verb] [what] [context]. [Specifics]. Use when [trigger1], [trigger2], "[quoted phrases]", or [patterns].

Auto-include:

• Specific action extracted from request
• What it checks/generates/analyzes
• Trigger phrases derived from user's language
• File types if mentioned
• Natural language variations

Auto-Selected Tools

Based on detected task type:

• Review/Check → Read, Grep, Glob
• Generate → Read, Write, Glob
• Analyze with commands → Read, Grep, Glob, Bash
• Refactor → Read, Write, Grep, Glob
• Test with execution → Read, Write, Bash

Auto-Generated Content Structure

Select appropriate template based on task type (from templates.md):

• Code Review → Template 1
• Code Generator → Template 2
• Analyzer/Reporter → Template 3
• Refactoring Assistant → Template 4
• Test Assistant → Template 5
• Documentation Generator → Template 6

Populate template with:

• Auto-generated name, description, tools
• Task-specific process steps
• Relevant output format
• Examples from similar skills (from examples.md)

Step 4: Generate and Validate

Auto-create directory structure:

Copymkdir -p .claude/skills/[auto-generated-name]

Auto-generate files:

1. SKILL.md (Required, Concise)

   • Frontmatter (name, description, allowed-tools)
   • When to Activate (trigger phrases)
   • Process steps (core workflow)
   • Output format (template structure)
   • Keep under 150 lines - core instructions only!

2. templates.md (Optional, for code/structure templates)

   • Code templates
   • File structure templates
   • Boilerplate examples
   • Use when skill generates code or files

3. examples.md (Optional, for detailed examples)

   • Real-world usage examples
   • Before/after code samples
   • Complex scenarios
   • Use when skill needs detailed guidance

4. standards.md (Optional, for rules/guidelines)

   • Coding standards
   • Naming conventions
   • Best practices
   • Reference documentation
   • Use when skill enforces specific rules

Separation principle:

• SKILL.md = Concise instructions (what to do, how to do it)
• Separate files = Supporting details (templates, examples, references)

Auto-validate:

• ✓ Valid YAML frontmatter with --- delimiters
• ✓ Name lowercase with hyphens
• ✓ Description specific with quoted triggers
• ✓ Tools appropriate for task type
• ✓ Process steps clear and actionable
• ✓ SKILL.md concise (under 150 lines)
• ✓ Extra content moved to separate files

Step 5: Present and Test

Show user:

Copy✅ Created skill: [name]

📁 Location: `.claude/skills/[name]/SKILL.md`

🎯 Try these phrases:
- "[trigger phrase 1]"
- "[trigger phrase 2]"
- "[trigger phrase 3]"

📖 Description: [generated description]

Quick Reference: Task Types

Auto-Generation Examples

Example 1: User says "create a skill to check TODO comments"

Auto-analysis:

• Task type: Review (check/find)
• Name: todo-finder
• Tools: Read, Grep, Glob
• Triggers: "find todos", "check todos", "show todos", "list fixmes"
• Output: Report organized by priority

Action: Auto-generate complete skill, create files, show confirmation

Example 2: User says "I need to generate React components"

Auto-analysis:

• Task type: Generator (create/generate)
• Name: react-component-generator
• Tools: Read, Write, Glob
• Triggers: "create component", "generate component", "new component"
• Output: Component files with tests

Action: Auto-generate complete skill, create files, show confirmation

Example 3: User says "make a skill for iOS performance issues"

Auto-analysis:

• Task type: Analyzer (check performance)
• Name: ios-performance-check
• Tools: Read, Grep, Glob, Bash
• Triggers: "check performance", "performance issues", "slow code"
• Output: Performance report with fixes

Action: Auto-generate complete skill, create files, show confirmation

Standard Workflow

When user requests a skill:

1. Analyze request → Detect task type, extract key concepts
2. Generate skill name, description, triggers automatically
3. Select appropriate template and tools
4. Create .claude/skills/[name]/SKILL.md with complete content
5. Validate frontmatter, structure, triggers
6. Present summary with test phrases

No questions asked unless truly ambiguous!

Creation Output Format

After auto-generating skill, show:

Copy✅ Skill Created: [name]

📁 Files created:
  - `.claude/skills/[name]/SKILL.md` (core instructions)
  - `.claude/skills/[name]/templates.md` (if applicable)
  - `.claude/skills/[name]/examples.md` (if applicable)
  - `.claude/skills/[name]/standards.md` (if applicable)

🔧 Type: [task-type]
🛠️  Tools: [tool-list]
📄 Lines: [line-count] (SKILL.md is concise!)

🎯 Test with these phrases:
- "[natural trigger 1]"
- "[natural trigger 2]"
- "[natural trigger 3]"

📖 Full description:
[Generated description with all triggers]

✅ Ready to use! Try one of the test phrases above.

Internal References

Use these for generation (don't show to user):

• templates.md: 6 skill templates for different task types
• examples.md: 5 complete real-world examples
• Official documentation: https://code.claude.com/docs/en/skills

Key Principles

1. Be autonomous: Infer everything possible from the user's request
2. Ask minimally: Only ask if genuinely ambiguous (approach, scope, critical choices)
3. Generate completely: Create full SKILL.md with all sections
4. Validate automatically: Check frontmatter, structure, triggers before presenting
5. Present clearly: Show what was created and how to test it

Important Rules

Auto-Generation

• Auto-generate skill name from request (lowercase-with-hyphens)
• Auto-detect task type to select template and tools
• Auto-extract trigger phrases from user's language
• Auto-create description with specific triggers in quotes
• Auto-select appropriate tools based on task type

Quality Standards

• No generic names: Always use specific technology/action names
• No vague descriptions: Always include specific triggers and file types
• Valid YAML: Always use --- delimiters and proper frontmatter format
  • allowed-tools must be comma-separated (e.g., Read, Write, Glob) not array format

File Organization

• SKILL.md must be concise: Under 150 lines, core instructions only
• Separate templates: Move code templates to templates.md
• Separate examples: Move detailed examples to examples.md
• Separate standards: Move rules/guidelines to standards.md
• Clear separation: Instructions in SKILL.md, details in other files

---

Ready for autonomous skill generation! Just tell me what skill you need.