grill-me
Challenge a plan with focused questions before writing implementation code.
npx skills add mattpocock/skills --skill grill-meFind workflow skills for design discussions, planning, testing and code maintenance.
Start with questions or a handoff when the task is underspecified. Use TDD after the behavior is clear enough to test.
Challenge a plan with focused questions before writing implementation code.
npx skills add mattpocock/skills --skill grill-meCross-check design questions against the project’s existing documentation.
npx skills add mattpocock/skills --skill grill-with-docsIdentify structural problems in a codebase and propose a migration path for fixing them.
npx skills add mattpocock/skills --skill improve-codebase-architectureWork in failing-test, passing-test cycles instead of writing tests after the implementation.
npx skills add mattpocock/skills --skill tddRecord progress, decisions and remaining work so the next session can continue.
npx skills add mattpocock/skills --skill handoffBuild the smallest throwaway experiment that settles an open design question.
npx skills add mattpocock/skills --skill prototypeNo skill in this category has a full write-up yet.
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.
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.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”.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.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.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.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
grill-me produces noise. Start from the decision and use grill-with-docs to check consistency instead.grill-me should raise. If it raises none, you are either done or not thinking.prototype: state the question it answers and delete it afterwards. Evidence it exists is evidence the step was skipped.tdd: check the first test run failed for the expected reason, not for a syntax error.handoff: read only the remaining-work section and see whether the next person could start.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.
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.
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.
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.