Skill Lifecycle Manager Skill

Skill Lifecycle Manager

Overview

Meta-skill for managing the complete lifecycle of Claude Code skills - from creation to deployment.

When to use:

Creating a new skill from user workflow
Iterating on existing skill based on usage
Testing skill discovery and loading
Managing git repo and symlinks
Validating skill infrastructure

Announce: "I'm using the skill-lifecycle-manager to manage skill operations"

Process

Phase 1: Skill Creation

# Check if we're in git repo or ~/.claude
if [[ -d ~/Code/claude-skills ]]; then
    cd ~/Code/claude-skills
elif [[ -d ~/.claude/skills ]]; then
    cd ~/.claude/skills
else
    echo "Creating skills repository"
    mkdir -p ~/Code/claude-skills
    cd ~/Code/claude-skills
    git init
fi

Phase 2: Capture Current Workflow

When user completes a task that should become a skill:

Extract pattern from conversation

# Review current session for reusable patterns
grep -E "(I'm using|Let me|I'll)" ~/.claude/session-env/*/messages.jsonl | tail -20

Generate skill from workflow

./skills-toolkit/generate-skill.sh "$SKILL_NAME" bundled

Populate with captured process
- Copy successful commands to scripts/
- Extract templates used to templates/
- Document decision points in SKILL.md

Phase 3: Test Skill Loading

Verify Discovery:

# Test 1: Check if skill is discoverable
ls -la ~/.claude/skills/ | grep "$SKILL_NAME"

# Test 2: Verify symlink if using git repo
readlink ~/.claude/skills/"$SKILL_NAME"

# Test 3: Check frontmatter validity
head -10 "$SKILL_NAME/SKILL.md" | grep -E "^(name|description):"

Test Progressive Disclosure:

# Simulate Claude's loading pattern
import yaml
import os

def test_skill_loading(skill_path):
    # Phase 1: Metadata only (~100 tokens)
    with open(f"{skill_path}/SKILL.md", 'r') as f:
        content = f.read()
        frontmatter = content.split('---')[1]
        metadata = yaml.safe_load(frontmatter)
        print(f"Metadata tokens: ~{len(metadata['description'].split())}")

    # Phase 2: Full instructions (<5k tokens)
    instructions = content.split('---')[2]
    print(f"Instruction tokens: ~{len(instructions.split())}")

    # Phase 3: Resources (as needed)
    for subdir in ['scripts', 'templates', 'reference']:
        path = f"{skill_path}/{subdir}"
        if os.path.exists(path):
            size = sum(os.path.getsize(f"{path}/{f}") for f in os.listdir(path))
            print(f"{subdir}/ size: {size} bytes")

Phase 4: Iteration Workflow

Capture improvements during usage:

Monitor skill effectiveness

# Track when skill is invoked
grep "using the $SKILL_NAME skill" ~/.claude/debug/latest | wc -l

Update based on failures
- Add error handling for edge cases
- Expand validation checklist
- Improve trigger descriptions

Version and commit

# Update version in frontmatter
sed -i '' "s/version: .*/version: $NEW_VERSION/" SKILL.md

# Update CHANGELOG
echo "## [$NEW_VERSION] - $(date +%Y-%m-%d)" >> CHANGELOG.md
echo "- $CHANGE_DESCRIPTION" >> CHANGELOG.md

# Commit improvements
git add -A
git commit -m "feat($SKILL_NAME): $IMPROVEMENT"

Phase 5: Infrastructure Validation

Complete health check:

#!/bin/bash
# skill-health-check.sh

echo "=== Skill Infrastructure Health Check ==="

# 1. Check repositories
echo -n "Git repo exists: "
[[ -d ~/Code/claude-skills/.git ]] && echo "✓" || echo "✗"

# 2. Check symlinks
echo -n "Symlinks valid: "
for link in ~/.claude/skills/*; do
    [[ -L "$link" ]] && [[ -e "$link" ]] || echo "✗ $link broken"
done
echo "✓"

# 3. Check frontmatter
echo -n "Frontmatter valid: "
for skill in ~/Code/claude-skills/*/SKILL.md; do
    grep -q "^name:" "$skill" || echo "✗ $skill missing name"
    grep -q "^description:" "$skill" || echo "✗ $skill missing description"
done
echo "✓"

# 4. Test discovery
echo -n "Skills discoverable: "
ls ~/.claude/skills/ | wc -l
echo " skills found"

# 5. Check for conflicts
echo -n "No naming conflicts: "
ls ~/.claude/skills/ | sort | uniq -d | wc -l | grep -q "0" && echo "✓" || echo "✗"

Validation Checklist

[ ] Skill has valid frontmatter (name, description)
[ ] Description includes trigger keywords
[ ] Symlink points to git repo (if applicable)
[ ] Git repo has clean history
[ ] CHANGELOG tracks iterations
[ ] Resources in correct directories
[ ] No naming conflicts
[ ] Progressive disclosure works
[ ] Auto-discovery successful

Meta Patterns

Pattern 1: Workflow to Skill

User completes task → Capture process → Generate skill → Test → Deploy

Pattern 2: Skill Evolution

Usage → Identify improvement → Update skill → Version → Test → Commit

Pattern 3: Infrastructure Maintenance

Health check → Fix issues → Validate → Document → Share

Integration Points

Works with:

skills-toolkit/generate-skill.sh - For scaffolding
Git workflows - For versioning
Claude's skill discovery - For validation
Session history - For pattern extraction

Common Issues

Symlink broken after git pull:

# Re-establish symlinks
for skill in ~/Code/claude-skills/*/; do
    name=$(basename "$skill")
    ln -sf "$skill" ~/.claude/skills/"$name"
done

Skill not discovered:

Check frontmatter format
Verify description has keywords
Ensure SKILL.md exists
Check file permissions

Progressive disclosure not working:

Keep SKILL.md under 5k tokens
Move large content to resources/
Use references instead of inline code

Agent Skills: Skill Lifecycle Manager

Install this agent skill to your local

Skill Files