Ask Matt

You don't need to remember every skill, so just ask.

Flow is a path through skills. Most paths follow a main flow, with two on-ramps merging into it. Other content is either standalone or a vocabulary layer running underneath.

The main flow: idea -> ship

This is the route for most work: you have an idea and want to build it out.

/grill-with-docs
- Refine ideas through interviews. Start here when there's a codebase: it's stateful and saves what's learned in
```
CONTEXT.md
```
and ADRs. (No codebase? Use
```
/grill-me
```
, see Standalone. Both run the same
```
/grilling
```
primitive;
```
/grill-with-docs
```
is the version that leaves documentation traces.)
Branch - Can all issues be resolved in the conversation? If a problem requires a runnable answer (state, business logic, or UI that must be seen firsthand), detour via prototype and bridge both directions with /handoff
(see Crossing sessions):
- /handoff
  Export, then open a fresh session based on that file;
- /prototype
  Answer the question with throwaway code;
- /handoff
  Bring back what's learned and reference it in the original idea thread.
Branch - Is this a multi-session build?
- Yes -> /to-prd
  (turn the thread into a PRD) -> /to-issues
  (break the PRD into independently assignable issues). Since issues are independent, clear context between each issue: start a fresh session for each issue, pass the PRD and single issue to /implement
  .
- No -> Run /implement
  directly in the current context window.
Either way, /implement
internally drives /tdd
to build each issue: one red-green slice at a time; then wrap up with /code-review
, conducting a dual-axis review of Standards + Spec on the diff before submitting. Use /tdd
alone when you want to build a specific behavior test-first; use /code-review
alone when you want to review a branch or PR at a fixed point.

Context Hygiene

Steps 1 through

/to-issues

must stay in the same uninterrupted context window; do not compact or clear it, so that grilling, PRD, and issues can build on the same set of thinking. Each subsequent

/implement

starts with a fresh session, working only based on the corresponding issue.

The limitation comes from the smart zone: within this window (approximately 120k tokens for the latest models), the model can still maintain sharp reasoning. If the session approaches this limit before

/to-issues

, don't push through with degraded performance; use

/handoff

and continue in a fresh thread.

On-ramps

Starting points generate work and then merge into the main flow.

Bugs and requests are piling up -> /triage
. It advances issues through triage roles and produces agent-ready issues, which are then picked up by /implement
.
Triage is only used for issues not created by you: bug reports, incoming feature requests, and any content that comes in originally. Issues produced by
```
/to-issues
```
are already agent-ready, so don't triage them again.
Something's broken -> /diagnosing-bugs
. For tough problems: bugs not obvious at first glance, intermittent flakes, regressions stuck between two known-good states. It rejects speculation until it has a tight feedback loop, i.e., a command that already turns red for this bug; then fixes it with a regression test. If a retrospective finds the real issue is the lack of a good seam to lock the bug, it hands off follow-up to /improve-codebase-architecture
.

Codebase health

This is not feature work, but maintenance.

/improve-codebase-architecture
- Run when you have time to keep the codebase suitable for agent operation. It exposes deepening opportunities; choosing one generates an idea that can be brought into
```
/grill-with-docs
```
in the main flow. It is responsible for finding candidates; /codebase-design
(see below) is the workbench you use when designing the selected candidates.

Vocabulary underneath

Two model-invoked references run underneath other skills, each being the single source of truth for their own vocabulary. Use them directly when the problem is about words rather than processes; you can also let the above skills pull them up automatically.

/domain-modeling
- Refine the project's domain language: challenge vague terms, resolve overloaded words (e.g., an "account" taking on three roles), and record irreversible decisions as ADRs. It is the active discipline used by
```
/grill-with-docs
```
to keep the
```
CONTEXT.md
```
glossary clean.
/codebase-design
- Deep-module vocabulary (module, interface, depth, seam, adapter, leverage, locality) for designing the shape of modules: placing large amounts of behavior behind small interfaces on clean seams. Both
```
/tdd
```
and
```
/improve-codebase-architecture
```
use this set of language.

Crossing sessions

/handoff
- When a thread is nearly full, or you need to branch into another session (e.g., a
```
/prototype
```
session), compress the conversation into a markdown file. You won't continue in place; instead, open a new session and reference the file to carry over context. It is a bridge between context windows, usable in both directions. Use it when you want a fresh session but need to retain the current conversation.
/compact
(built-in) - Stay in the same conversation and let earlier turns be summarized. Use only at clear breakpoints between phases; do not compact mid-phase, otherwise the agent may get lost.
```
/handoff
```
is for forking;
```
/compact
```
is for continuing.

Standalone

Completely outside the main flow.

/grill-me
- The same continuous interview as
```
/grill-with-docs
```
, but for scenarios without a codebase. It is stateless: it doesn't save content locally or build
```
CONTEXT.md
```
. Use it to refine any plan or design that doesn't belong to a repo.
/prototype
- A small throwaway program used to answer a design question: does this state model feel right, or what should this UI look like? It's throwaway from day one: keep the answer, delete the code. It's a detour in step 2 of the main flow, but any design question that's hard to solve on paper can use it directly.
/research
- Delegate reading work to a background agent: it researches the question against primary sources and leaves a referenced Markdown file in the repo. You can continue working while it reads. The output should be brought into the main flow of
```
/grill-with-docs
```
; research provides thinking materials but does not replace thinking.
/teach
- Use the current directory as a stateful workspace to learn a concept across multiple sessions.
/writing-great-skills
- Reference for writing and editing skills.

Precondition

/setup-matt-pocock-skills
- Execute this before running the engineering flow for the first time to configure the issue tracker, triage labels, and docs layout that other skills depend on. Custom issue trackers are also supported.

ask-matt

NPX Install

Tags

SKILL.md Content (Chinese)