skill-harvester

Skill Harvester

Transform your past work into reusable Claude Code skills automatically.

Overview

The Skill Harvester is a meta-skill that helps you systematically extract reusable patterns, workflows, and expertise from your Claude Code sessions and convert them into well-structured skills that can be shared and reused.

When to Use

Use this skill when:

• Completing a significant project or work session
• Identifying repetitive patterns across multiple sessions
• Building organizational knowledge repositories
• Creating team-wide skill libraries
• Documenting complex workflows for future reuse
• Converting infrastructure/tooling expertise into skills
• After solving complex problems that could help future work

Skill Harvesting Process

1. Reflection & Analysis

Examine recent work:

# Review recent git commits
git log --oneline -20

# Analyze file changes
git diff HEAD~10..HEAD --stat

# Check which files were most modified
git log --pretty=format: --name-only | sort | uniq -c | sort -rg | head -20

Identify domains:

• What technologies were used? (frameworks, languages, tools)
• What problems were solved? (deployment, testing, optimization)
• What patterns emerged? (error handling, API integration, workflow)
• What expertise was developed? (domain knowledge, best practices)

2. Skill Identification

Questions to ask:

1. Reusability: Could this help in future projects?
2. Generalizability: Does it apply beyond this specific context?
3. Complexity: Is it non-trivial enough to warrant a skill?
4. Value: Would others benefit from this pattern?
5. Completeness: Can it be documented as a standalone skill?

Skill categories to consider:

• Infrastructure: Docker, Kubernetes, cloud platforms, CI/CD
• Backend: API design, database optimization, authentication
• Frontend: Component patterns, state management, build optimization
• DevOps: Deployment strategies, monitoring, automation
• Data Engineering: ETL pipelines, data validation, transformation
• Security: Auth patterns, encryption, vulnerability scanning
• Testing: Test strategies, mocking, coverage analysis
• Documentation: API docs, architecture diagrams, runbooks

3. Skill Template Creation

Essential components of a good skill:

---
name: skill-name (kebab-case)
description: Clear, concise 1-2 sentence description of what the skill does
license: MIT
tags: [relevant, searchable, tags]
---

# Skill Title

Brief overview paragraph explaining the skill's purpose and value.

## When to Use

- Specific scenario 1
- Specific scenario 2
- Specific scenario 3

## Core Concepts

Explain the fundamental ideas and principles.

## Workflow

Step-by-step process for using the skill.

### Step 1: [Action]
Detailed explanation with code examples.

### Step 2: [Action]
More details and examples.

## Common Patterns

### Pattern 1: [Name]
Description and example.

### Pattern 2: [Name]
Description and example.

## Best Practices

### ✅ DO
- Recommended approach 1
- Recommended approach 2

### ❌ DON'T
- Anti-pattern 1
- Anti-pattern 2

## Examples

### Example 1: [Scenario]
Full working example with explanation.

### Example 2: [Scenario]
Another complete example.

## Troubleshooting

### Issue 1: [Problem]
**Symptoms**: What you see
**Cause**: Why it happens
**Solution**: How to fix

## Reference

Quick reference table or cheat sheet.

## Additional Resources

- Links to relevant documentation
- Related skills
- External references

4. Content Extraction

Extract from various sources:

# From code files
# Look for:
# - Complex functions that solve specific problems
# - Utility scripts with general applicability
# - Configuration patterns that work well
# - Error handling strategies
# - Integration patterns

# From documentation
# Harvest:
# - README instructions
# - Setup guides
# - Troubleshooting notes
# - Architecture decisions
# - Lessons learned

# From git commits
git log --all --grep="fix\|feat\|refactor" --pretty=format:"%h %s" -20

# From issue trackers
# Extract:
# - Common problems and solutions
# - Debugging strategies
# - Workarounds and fixes

5. Skill Organization

Directory structure:

harvestable_skills/
├── automation/
│   ├── skill-name/
│   │   └── skill.md
├── backend/
├── devops/
├── frontend/
├── infrastructure/
├── testing/
└── documentation/

Categorization guidelines:

• automation: Workflow automation, scripting, batch operations
• backend: Server-side development, APIs, databases
• cloud: Cloud platforms, serverless, infrastructure
• data-engineering: Data processing, ETL, analytics
• devops: CI/CD, deployment, monitoring
• documentation: Documentation generation, diagrams
• frontend: UI development, client-side frameworks
• infrastructure: Container orchestration, VMs, networking
• security: Authentication, authorization, encryption
• testing: Test frameworks, strategies, automation
• web-development: Full-stack web development patterns

Harvesting Strategies

Strategy 1: Domain Expertise Extraction

When you've worked extensively with a specific tool or technology:

1. Document the mental model: How does it work? What are the key concepts?
2. Capture common operations: What do you do most often?
3. Record gotchas: What are the common pitfalls?
4. Create quick reference: What do you always look up?

Example domains:

• Database query optimization
• Docker multi-stage builds
• JWT authentication patterns
• GraphQL schema design
• Terraform module creation

Strategy 2: Workflow Pattern Extraction

When you've developed an effective workflow:

1. Map the steps: What's the sequence of actions?
2. Identify decision points: Where are choices made?
3. Document prerequisites: What's needed to start?
4. Capture success criteria: How do you know it worked?

Example workflows:

• Blue-green deployments
• Feature branch review process
• Database migration strategies
• API versioning approaches

Strategy 3: Problem-Solution Pattern Mining

When you've solved complex problems:

1. Describe the problem: What was broken/missing?
2. Explain the diagnosis: How did you identify it?
3. Detail the solution: What fixed it?
4. Generalize the pattern: How to prevent/solve similar issues?

Example patterns:

• Memory leak debugging
• Race condition resolution
• Performance bottleneck analysis
• Security vulnerability patching

Strategy 4: Tool Mastery Documentation

When you've become proficient with a tool:

1. Core operations: What are the essential commands?
2. Advanced features: What are the power-user tricks?
3. Integration patterns: How does it work with other tools?
4. Troubleshooting: Common errors and fixes?

Example tools:

• kubectl for Kubernetes
• AWS CLI for cloud operations
• jq for JSON processing
• git for version control

Automation Helpers

Bulk Skill Generation

#!/bin/bash
# bulk-harvest.sh - Generate multiple skills from a list

SKILLS_FILE="$1"
OUTPUT_DIR="harvestable_skills"

while IFS='|' read -r category name description; do
    # Skip header and empty lines
    [[ "$category" == "Category" ]] && continue
    [[ -z "$category" ]] && continue

    SKILL_DIR="$OUTPUT_DIR/$category/$name"
    mkdir -p "$SKILL_DIR"

    cat > "$SKILL_DIR/skill.md" << EOF
---
name: $name
description: $description
license: MIT
---

# ${name//\-/ }

$description

## When to Use

TODO: Add specific scenarios

## Implementation

TODO: Add implementation details

## Examples

TODO: Add working examples

## Best Practices

TODO: Add recommendations
EOF

    echo "✓ Created: $category/$name"
done < "$SKILLS_FILE"

Usage:

# Create skills-to-harvest.txt
cat > skills-to-harvest.txt << EOF
Category|Name|Description
devops|docker-layer-optimization|Optimize Docker image layers for faster bui