# 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. 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)
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` |