fradser/dotclaude/ask-matt

Claude Code and agent skill by fradser/dotclaude

Trust tier 2
  • community
LLM review pending
Source check pending

Checking that the SKILL.md file is still in the repository.

Recommends the skill or flow that fits the user's situation. A router over the skills in this repo. Use when the user asks which skill to use, is unsure what fits, or needs a pointer to the right workflow.

Install

npx vskill@latest install fradser/dotclaude/ask-matt

SKILL.md

The same SKILL.md was published earlier as fradser/dotclaude/ask-matt.

Ask Matt

You don't remember every skill, so ask.

Before stating what a skill does or recommending a step be skipped, read that skill's SKILL.md: the summaries here are for orientation only.

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.

  1. `/mattpocock:grill-with-docs` sharpens the idea by interview. Start here when you have a codebase: it's stateful, retaining what it learns in GLOSSARY.md and ADRs. (No codebase? Use /mattpocock:grill-me instead, covered under Standalone. Both run the same /mattpocock:grilling primitive; grill-with-docs is the one that leaves a paper trail.)
  2. 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 `/mattpocock:handoff` in both directions (see Crossing sessions):
  • `/mattpocock:handoff` out, then open a fresh session against that file,
  • `/mattpocock:prototype` to answer the question with throwaway code,
  • `/mattpocock:handoff` back what you learned, and reference it from the original idea thread.
  1. Branch: is this a multi-session build?
  • Yes → `/mattpocock:to-spec` (turn the thread into a spec), then `/mattpocock:to-tickets` 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/, worked blockers-first by hand; on a real tracker the edges become native blocking links, so any ticket whose blockers are done can be grabbed: kick off `/mattpocock:implement` per ticket, clearing context between each one. Each ticket is self-contained, so the last one's context is disposable.
  • No → `/mattpocock:implement` right here, in the same context window.

Either way, `/mattpocock:implement` builds each issue by driving `/mattpocock:bdd` internally (Discovery → Formulation, then Automation delegated to /mattpocock:tdd) (one vertical slice at a time), then closes out by running `/mattpocock:code-review`, a two-axis review (Standards + Spec) of the diff, before committing. Reach for `/mattpocock:bdd` on its own when you want to define Gherkin scenarios for a feature, and `/mattpocock:tdd` on its own when you want to write tests within the BDD Automation phase. Reach for `/mattpocock:code-review` on its own whenever you want to review a branch or PR against a fixed point.

For the Yes branch there is also `/mattpocock:implement-spec`: it reads the tickets as a task graph, runs implementer subagents across the ready frontier in parallel, and lands everything on one integration branch; each implementer drives the BDD pipeline, and it runs one /mattpocock:code-review over that branch. Reach for it when you'd rather orchestrate the build than drive each ticket yourself.

When the work goes up as a pull request, `/mattpocock:pr` shapes the body: the smallest visual that shows the change, before/after evidence that it works, and a one-way or two-way door call.

  1. `/mattpocock:retro` closes the loop. After a build, and especially one that went sideways, it looks back over the session and suggests changes to the agent's environment, not the code: navigation pointers, automated checks, the coding standards /mattpocock:code-review enforces, steering files, tooling. Mechanical mistakes become deterministic checks; judgement calls become coding standards. The next build then starts from a better environment.
Context hygiene

Keep steps 1–3 in one unbroken context window (don't compact or clear until after /mattpocock:to-tickets) so the grilling, spec, and tickets all build on the same thinking. Each /mattpocock:implement then starts fresh, working from the ticket. Run /mattpocock:retro in the session it's looking back on, before you clear; after clearing, point it at that session's log instead.

The limit on this is the [smart zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone): the window (~120k tokens on state-of-the-art models) within which the model still reasons sharply. If a session approaches it before /mattpocock:to-tickets, don't push on degraded; /mattpocock:handoff and continue in a fresh thread.

CRITICAL: Route by scenario, not by habit

Wayfinder is only for work too big for one session — never a well-scoped feature. Triage is only for issues the user didn't create — never for the tickets /mattpocock:to-tickets produced. Keep steps 1–3 in one unbroken context window: no compact or clear until after /mattpocock:to-tickets.

On-ramps

A starting situation that generates work, then merges onto the main flow.

  • Bugs and requests piling up → `/mattpocock:triage`. It moves issues through triage roles and produces agent-ready issues, which `/mattpocock:implement` later picks up.

Triage is only for issues you didn't create: bug reports, incoming feature requests, anything that arrives raw. Tickets that /mattpocock:to-tickets produced are already agent-ready, so don't triage them.

  • Something's broken → `/mattpocock:diagnosing-bugs`. 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. Once the fix is in, run /mattpocock:retro in the same session to ask what would have prevented the bug; where the real finding is that there's no good seam to lock it down, that's a job for `/mattpocock:improve-codebase-architecture`.
  • A huge, foggy effort: a greenfield project or a huge feature build, too big for one session → `/mattpocock:wayfinder`, 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 `/mattpocock:grill-with-docs` 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 `/mattpocock:to-spec`, which collapses the map's linked decisions into a buildable plan, then /mattpocock:to-tickets and /mattpocock:implement as usual. Looping the map straight into /mattpocock:implement skips that collapse and throws the linked detail away, so go straight to /mattpocock:implement only when the effort turned out genuinely small.

Codebase health

Not feature work, just upkeep.

  • `/mattpocock:improve-codebase-architecture` runs whenever you have a spare moment to keep the codebase good for agents to operate in. It surfaces deepening opportunities; picking one _generates an idea_ you can take into the main flow at /mattpocock:grill-with-docs. It's the survey that finds the candidates; `/mattpocock:codebase-design` (below) is the bench you design the chosen one on.

Vocabulary underneath

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.

  • `/mattpocock:codebase-design`: 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. /mattpocock:bdd, /mattpocock:tdd (BDD-driven), and /mattpocock:improve-codebase-architecture all speak it.
  • `/mattpocock:domain-modeling`: 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 /mattpocock:grill-with-docs drives to keep GLOSSARY.md a clean glossary.

Crossing sessions

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.
  • `/clear`: empty the window, when nothing here matters to what's next.
  • `/mattpocock:handoff` writes 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. It's the bridge between context windows, in either direction.
  • Subagent: send a tightly-scoped task to its own window and get a report back.
  • `/compact` (built-in) compresses this context and seeds 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. /mattpocock:handoff forks; /compact continues.

Standalone

Off the main flow entirely.

This is the start of the file. Read the full SKILL.md on GitHub.

Security

  • Security scanPassed, 100 of 100Pattern checks on the skill's files.
  • Model reviewNot runA model review is scheduled for the next rescan.

Quality evaluation

  • Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

Source

Popularity

Repository stars
593
Repository forks
51
7-day trend score
32

Stars and forks are for the whole GitHub repository, not this skill alone. Not refreshed yet.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

  • Claude Code
  • Cursor
  • GitHub Copilot
  • Windsurf
  • Codex
  • Gemini CLI
  • Cline
  • Amp
  • Roo Code
  • Goose
  • Continue
  • Kilo Code
  • Junie
  • Trae
  • OpenHands
  • Qwen Code
  • AI Agent
  • Tabnine Chat
  • Sourcegraph Cody
  • Amazon Q
  • Firebase Genkit
  • Sweep
  • Devin
  • Phind
  • Mentat
  • Claude Desktop
  • Aider
  • GPT Pilot
  • Plandex
  • bolt.new
  • v0
  • Replit Agent
  • Anse
  • TypingMind
  • BetterChatGPT
  • LibreChat
  • Warp AI
  • Pieces
  • Fig AI
Embed badge
vskill VERIFIED badge
[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/fradser/dotclaude/ask-matt/badge)](https://verified-skill.com/skills/fradser/dotclaude/ask-matt)

Something wrong with this skill or its page? Tell us.