Ask Matt
You don't remember every skill, so ask.
A flow is a path through the skills. Most paths run along one main flow, and two on-ramps merge onto it. Everything else is standalone, or a vocabulary layer that runs underneath.
The main flow: idea → ship
The route most work travels. You have an idea and want it built.
-
— sharpen the idea by interview. Start here whenever you are
working in a working directory: it's stateful, retaining what it learns in
and ADRs. (No working directory? Use
— see Standalone. Both run the same
primitive;
is the one that leaves a paper trail, which makes it the better of the two whenever a repo is there to leave it in.)
-
Branch — can you settle every question in conversation? If a question needs a runnable answer (state, business logic, a UI you have to see), detour through a prototype, bridged by
in both directions (a prototype lives in its own directory, which is exactly what
is for — see Phase boundaries):
- out, then open a fresh session against that file,
- to answer the question with throwaway code,
- back what you learned, and reference it from the original idea thread.
-
Branch — is this a multi-session build?
- Yes → (turn the thread into a spec), then to split it into tracer-bullet tickets, each declaring its blocking edges. On a local tracker that's one file per ticket under
.scratch/<feature>/issues/
- No → right here, in the same context window.
Either way,
builds each issue by driving
internally — one red-green slice at a time — then closes out by running
, a two-axis review (Standards + Spec) of the diff, before committing. Reach for
on its own when you just want to build a concrete behaviour test-first without a full spec, and
on its own whenever you want to review a branch or PR against a fixed point.
Context hygiene
Keep steps 1–3 in
one unbroken context window — don't compact or clear until after
— so the grilling, spec, and tickets all build on the same thinking. Each
then starts fresh, working from the ticket.
The limit on this is the
smart zone: the window (~150k tokens on state-of-the-art models) within which the model still reasons sharply. If a session approaches it before
, don't push on degraded —
at the nearest phase boundary and carry on (see Phase boundaries).
On-ramps
A starting situation that generates work, then merges onto the main flow.
-
Bugs and requests piling up →
. It moves issues through triage roles and produces agent-ready issues, which
later picks up.
Triage is only for issues
you didn't create — bug reports, incoming feature requests, anything that arrives raw. Tickets that
produced are already agent-ready, so
don't triage them.
-
Something's broken →
. For the hard ones: the bug that resists a first glance, the intermittent flake, the regression that crept in between two known-good states. It refuses to theorise until it has a
tight feedback loop — one command that already goes red on
this bug — then fixes with a regression test. Its post-mortem hands off to
/improve-codebase-architecture
when the real finding is that there's no good seam to lock the bug down.
-
A huge, foggy effort — a greenfield project or a huge feature build, too big for one session →
, the most cognitively demanding flow here. When the way from here to the destination isn't visible yet, it charts a
shared map of
decision tickets on the issue tracker and resolves them one at a time — producing
decisions, not deliverables — until the fog is pushed back and the way is clear. Where
sharpens an idea you can hold in one session, wayfinder is for the idea you can't — and it's slower and denser, so save it for exactly that, never a well-scoped feature.
When the map clears,
it hands off, it doesn't build: merge onto the main flow at
, which collapses the map's linked decisions into a buildable plan, then
and
as usual. Looping the map straight into
skips that collapse and throws the linked detail away — go straight to
only when the effort turned out genuinely small.
Codebase health
Not feature work — upkeep.
/improve-codebase-architecture
Vocabulary underneath
Two model-invoked references that run beneath the other skills — each the single source of truth for its vocabulary. Reach for them directly when the words, not the process, are the problem; or let the skills above pull them in.
- — sharpen the project's domain language: challenge a fuzzy term, resolve an overloaded word ("account" doing three jobs), record a hard-to-reverse decision as an ADR. It's the active discipline drives to keep a clean glossary.
- — the deep-module vocabulary (module, interface, depth, seam, adapter, leverage, locality) for designing a module's shape: a lot of behaviour behind a small interface at a clean seam. and
/improve-codebase-architecture
Phase boundaries
A phase is a chunk of work inside a session — the grilling, the implementation, the QA. At the boundary between two of them you have five options, and picking between them is the fuzziest decision in this whole map:
- Continue — stay put. Costs nothing, loses nothing.
- — empty the window, when nothing here matters to what's next.
- — write a portable markdown file. Narrow: only for a new harness, a new directory, a colleague, or forking a side task mid-phase. What it buys is portability.
- Subagent — send a tightly-scoped task to its own window and get a report back.
- — compress this context and seed a fresh session with it. The default, at the bottom of the tree rather than the first reach.
Read PHASE-BOUNDARIES.md for the ordered tree — the five questions, the reasoning behind each branch, and why the primary-source cost makes Continue the one to rule out first. Make the decision at a boundary; mid-phase, continue or split the rest into subagents.
Standalone
Off the main flow entirely.
- — the same relentless interview as , but stateless: it saves nothing locally and builds no . Reach for it when you are not working in a working directory — sharpening a plan, a design, a piece of writing, anything with no repo under it. If you are in a working directory, use instead: it runs the same interview and leaves a paper trail, so it is strictly the better one.
- — the interview primitive itself: rounds, the frontier, facts are the agent's job and decisions are yours. and are the two named ways in, and , and
/improve-codebase-architecture
/resolving-merge-conflicts
- — a small, throwaway program that answers one design question: does this state model feel right, or what should this UI look like. Throwaway is a constraint on how the code is written, not a promise to destroy it: the answer folds into the real code, and the prototype itself is kept as a primary source on a branch out of main, pointed at from the implementation issue. 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.
- — delegate reading legwork to a background agent: it investigates a question against primary sources, then leaves a cited Markdown file in the repo. Keep working while it reads. The file it produces is something to take into the main flow at — research feeds the thinking, it doesn't replace it.
- — when the thing blocking you isn't in your head or the codebase but in someone else's, this writes them a questionnaire to fill in. It's the inverse of : instead of interviewing you about the subject, it interviews you about the send — who it's going to, what you need back — and aims the questions at the gap. What comes back is material for or .
- — for the steps only a human can take: provisioning infrastructure, setting up credentials or CI secrets, clicking through an unfamiliar third-party dashboard, running a one-off migration or cutover. It generates an interactive bash script that opens each URL, captures each value, and writes it into and GitHub secrets — so the procedure stops being something you re-explain to an agent every time. Model-invoked, so the agent reaches for it the moment it hits a wall only you can pass. If the agent could just do it itself, it should; this is for where a human is genuinely in the loop.
- — the corrective for a message that didn't land. Use it mid-conversation, inside any other skill, and the agent re-pitches what it just said with the context you were missing, in plain English, using the vocabulary. It works after the fact; is the upfront cure, because a shared language agreed early is what stops the jargon arriving at all.
- — learn a concept over multiple sessions, using the current directory as a stateful workspace.
- — reference for writing documents agents consume: skills, AGENTS.md, pointed-at docs.
Precondition
/setup-matt-pocock-skills
— run before your first engineering flow to configure the issue tracker, triage labels, and doc layout the other skills assume. Custom issue trackers also work.