which-skill
Pick the skill or flow that fits your situation. A router over the skills in this repo.
- License 许可
- Apache-2.0
- 最近更新
- 2026-11-06
- Stars
- ★ 7
- Forks
- 0
01 前言 Front Matter
- name
- which-skill
- description
- Pick the skill or flow that fits your situation. A router over the skills in this repo.
- disable-model-invocation
- true
03 SKILL.md 正文
Which skill?
You won't hold every skill in your head, so route through this instead of guessing.
A flow is a path traced across the skills. Most work follows a single main flow, with two on-ramps feeding into it. The rest are either standalone tools or a vocabulary layer that operates beneath everything else.
The main flow: idea → ship
The route most work takes. You have an idea; you want it built.
-
/grill-with-docs— sharpen the idea through interview. Start here when there is a codebase: it keeps state, folding what it learns back intoCONTEXT.mdand ADRs. (No codebase yet? Use/grill-me— see Standalone. Both drive the same/grillingprimitive; onlygrill-with-docsleaves a written trail.) -
Branch — can every open question be closed in conversation? If any question demands a runnable answer (state, business logic, a UI you have to lay eyes on), take a detour through a prototype, with
/handoffcarrying context in each direction (see Crossing sessions):/handoffout, then start a clean session against that file,/prototypeto settle the question with disposable code,/handoffthe findings back, and cite them from the original idea thread.
-
Branch — do you know what the feature actually rests on? If it's unclear which capabilities the idea needs versus what the codebase already provides, run
/to-primitives: it grades every capability against HEAD (exists/partial/missing, cited) and leaves a design doc with a build-order graph that/to-prdand/to-issuescan draw on. Skip it when the ground is already obvious. -
Branch — is this a multi-session build?
- Yes →
/to-prd(fold the thread into a PRD) →/to-issues(cut the PRD into issues anyone can grab independently). Since the issues stand alone, reset context between them: open a fresh session per issue and start/implementwith the PRD plus the one issue to work on. - No →
/implementright here, without leaving this context window.
Either path,
/implementdelivers each issue by driving/tddunderneath — one red-green slice at a time — then finishes with/code-review, a two-axis pass (Standards + Spec) over the diff, before it commits. Pull in/tddby itself when you simply want a concrete behaviour built test-first without a full spec, and/code-reviewby itself whenever you want a branch or PR checked against a fixed baseline. - Yes →
Context hygiene
Hold steps 1–4 inside one continuous context window — don't compact or clear until /to-issues is done — so the grilling, the PRD, and the issues all rest on the same line of thinking. Each /implement then begins clean, taking the issue as its starting point.
What bounds this is the smart zone: the window (roughly 120k tokens on current frontier models) inside which the model still reasons crisply. If a session nears that edge before /to-issues, don't grind on through degraded reasoning — /handoff and pick up in a fresh thread.
On-ramps
A starting situation that generates work, then merges onto the main flow.
-
Bugs and requests stacking up →
/triage. It walks issues through their triage roles and turns out agent-ready issues, which/implementlater collects.Triage is for issues you didn't author — bug reports, incoming feature requests, whatever lands raw. Issues that
/to-issuesproduced are already agent-ready, so skip triage for those. -
Backlog gone stale →
/audit-issue. Point it at an old issue or epic and it verifies every claim against HEAD, teaches back what the tree affords, and recommends keep / rescope / close — with drafted closing comments so the research survives the closure. Issues it recommends rescoping feed/to-issues; ones worth keeping feed/implement. -
Something's broken →
/diagnosing-bugs. Built for the stubborn ones: the bug that shrugs off a first look, the intermittent flake, the regression that slipped in between two known-good points. It won't theorise until it holds a tight feedback loop — one command that already goes red on this bug — then lands the fix behind a regression test. Its post-mortem hands off to/improve-codebase-architecturewhen the real lesson is that no clean seam exists to pin the bug down.
Loops
Recurring work, or the main flow with nobody watching in real time.
/designing-loops— reference for the four loop shapes and how to write a completion criterion that actually stops the loop. Read this before wiring up any of the below./dependency-update-loop,/stacked-pr-loop,/deploy-verify-loop— ready-to-hand-to-a-schedule recipes for the recurring maintenance that piles up around shipped code: bot PRs, PR stacks, and the window right after a deploy.
Codebase health
Not feature work — upkeep.
/improve-codebase-architecture— reach for it whenever you have a spare moment to keep the codebase pleasant for agents to work in. It surfaces deepening opportunities; choosing one spawns an idea you can carry into the main flow at/grill-with-docs. It's the survey that turns up candidates;/codebase-design(below) is the bench where you shape the one you picked.
Verification
Turn a spec or a settled design into the checks that keep an implementation honest. Each distils the current thread into an in-repo doc; run them once the design is firm, before or alongside /implement. They compound — invariants become fuzz oracles, and both sharpen the conformance suite.
/to-invariants— the properties that must always hold. Splits into design-level system invariants and enforceable ones, each mapped to a check or flagged as an unguarded GAP. Start here; the other two lean on its output./to-fuzz— the targets worth fuzzing, each pinned to an oracle (differential, round-trip, invariant, crash). Reuses/to-invariantsoutput directly — every enforceable invariant is a ready-made oracle./to-conformance— a spec's normative requirements (MUST/SHOULD/MAY) turned into implementation-independent tests any conforming build must pass, with a traceability matrix and flagged spec ambiguities.
Vocabulary underneath
Two model-invoked references that sit below the other skills — each the single source of truth for its vocabulary. Call them directly when the words, not the process, are the sticking point; or let the skills above draw them in.
/domain-modeling— tighten the project's domain language: challenge a fuzzy term, untangle an overloaded word ("account" pulling triple duty), pin a hard-to-reverse decision into an ADR. It's the live discipline/grill-with-docsdrives to keepCONTEXT.mda clean glossary./codebase-design— the deep-module vocabulary (module, interface, depth, seam, adapter, leverage, locality) for shaping a module's form: plenty of behaviour behind a small interface at a clean seam. Both/tddand/improve-codebase-architecturespeak it.
Crossing sessions
/handoff— when a thread is full or you need to peel off (say, into a/prototypesession), this compresses the conversation into a markdown file. You don't resume in place — you open a new session and point it at that file to ferry the context across. It's the bridge between context windows, working either way. Use it when you want a fresh session but need the current conversation kept intact./compact(built-in) — stay in the same conversation and let the earlier turns be summarized. Use it at deliberate breaks between phases, when losing the verbatim history is fine. Don't compact mid-phase — the agent can lose the thread./handoffforks;/compactcontinues.
Standalone
Off the main flow entirely.
/grill-me— the same unrelenting interview as/grill-with-docs, but for when there's no codebase. Stateless: it writes nothing locally, builds noCONTEXT.md. Reach for it to sharpen any plan or design that doesn't live in a repo./prototype— a small, disposable program that answers one design question: does this state model feel right, or what should this UI look like. Throwaway from the first line — keep the answer, delete the code. It's the detour in step 2 of the main flow, but reach for it any time a design question is hard to settle on paper./research— hand the reading legwork to a background agent: it chases a question through primary sources, then drops a cited Markdown file into the repo. Keep working while it reads. What it produces is something to bring into the main flow at/grill-with-docs— research feeds the thinking, it doesn't stand in for it./teach— learn a concept across several sessions, treating the current directory as a stateful workspace./writing-great-skills— reference for writing and editing skills well.
Precondition
/setup-skills — run it before your first engineering flow to configure the issue tracker, triage labels, and doc layout the other skills expect. Custom issue trackers work too.
04 同仓库更多 Skills
writing-great-skills
Reference for writing and editing skills well — the vocabulary and principles that make a skill predictable.
technical-writing
House style for technical writing — the voice, sentence craft, formatting, and user-facing-copy rules that make docs and product text clear, direct, and consistent. Use when writing or editing a README, docs, a spec, release notes, a changelog, help text, or any error/CLI/UI copy a person reads; when reviewing a diff that touches prose or messages; or when a project needs a writing standard. Reference-heavy mechanics live in REFERENCE.md.
teach
Teach the user a new skill or concept, within this workspace.
handoff
Compact the current conversation into a handoff document for another agent to pick up.
grilling
Interrogate the user's plan or design one decision at a time until you both share the same understanding. Use when the user wants to pressure-test an idea before building it, or reaches for any 'grill' trigger phrase.
grill-me
A relentless, one-decision-at-a-time interview that sharpens a plan or design.