skills/SKILLS_INDEX.md

Engineering Skills Index

This index lists all available engineering skills. Load the full SKILL.md on demand.

Skill	Description	Use when
tdd	Test-Driven Development enforcement	Starting any new feature or fixing a bug
clean-code	Clean code principles with Go adaptation	Code review, refactoring, new code
solid	SOLID principles with Go examples	Design review, architecture decisions
code-review	Code smell detection + Go-specific checklist	Pre-merge review
refactoring	Systematic refactoring methodology (Fowler)	When improving existing code
test-design	Dave Farley test design scoring (Farley Index)	Reviewing or writing tests
cognitive-load	Cognitive complexity analysis (CLI score)	Identifying hotspots, before refactoring
problem-analysis	Deep problem understanding before coding	Starting any non-trivial task
user-stories	Elephant Carpaccio story slicing	Breaking down features
atdd	Acceptance Test-Driven Development workflow	Feature development with acceptance criteria
spec-driven-dev	Spec-driven development for PMs	Writing specs and requirements
planning	Planning and task breakdown	Sprint planning, task decomposition
gitea-ci	Gitea CI/CD pipeline with act_runner, buildah, k3s, GitHub mirror	Setting up or debugging CI on this infra
debug	Hypothesis-first debugging discipline	Any test failure or bug whose cause is not immediately obvious
feature-spec	Implementation-level feature spec (tighter than spec-driven-dev)	Scoping one feature inside an already-specced project
playwright	Playwright E2E testing — setup, HTMX patterns, SSE streams, CI wiring	Adding browser tests to any project with a web UI
session-retrospective	Surface non-obvious learnings from a session log	After a coding session ends, before context is lost
trainer	Two-phase brain curation (score candidates, write past quality gate)	Periodic brain pruning and curation
grill-me	Structured plan interrogation — Quick Poke, Full Grill, Pre-mortem	Stress-testing a plan before committing; end of Diamond 1; before promoting to pre-prod
telos-load	Load TELOS intention substrate at session start	Starting any koala session; before architectural decisions; CAD pipeline entry
regulatory-risk-assessment	Structured risk register for regulated-industry features	Filing a CAD issue (needs Risk: level); features touching payments, auth, external APIs, user data
discovery-framing	Problem-before-solution discovery/framing method	Framing/validating a problem before any solution; opportunity sizing
stage-gate-review	Stage-gate product governance (go/no-go council)	Preparing a Product Council ask; building a go/no-go checklist; gate review
web-shot	Screenshot a running web UI via a koala k3s Playwright job	Visual verification of a running UI when no local browser exists
superpowers-brainstorming	Structured divergent brainstorming	Generating or expanding a set of ideas
superpowers-writing-plans	Writing implementation plans	Planning substantial work before coding
superpowers-executing-plans	Executing a written plan step by step	Running an approved plan to completion
superpowers-dispatching-parallel-agents	Fan work out across parallel subagents	Decomposing work for concurrent agents
superpowers-subagent-driven-development	Subagent-driven development workflow	Building via orchestrated subagents
superpowers-systematic-debugging	Hypothesis-first systematic debugging	Diagnosing a failure methodically
superpowers-test-driven-development	TDD discipline (superpowers variant)	Red → green → refactor on a change
superpowers-verification-before-completion	Verify behavior before claiming done	Before marking any task complete
superpowers-requesting-code-review	Requesting a code review well	Asking another agent/human to review
superpowers-receiving-code-review	Acting on received review feedback	Responding to review comments
superpowers-finishing-a-development-branch	Cleanly finishing/landing a dev branch	Wrapping a branch → merge/PR
superpowers-using-git-worktrees	Isolating work with git worktrees	Parallel/isolated work in a worktree
superpowers-writing-skills	Authoring new SKILL.md skills	Creating a new reusable skill
superpowers-using-superpowers	Meta: orienting in the superpowers set	Learning how to use the superpowers skills

Wiring into tools

This repo is the canonical home. Clone it (e.g. to ~/dev/skills) and run task install — or the one-shot curl -fsSL .../install.sh | bash — to wire every skill into each harness. Per-skill symlinks, idempotent:

• Claude Code (global) — ~/.claude/skills/<name> → <repo>/<name>.
• Claude Code (per-repo) — <repo>/.claude/skills/<name> when task install is run inside another git repo (excluded via ~/.config/git/ignore).
• Crush — ~/.config/crush/skills/<name>.
• Antigravity — ~/.gemini/antigravity/skills/<name>.
• Mistral Vibe — ~/.vibe/skills/<name>.md → <repo>/<name>/SKILL.md (flat .md layout).

Individual targets are also runnable: task install:claude:global, install:crush, install:antigravity, install:vibe. task update pulls the canonical checkout then re-wires.

Skill Relationships

problem-analysis
    │
    └── user-stories
            │
            ├── spec-driven-dev (PM-kickoff lifecycle)
            │       │
            │       └── feature-spec (per-feature, mid-implementation)
            │               │
            │               └── planning
            │                       │
            │                       └── atdd ──→ tdd (foundation)
            │                                ├──→ debug (when tests fail)
            │                                ├──→ clean-code (REFACTOR phase)
            │                                └──→ test-design (review)
            │
            └── planning

code-review ──→ refactoring ──→ clean-code
                                    └──→ solid

(post-session)
session-retrospective ──→ trainer ──→ brain (via brain_write)

(planning & convergence)
grill-me ──→ planning (after plan is sharpened)
         ──→ spec-driven-dev (after hypothesis is validated)

Quick Triggers

Situation	Load
"Build this feature"	problem-analysis → spec-driven-dev → planning → atdd
"Fix this bug"	tdd
"Review this code"	code-review
"Refactor this"	refactoring + clean-code
"Design this system"	solid + problem-analysis
"Break this down into stories"	user-stories
"Write a spec"	spec-driven-dev
"This code is hard to understand"	cognitive-load
"Review these tests"	test-design
"Set up CI for this project"	gitea-ci
"CI pipeline is failing / not triggering"	gitea-ci
"Commit directly to main? Or branch?"	TBD: commit to main unless parallel agents are active (see gitea-ci SKILL §Trunk-Based Development)
"Grill me / stress-test this / is this ready?"	grill-me
"End of Diamond 1 — should we build this?"	grill-me (Full Grill)
"About to promote to pre-prod"	grill-me (Pre-mortem)
"What are the risks?" / "compliance gate" / "risk register"	regulatory-risk-assessment
"Start of session" / "load TELOS" / "what are we optimizing toward?"	telos-load