name: Skill Creator
slug: skill-creator
description: Create new Claude Code skills with proper structure and documentation
category: meta
complexity: complex
version: "1.0.0"
author: "ID8Labs"
triggers:
- "create a skill"
- "new skill"
- "build a skill"
- "skill creator"
- "design a skill"
tags:
- skill-development
- meta-programming
- automation

Skill Creator

The Skill Creator skill helps you design, build, and document new Claude Code skills following ID8Labs standards. It guides you through the complete skill creation process, from concept to implementation, ensuring your skills are well-structured, properly documented, and integrate seamlessly with the Claude Code ecosystem.

This skill automates the boilerplate work of skill creation while enforcing best practices around naming conventions, file structure, workflow design, and documentation. It helps you think through skill design decisions, identify the right complexity level, define clear triggers, and create comprehensive documentation that makes your skills easy to use and maintain.

Use this skill whenever you want to extend Claude Code's capabilities with new, reusable workflows that solve recurring problems or automate complex tasks.

Core Workflows

Workflow 1: Design New Skill from Concept

1. Clarify the skill purpose:
2. What problem does it solve?
3. Who will use it?
4. What are the key workflows?
5. Define skill metadata:
6. Name (clear, descriptive)
7. Slug (kebab-case)
8. Category (development, operations, meta, etc.)
9. Complexity (simple, complex, multi-agent)
10. Triggers (natural language phrases)
11. Tags (for discovery)
12. Design core workflows:
13. Identify 2-4 primary workflows
14. Map step-by-step processes
15. Define inputs and outputs
16. Identify dependencies (tools, MCPs, other skills)
17. Structure documentation:
18. Overview and use cases
19. Workflow details
20. Quick reference table
21. Best practices
22. Examples
23. Create skill file with full documentation
24. Test skill integration
25. Iterate based on usage

Workflow 2: Scaffold Skill from Template

1. Gather basic requirements:
2. Skill name and purpose
3. Category
4. Primary workflow
5. Generate SKILL.md from template:
6. Frontmatter with metadata
7. Description section
8. Core Workflows section
9. Quick Reference table
10. Best Practices list
11. Create directory structure:
12. /skills/[slug]/SKILL.md
13. Additional files if needed (examples, templates)
14. Populate with placeholder content
15. Guide user to fill in specifics

Workflow 3: Refactor Existing Workflow into Skill

1. Analyze the existing workflow:
2. What steps are repeated?
3. What knowledge is required?
4. What could be automated?
5. Extract reusable patterns
6. Generalize for broader use cases
7. Document as formal skill
8. Parameterize variable elements
9. Test with original use case and variations
10. Deploy to skills directory

Workflow 4: Skill Quality Review

1. Check metadata completeness:
2. All required frontmatter fields present
3. Triggers are natural and discoverable
4. Tags are relevant and consistent
5. Review documentation:
6. Clear description of purpose
7. Well-defined workflows
8. Actionable best practices
9. Useful examples
10. Validate structure:
11. Follows standard SKILL.md format
12. Proper markdown formatting
13. Logical organization
14. Test functionality:
15. Triggers work as expected
16. Workflows are executable
17. Dependencies are available
18. Suggest improvements
19. Approve or request revisions

Quick Reference

Best Practices

• Name Clearly: Skill names should be instantly understandable
• Good: "Database Designer", "API Tester", "Deployment Automation"

• Bad: "Helper", "Tool", "Manager"

• Choose Right Complexity:

• Simple: Single workflow, minimal dependencies, straightforward execution
• Complex: Multiple workflows, external tools, conditional logic

• Multi-agent: Coordinates other skills/agents, orchestration layer

• Define Natural Triggers: Use phrases users would actually say

• Include variations: "review code", "code review", "review this code"
• Avoid overly formal language

• Test with real users if possible

• Document Workflows Step-by-Step: Each workflow should be executable

• Number the steps
• Use action verbs
• Be specific about inputs/outputs

• Include decision points

• Provide Quick Reference: Users shouldn't need to read full docs

• Table format for common actions
• Copy-pasteable commands

• Clear, concise descriptions

• Include Examples: Show real usage

• Before/after scenarios
• Common use cases

• Edge cases if relevant

• Tag Thoughtfully: Help users discover your skill

• Use existing category tags when possible
• Add 3-5 specific tags

• Consider search terms users might use

• Version Properly: Follow semantic versioning

• Start at 1.0.0 for initial release
• Increment patch for bug fixes
• Increment minor for new workflows
• Increment major for breaking changes

Skill Metadata Reference

Required Frontmatter Fields

name: Human-Readable Name
slug: kebab-case-identifier
description: One-line description (under 100 chars)
category: development | operations | meta | design | data | testing
complexity: simple | complex | multi-agent
version: "1.0.0"
author: "ID8Labs"
triggers:
  - "natural language trigger 1"
  - "natural language trigger 2"
tags:
  - relevant-tag-1
  - relevant-tag-2

Optional Frontmatter Fields

dependencies:
  tools:
    - playwright
    - supabase
  mcps:
    - firecrawl
    - github
  skills:
    - other-skill-slug
requires_config:
  - ENV_VAR_NAME: "Description of what this is for"
examples_dir: "./examples"

Skill Categories

Common Skill Patterns

Simple Pattern: Single Action

## Core Workflows

### Workflow 1: Execute [Action]
1. Receive input
2. Process input
3. Return output

Complex Pattern: Multi-Step with Branching

## Core Workflows

### Workflow 1: [Primary Action]
1. Analyze input
2. **If** [condition]:
   - Path A
3. **Else**:
   - Path B
4. Synthesize results
5. Validate output

Multi-Agent Pattern: Orchestration

## Core Workflows

### Workflow 1: Coordinate [Task]
1. Assess requirements
2. **Delegate** to Skill A for [subtask]
3. **Delegate** to Skill B for [subtask]
4. **Monitor** progress
5. **Integrate** results
6. Validate final output

Testing Your Skill

Before considering a skill complete:

1. Test triggers: Verify phrases activate the skill
2. Execute workflows: Run through each workflow completely
3. Check dependencies: Ensure all required tools are available
4. Validate documentation: Have someone else read and use it
5. Edge cases: Test with unusual or complex inputs
6. Integration: Verify it works with related skills
7. Performance: Ensure it doesn't create bottlenecks

Skill Maintenance

Skills should evolve with usage:

• Track issues: Note when workflows fail or confuse users
• Gather feedback: Ask users what's missing or unclear
• Update docs: Keep examples and best practices current
• Deprecate carefully: If replacing, provide migration guide
• Version clearly: Document breaking changes