skill-creator

name	skill-creator
description	Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Skill Creator

Purpose

A meta-skill that guides the creation of high-quality, effective skills. Provides templates, best practices, and structural guidelines for building skills that enhance Claude's capabilities with specialized knowledge, workflows, or tool integrations.

When to Use

• User wants to create a new skill
• User wants to update or improve an existing skill
• User asks how to structure skill documentation
• Need to design a skill for a specific domain or workflow
• Want to ensure skill follows best practices

Core Skill Structure

Required Components

Every skill must have these elements:

1. Frontmatter

   ---
   name: skill-name
   description: One-line description when to use this skill
   ---
   

2. Title & Purpose

   # Skill Name
   
   ## Purpose
   Clear, concise statement of what this skill does
   

3. When to Use

   ## When to Use
   - Specific trigger 1
   - Specific trigger 2
   - Context where this helps
   

4. Core Capabilities

   ## Core Capabilities
   
   ### Domain Expertise
   - Key knowledge area 1
   - Key knowledge area 2
   
   ### Tools & Methods
   - Specific techniques
   - Frameworks used
   

Optional but Recommended Components

5. Workflow

   ## Workflow
   
   1. Step 1: What to do first
   2. Step 2: Next action
   3. Step 3: Final deliverable
   

6. Best Practices

   ## Best Practices
   
   - Do this
   - Avoid that
   - Remember this
   

7. Examples

   ## Examples
   
   ### Example 1: Common Use Case
   **Input**: User request
   **Approach**: How to handle
   **Output**: Expected result
   

8. Anti-Patterns

   ## Anti-Patterns
   
   ❌ **Don't**: Bad practice
   ✅ **Do**: Good alternative
   

Skill Creation Workflow

Step 1: Define Scope

Ask yourself:

• What problem does this skill solve?
• Who will use it?
• What triggers its use?
• What's the expected outcome?

Step 2: Identify Core Knowledge

Document:

• Domain-specific terminology
• Key concepts and principles
• Common patterns in this domain
• Tools and technologies involved

Step 3: Structure the Workflow

Map out:

• Entry conditions
• Step-by-step process
• Decision points
• Exit criteria and deliverables

Step 4: Add Practical Elements

Include:

• Real-world examples
• Common pitfalls to avoid
• Best practices from the field
• Quality criteria

Step 5: Write Clear Triggers

Make "When to Use" specific:

• ✅ "User needs SQL query optimization for PostgreSQL databases"

• ❌ "User needs database help"

• ✅ "Debugging production outages in distributed systems"

• ❌ "Fixing bugs"

Skill Quality Criteria

Clarity

• Name is self-explanatory
• Description clearly states when to use
• Purpose is stated in 1-2 sentences
• No jargon without explanation

Completeness

• All required sections present
• Workflow is actionable
• Examples cover common cases
• Edge cases addressed

Specificity

• Triggers are concrete
• Steps are detailed enough to follow
• Tools/methods are named explicitly
• Success criteria defined

Usability

• Easy to scan and navigate
• Consistent formatting
• Logical section ordering
• Cross-references where helpful

Skill Templates

Technical Domain Skill Template

---
name: domain-expert
description: Use when user needs [specific technical task] in [technology/domain]
---

# Domain Expert

## Purpose

Expert in [domain] specializing in [specific areas]. Helps with [key problems solved].

## When to Use

- User needs [specific task 1]
- Working with [technology] and needs [help type]
- Troubleshooting [specific problem type]
- Designing [architectural element]

## Core Capabilities

### [Domain] Expertise
- [Technology 1] - [version/specifics]
- [Technology 2] - [what aspects]
- [Pattern/practice] - [when/how]

### Key Techniques
- **[Technique 1]**: [What it solves]
- **[Technique 2]**: [When to use]
- **[Technique 3]**: [How it helps]

## Workflow

1. **Understand Requirements**
   - Clarify [specific aspects]
   - Identify [constraints]

2. **Apply [Domain] Patterns**
   - Use [pattern 1] for [scenario]
   - Consider [trade-off]

3. **Implement Solution**
   - Follow [best practice]
   - Ensure [quality criteria]

4. **Validate**
   - Test [aspects]
   - Verify [requirements met]

## Best Practices

- **[Practice 1]**: [Reasoning]
- **[Practice 2]**: [Benefit]
- **[Practice 3]**: [Why important]

## Common Patterns

### [Pattern 1]
**When**: [Scenario]
**How**: [Implementation approach]
**Why**: [Benefits]

### [Pattern 2]
**When**: [Scenario]
**How**: [Implementation approach]
**Why**: [Benefits]

## Anti-Patterns

❌ **Don't**: [Bad practice]
   - Why it fails: [Reason]
   - Better approach: [Alternative]

❌ **Avoid**: [Common mistake]
   - Problem: [What goes wrong]
   - Instead: [Correct way]

## Examples

### Example 1: [Common Scenario]
**Context**: [Situation]
**Approach**: [Solution steps]
**Result**: [Outcome]

## Tools & Technologies

- **[Tool 1]**: [Version] - [Use for what]
- **[Tool 2]**: [Version] - [Use for what]
- **[Framework]**: [Version] - [Key features used]

Process/Workflow Skill Template

---
name: process-specialist
description: Use when user needs [specific process/workflow] for [outcome]
---

# Process Specialist

## Purpose

Guides [specific process] to achieve [specific outcome]. Ensures [quality aspects] through [methodology].

## When to Use

- Need to [execute process]
- Want to ensure [quality outcome]
- Working on [scenario requiring this process]

## Core Process

### Phase 1: [Name]
**Goal**: [What to achieve]

Steps:
1. [Action 1]: [Details]
2. [Action 2]: [Details]
3. [Action 3]: [Details]

**Outputs**: [What you have after this phase]

### Phase 2: [Name]
**Goal**: [What to achieve]

Steps:
1. [Action 1]: [Details]
2. [Action 2]: [Details]

**Outputs**: [What you have after this phase]

### Phase 3: [Name]
**Goal**: [What to achieve]

Steps:
1. [Action 1]: [Details]
2. [Action 2]: [Details]

**Deliverable**: [Final output]

## Decision Points

### When to [Decision]
- If [condition], then [choice A]
- If [condition], then [choice B]

## Quality Gates

After each phase, verify:
- [ ] [Criterion 1]
- [ ] [Criterion 2]
- [ ] [Criterion 3]

## Best Practices

- **[Practice]**: [Why it matters]
- **[Practice]**: [Impact on quality]

## Common Pitfalls

- **Pitfall**: [What people do wrong]
  - **Impact**: [What happens]
  - **Solution**: [How to avoid]

Writing Tips

Be Specific

❌ "Use when working with databases" ✅ "Use when optimizing SQL queries for PostgreSQL 14+ production databases"

Be Actionable

❌ "Think about security" ✅ "Run OWASP ZAP scan and review all HIGH severity findings"

Be Structured

Use consistent heading levels:

• ## for major sections
• ### for subsections
• #### for detailed breakdowns

Use Visual Indicators

• ✅ for good practices
• ❌ for anti-patterns
• 🔍 for investigation steps
• ⚠️ for warnings
• 💡 for tips

Include Context

Don't just list what to do—explain why:

## Instead of:
- Use connection pooling

## Write:
- **Use connection pooling** (pg-pool for PostgreSQL)
  - Reduces connection overhead by 80%
  - Critical for applications with >100 concurrent users
  - Configure pool size = (core count × 2) + effective_spindle_count

Skill Maintenance

When to Update

• New version of core technology released
• Better practices emerge in the field
• User feedback reveals gaps
• Related skills are created (cross-reference)

Version Control

Consider adding to frontmatter:

---
name: skill-name
description: One-line description
---

Skill Integration

Cross-References

Link to related skills:

## Related Skills
- Use [[debugger-skill]] when issues arise
- Combine with [[performance-engineer-skill]] for optimization
- Precede with [[architect-reviewer-skill]] for design validation

Skill Composition

Complex workflows can chain skills:

## Workflow
1. Use [[requirement-analyst]] to gather needs
2. Apply this skill for implementation
3. Use [[code-reviewer]] for quality assurance
4. Use [[deployment-engineer]] to ship

Examples

Example 1: Creating a Python Pro Skill

Context: Need a skill for advanced Python development

Process:

1. Define scope: Python 3.11+ with focus on FastAPI and type safety
2. Identify triggers: "modern Python", "type hints", "FastAPI"
3. Structure core capabilities:
   • Python 3.11+ features (match statements, typing improvements)
   • FastAPI framework patterns
   • Type annotation best practices
4. Add workflow: Design API → Type models → Implement routes → Test
5. Include examples: FastAPI route with full type annotations

Result: A focused, actionable skill for modern Python development

Example 2: Creating a Git Workflow Skill

Context: Need to codify team's git branching strategy

Process:

1. Define scope: Git workflow for feature development
2. Identify triggers: "create branch", "make PR", "git workflow"
3. Structure as phases:
   • Branch creation
   • Development cycle
   • PR process
   • Merge strategy
4. Add decision points: When to rebase vs merge
5. Include examples: Standard feature development flow

Result: Clear procedural guide for consistent git usage

Validation Checklist

Before finalizing a skill, check:

Structure

• Frontmatter complete (name, description)
• Title and purpose clear
• "When to Use" section has specific triggers
• Core capabilities well-defined

Content

• Information is accurate and current
• Examples are realistic and helpful
• Best practices are justified
• Anti-patterns show alternatives

Usability

• Can scan and find info quickly
• Sections flow logically
• Formatting is consistent
• Cross-references are correct

Quality

• No spelling/grammar errors
• Technical terms defined
• Code examples (if any) are correct
• Meets all quality criteria above

Meta: About This Skill

This skill itself demonstrates the principles it teaches:

• Clear frontmatter and structure
• Specific "When to Use" triggers
• Actionable workflows
• Concrete examples
• Quality criteria

When creating skills, use this as both a guide and a template.