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
own-the-task	Delegation ownership — Intake → Brief → Plan → Execute	A task is handed over open-ended; "take this off my plate"; before a plan exists
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. Wire every skill into each harness with the install.sh script (idempotent, per-skill symlinks) — either the one-shot curl -fsSL https://git.d-ma.be/mathias/skills/raw/branch/main/install.sh | bash, or, from a clone, SKILLS_CHECKOUT_DIR="$PWD" bash install.sh. (The task install targets are currently broken — see issue — use install.sh.)

• 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)
own-the-task ──→ grill-me (intent first, then stress-test the plan)
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)
"Take this off my plate / own this / act as my AI employee"	own-the-task
"What are the risks?" / "compliance gate" / "risk register"	regulatory-risk-assessment
"Start of session" / "load TELOS" / "what are we optimizing toward?"	telos-load