Catalog
Every skill in the repository and what it is for.
Every skill in skills/, grouped by what it is for. Each name is the slash command and links to its SKILL.md. The descriptions are the skills' own frontmatter: each one is a summary for the person typing its name, except unslop and linear, which the agent fires on its own, so theirs are written for an agent to route on.
The Loop
| skill | what it does |
|---|---|
/plans | Durable backlog on disk. Bare /plans prints the ready frontier, /plans new surveys and writes a batch, /plans do starts one on a branch, /plans wave runs the close sweep then starts every ready one in its own thread, /plans close archives it, or with no id closes each merged one whose thread has finished. Project detected from the working directory. Publishing follows the delivery mode. |
/playbook | Route a task to the right engineering playbook. Applies the principles index. |
/figure-it-out | Design an auditable playbook when no narrower one fits, scaling rigor to the task, running a hypothesis loop, and logging decisions via show-me-your-work. |
/blast-radius | Find what a change could break outside the diff before it ships, and prove the one fact it is safe because of by running real code. |
/tdd | Fix a bug by writing a regression test that fails first, when a cheap local test path exists. |
/show-me-your-work | Keep a reviewable decision trail for unattended work: a TSV log, one row per decision (project, plan, branch, evidence, result), local and uncommitted. |
Panels
| skill | what it does |
|---|---|
/architect | Sketch types, signatures, and module structure before code, then stay in the loop while implementation fills in. |
/how | Explain how a subsystem works, its architecture, runtime flow, and where new code belongs, without changing anything. |
/interrogate | Have reviewers on different models challenge a change from independent angles and synthesize their findings into one verdict. |
Writing
| skill | what it does |
|---|---|
/technical-writing | Write or review docs, RFCs, readmes, and PR descriptions against a layered standard: Diátaxis structure, Google developer style sentences, STE instruction rules, and Global English syntax. |
/unslop | Cut AI tells from any writing. Must always apply. |
/no-comments | Spawn comment-sicko, fix accepted findings, and offer encodings for claimed constraints. |
Review Extensions
| skill | what it does |
|---|---|
/coderabbit | Decide whether CodeRabbit reviewed a PR head, has findings, or is paused or rate limited. GitHub only. Needs prs mode. |
/greptile | Decide, inside a prs mode fix round, whether a PR's Greptile confidence score ends the loop, hands it back, or earns a paid re-review, and reply to and resolve the reviewer threads Greptile started that the round settled. GitHub only. Needs prs mode. |
/macroscope | Decide whether Macroscope reviewed a PR head, has findings at or above the severity floor, or needs a re-review. GitHub only. Needs prs mode. |
Tracker Extensions
| skill | what it does |
|---|---|
/linear | Branch a task after the Linear issue it came from, then link its PR to that issue and move the issue to code review through the Linear MCP. Use when the request names a Linear issue by URL or identifier. Needs prs mode. |
Sync Extensions
| skill | what it does |
|---|---|
/hub | Share one plans history across your machines through a self hosted hub that stores only ciphertext. Install it with ./install.sh --with hub, which writes HUB_URL and HUB_NETWORK and walks you through joining or starting a hub. |
Principles
| skill | what it does |
|---|---|
/principle-boundary-discipline | Apply when wiring validation, error handling, or framework adapters. Concentrate guards at system boundaries (CLI, config, network, external APIs); trust internal types and keep business logic in pure functions. |
/principle-build-the-lever | Apply to any non-trivial work, not just bulk work: edits, migrations, analyses, checks. Build the tool that does it or proves it (codemod, script, generator, or a skill your subagents follow) instead of working by hand. The tool is the artifact a reviewer can rerun. |
/principle-encode-lessons-in-structure | Apply when you catch yourself writing the same instruction a second time, or notice a recurring correction. Encode the rule as a lint, metadata flag, runtime check, or script instead of more text. |
/principle-exhaust-the-design-space | Apply when facing a novel UI interaction or architectural decision with no precedent in the codebase. Build 2-3 competing prototypes and compare side by side before choosing one. |
/principle-experience-first | Apply when product, UX, or feature-scope tradeoffs come up. Choose user delight over implementation convenience; ship fewer polished features over more rough ones. |
/principle-fix-root-causes | Apply when debugging. Trace each symptom to its root cause and fix it there; reproduce first, ask why until you reach it, resist nil-check guards that silence crashes. |
/principle-foundational-thinking | Apply before writing logic: choosing core types and data structures, sequencing scaffold-vs-feature work, asking what concurrent actors share. Get the data structures right so downstream code becomes obvious. |
/principle-guard-the-context-window | Apply when context is filling up: large outputs, long files, repeated reads, fan-out planning. Route bulk to subagents; keep summaries in the main thread, not raw payloads. |
/principle-laziness-protocol | Apply when refactoring, evaluating diff size, or tempted to add abstractions, layers, or signal threading. Bias toward deletion and the smallest change that solves the problem. |
/principle-make-operations-idempotent | Apply when designing commands, lifecycle steps, or processing loops that run amid crashes, restarts, and retries. Converge to the same end state regardless of partial prior runs. |
/principle-migrate-callers-then-delete-legacy-apis | Apply when introducing a new internal API while old callers still exist. Migrate callers and delete the old API in the same wave instead of preserving compatibility layers. |
/principle-minimize-reader-load | Apply when reviewing or shaping code that's hard to trace. Count layers between question and answer, and hidden state in the reader's head; collapse one-caller wrappers and shrink mutable scope. |
/principle-model-the-domain | Apply when writing stateful logic, or when code branches a lot or repeats a shape assumption across files. Encode the domain in a structure instead of scattered conditionals. |
/principle-never-block-on-the-human | Apply when tempted to ask 'should I do X?' on reversible work. Proceed, present the result, let the human course-correct after the fact; reserve confirmation for irreversible actions. |
/principle-outcome-oriented-execution | Apply during planned rewrites and migrations with explicit phase boundaries. Converge on the target architecture; don't preserve smooth intermediate states with throwaway compatibility code. |
/principle-prove-it-works | Apply after completing a task, before declaring done. Verify against the real artifact (run the feature, read the actual value, inspect the diff), not a proxy, self-report, or 'it compiles.' |
/principle-redesign-from-first-principles | Apply when integrating a new requirement into an existing design. Redesign as if the requirement had been a foundational assumption from day one, instead of bolting it on. |
/principle-separate-before-serializing-shared-state | Apply when concurrent actors might write to the same file, branch, key, or state object. Eliminate the sharing first; serialize structurally only when one shared writer is a real invariant. |
/principle-sequence-verifiable-units | Apply to multi-step work: sweeps, migrations, runs of similar edits. Break work into small units that each end in a verifiable state, check each before the next, and order the work so the sequence proves itself to a reviewer. |
/principle-subtract-before-you-add | Apply when sequencing an addition, refactor, or rewrite. Remove dead weight, redundant validators, and stub references first, then build on the simpler base. |
/principle-type-system-discipline | Apply when designing types, reviewing a function signature, or writing code in any statically-typed language. Make illegal states unrepresentable, brand semantic primitives, parse external data at boundaries, refuse to lie to the compiler, exhaust variants, derive from authoritative schemas. |