HavenSkills

Matt Pocock Skills

Find workflow skills for design discussions, planning, testing and code maintenance.

Skills
6 skills
Full write-ups
0

How to choose

Start with questions or a handoff when the task is underspecified. Use TDD after the behavior is clear enough to test.

Filter

All skills in this category

grill-me

Challenge a plan with focused questions before writing implementation code.

by mattpocock
npx skills add mattpocock/skills --skill grill-me
Author
mattpocock
Repo
GitHub

grill-with-docs

Cross-check design questions against the project’s existing documentation.

by mattpocock
npx skills add mattpocock/skills --skill grill-with-docs
Author
mattpocock
Repo
GitHub

improve-codebase-architecture

Identify structural problems in a codebase and propose a migration path for fixing them.

by mattpocock
npx skills add mattpocock/skills --skill improve-codebase-architecture
Author
mattpocock
Repo
GitHub

tdd

Work in failing-test, passing-test cycles instead of writing tests after the implementation.

by mattpocock
npx skills add mattpocock/skills --skill tdd
Author
mattpocock
Repo
GitHub

handoff

Record progress, decisions and remaining work so the next session can continue.

by mattpocock
npx skills add mattpocock/skills --skill handoff
Author
mattpocock
Repo
GitHub

prototype

Build the smallest throwaway experiment that settles an open design question.

by mattpocock
npx skills add mattpocock/skills --skill prototype
Author
mattpocock
Repo
GitHub

What the Matt Pocock skills are for

These six skills come from mattpocock/skills, and they share one assumption: the expensive mistake is building the wrong thing carefully. So they spend their effort before the code — challenging the plan, checking it against what the repository already says, and only then writing tests.

Because Matt Pocock writes TypeScript teaching material, the examples are TypeScript-shaped; the workflow itself is language-agnostic.

The order that pays off

  1. grill-me — takes a plan and asks the questions that expose what is still undecided: what happens on the failure path, what the existing code does today, why this approach over the obvious one. Use it while the design is still cheap to change.
  2. grill-with-docs — the same challenge, but cross-checks the answers against the project's own documentation and conventions. This is the one that catches “we already decided this two quarters ago”.
  3. prototype — when the question cannot be settled by talking: build the smallest experiment that answers it, then throw it away. The value is in the answer, not the artefact.
  4. tdd — small failing-test, passing-test cycles once the behaviour is clear enough to name. If you cannot name the test, the behaviour is not decided yet — go back to step 1.
  5. improve-codebase-architecture — periodic rather than per-task: find the places where coupling makes every change expensive, and propose structural changes with a migration path.
  6. handoff — writes down progress, decisions and what is left, so the next contributor starts from the decision instead of re-reading the conversation.

Install one at a time — the repo is small but each skill is independent:

npx skills add mattpocock/skills --skill grill-me

Where these skills break in practice

  • Grilling a decision already made. If the approach was settled last week, grill-me produces noise. Start from the decision and use grill-with-docs to check consistency instead.
  • Prototypes that survive. A prototype kept “just in case” becomes production code without the review it needed. Delete it the moment it answers the question.
  • TDD after the fact. Tests written to match the implementation pass on the first run and prove nothing. The failing run is the evidence.
  • Architecture opinions with no inventory. A refactor proposal that does not name the files, the coupling and the migration order is a theme, not a plan.
  • Handoff as a diary. What was done is the least useful part. What is left, what was decided against, and what would break is the part that matters.

The check that catches most of it

  1. Before coding: write down the decision you expect to make and the question grill-me should raise. If it raises none, you are either done or not thinking.
  2. For prototype: state the question it answers and delete it afterwards. Evidence it exists is evidence the step was skipped.
  3. For tdd: check the first test run failed for the expected reason, not for a syntax error.
  4. For handoff: read only the remaining-work section and see whether the next person could start.

Which page to read next

Superpowers covers the same loop as a stricter discipline — verification and code review included. Coding skills covers individual reviews and refactors without the upfront questioning.

Frequently asked questions

Which skill should I start with? grill-me if plans often turn out wrong halfway through. tdd if you want the tightest feedback loop. handoff if work stops mid-task often.

Do these work outside TypeScript? Yes. The instructions are language-agnostic; examples lean TypeScript because that is the author's domain.

grill-me or grill-with-docs? grill-me for an open design question, grill-with-docs when you need the answer checked against decisions the repository already records.

When should I run improve-codebase-architecture? Between features, not during one. It reads the codebase as a whole and proposes structural change — the wrong input for a single-task session.

How much do these skills slow the agent down? They add a step and save rework. The measurable effect is fewer reopened tasks, not faster single tasks.

How to choose between these six skills

Pick by what is undecided. An open design question needs grill-me; a question that the repository already answers needs grill-with-docs; a question only running code can answer needs prototype. Tests come after the behaviour is named, architecture work comes between features, and handoff comes when the session ends mid-task.

How to check the result

Install one skill, then give it a single real task rather than a demo: the plan you are actually unsure about, or the handoff you actually need to write. Read what it produces and ask whether it named something you had not written down — a failure path, an existing convention, a file that will have to change. If the output only restates your input, the skill is not doing the work and the task was too vague.