Skill Pipeline

The process for building and maintaining elite-level skills.

Core Philosophy

1. Elite or nothing — Don't create mediocre skills
2. Standards-first — Check what exists before inventing
3. Security-focused — Every skill considers threats
4. Living documents — Skills evolve with their domains
5. Progressive disclosure — Load only what's needed

When to Use This Skill

• Creating a new skill from scratch
• Iterating on an existing skill
• Performing a refinement sweep across all skills
• Reviewing a skill for quality

---

Part 1: Creating New Skills

Phase 1: Discovery

Before writing anything:

1. What domain is this skill for?
2. Who are the authoritative sources?
3. What existing skills/standards exist?
4. What's the "elite" bar for this domain?
5. What would an expert in this field expect?

Phase 2: Research

Gather primary sources:

1. Official documentation (specs, papers, docs)
2. Security resources (audits, exploits, checklists)
3. Best practices (from recognized experts)
4. Real-world examples (production code, case studies)
5. Emerging standards (drafts, discussions)

Research checklist:

• Found official/canonical sources
• Found security-focused resources
• Found real-world examples
• Checked for existing skills in the domain
• Identified gaps in current tooling

Phase 3: Structure

Use standard skill anatomy:

skill-name/
├── SKILL.md                    # Core workflow, quick reference
├── references/
│   ├── [domain]-fundamentals.md  # Core concepts
│   ├── [domain]-index.md         # Standards/patterns index
│   ├── security/
│   │   ├── threat-models.md
│   │   └── audit-checklist.md
│   ├── checklists/
│   │   └── pre-[action].md
│   └── sources.md               # Where to watch for updates
├── scripts/                     # Automation (optional)
└── assets/                      # Templates, examples (optional)

Phase 4: Write

SKILL.md requirements:

• Clear description with trigger words
• Core workflow/process
• Quick reference for common tasks
• Links to references with "when to load"
• Security considerations

Reference file requirements:

• Actionable, not just informational
• Examples with code when relevant
• Security implications noted
• Sources cited

Phase 5: Quality Check

Run against quality bar (see references/quality-bar.md):

• Comprehensive but not bloated
• Standards-first approach documented
• Security-focused throughout
• Actionable workflows, not just reference
• Progressive disclosure (don't load everything)
• sources.md defines update triggers

Phase 6: Ship

cd ~/skills
git add skill-name/
git commit -m "feat: add skill-name skill

[Brief description of what it covers]

Sources: [list primary sources]"
git push

npx skills update  # Get it installed

---

Part 2: Refining Existing Skills

Refinement Triggers

Check sources.md for each skill to find:

1. New standards — EIPs, RFCs, specs going final
2. New threats — Exploits, vulnerabilities, attack patterns
3. Tool updates — Breaking changes, new features
4. Better patterns — Improved examples, cleaner code
5. Corrections — Errors, outdated info

Refinement Process

For each skill in ~/skills/:

1. Read references/sources.md
2. For each source:
   a. Check for updates since last-checked date
   b. If relevant update found:
      - Fetch and summarize
      - Identify target reference file
      - Integrate (don't duplicate)
      - Update last-checked date
3. Commit changes with source attribution
4. Push to GitHub

Refinement Checklist

• All sources checked
• New patterns integrated
• Outdated info removed
• Examples still work
• No duplicate information
• Last-checked dates updated
• Commit messages reference sources

---

Part 3: Bulk Refinement Sweep

When asked to "refine all skills" or "make skills more elite":

# For each skill directory
for skill in ~/skills/*/; do
  echo "=== Refining: $skill ==="
  
  # 1. Check if sources.md exists
  if [ ! -f "$skill/references/sources.md" ]; then
    echo "WARNING: No sources.md - create one first"
    continue
  fi
  
  # 2. Run refinement process
  # (This is done by the agent, not a script)
done

Sweep Process

1. List all skills in ~/skills/
2. For each skill:
   • Load its sources.md
   • Check high-priority sources first
   • Apply updates
   • Commit per-skill
3. Push all changes
4. Run npx skills update

---

Quality Bar

See references/quality-bar.md for the full checklist.

Summary — An elite skill:

Criterion	Description
Comprehensive	Covers the domain deeply, not superficially
Authoritative	Based on primary sources, not hearsay
Actionable	Provides workflows, not just information
Secure	Considers threats and mitigations
Current	Has sources.md and update process
Efficient	Progressive disclosure, not context-bloat

---

Templates

Use assets/template/ as starting point for new skills.

---

Maintenance Schedule

Frequency	Action
Per-use	Note gaps/issues while using skills
Weekly	Check high-priority sources (exploits, releases)
Monthly	Full refinement sweep
Quarterly	Review skill structure, consider splits/merges