jmsktm/Skill Creator

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:
   • What problem does it solve?
   • Who will use it?
   • What are the key workflows?
2. Define skill metadata:
   • Name (clear, descriptive)
   • Slug (kebab-case)
   • Category (development, operations, meta, etc.)
   • Complexity (simple, complex, multi-agent)
   • Triggers (natural language phrases)
   • Tags (for discovery)
3. Design core workflows:
   • Identify 2-4 primary workflows
   • Map step-by-step processes
   • Define inputs and outputs
   • Identify dependencies (tools, MCPs, other skills)
4. Structure documentation:
   • Overview and use cases
   • Workflow details
   • Quick reference table
   • Best practices
   • Examples
5. Create skill file with full documentation
6. Test skill integration
7. Iterate based on usage

Workflow 2: Scaffold Skill from Template

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

Workflow 3: Refactor Existing Workflow into Skill

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

Workflow 4: Skill Quality Review

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

Quick Reference

| Action | Command/Trigger | |--------|-----------------| | Create new skill | "Create a skill for [purpose]" | | Scaffold from template | "Scaffold a skill called [name]" | | Review existing skill | "Review this skill: [path or content]" | | Convert workflow to skill | "Turn this workflow into a skill: [workflow]" | | Generate skill metadata | "Generate metadata for [skill concept]" | | Design skill workflows | "Design workflows for [skill purpose]" | | Validate skill structure | "Validate this skill file: [path]" |

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

| Category | Purpose | Examples | |----------|---------|----------| | development | Building and coding | Code review, scaffolding, refactoring | | operations | Deployment and infrastructure | CI/CD, monitoring, deployment | | meta | Skills about AI/skills | Prompt engineering, workflow design | | design | UI/UX and creative work | Component design, design systems | | data | Database and data workflows | Schema design, migrations, queries | | testing | Quality assurance | Test generation, E2E testing | | content | Writing and documentation | Technical writing, marketing copy |

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