A coding agent can get surprisingly far before you realise it has misunderstood the task. By then, you have code to review, tests to untangle and a conversation to start again. Matt Pocock skills give you a way to ask more of the questions before that work begins, then carry the answers through implementation and review.
The collection contains 27 skills, but you do not need to turn every change into a 27-step process. For a first trial, choose a ticket with a few unresolved requirements and start with /grill-with-docs. You may already know /grill-me, which interviews you about a plan. This version also records the decisions, so the next session does not need you to explain everything again. The rest of the workflow becomes useful as more people, sessions or agents get involved.
What are Matt Pocock skills?#
TypeScript educator Matt Pocock publishes the skills in the open-source mattpocock/skills repository. Each skill gives a coding agent instructions for a particular job: questioning a design, preparing tickets, reviewing code or helping with another part of development. They are available under the MIT licence, and the repository has more than 300,000 GitHub stars. Pocock's AI Hero catalogue lists support for Claude Code, Cursor, Codex, Copilot and Amp.
This guide covers the v1.3 series and the 27-skill catalogue as of November 2026. The catalogue has six groups: Getting started, The main flow, Shaping, Engineering, Productivity and Reference. You invoke some skills directly, such as /grill-with-docs. Others provide instructions the agent can draw on while doing the work, including grilling and tdd. You can use individual skills without adopting the entire sequence.
That flexibility is useful when introducing them to a team. If unclear requirements regularly come back during review, try the interview. If work gets lost between sessions, try the documentation and handoff tools. Installing the collection gives you options; deciding which problem to address gives you somewhere to start.
How do you install Matt Pocock skills?#
For editable project files, run the installer from your repository and select the skills and agents you want:
npx skills@latest add mattpocock/skills
Claude Code also has a managed plugin. Its files are read-only and it updates automatically:
claude plugins install mattpocock-skills
For a team that wants to inspect updates before adopting them, we recommend the editable installation. Keep the project copy under version control so reviewers can see when its instructions change. The managed plugin is convenient for trying the collection, but automatic updates give you less control over when everyone moves to a new version.
Next, run the setup skill once in each repository:
/setup-matt-pocock-skills
It settles up to three things: where you track issues, which triage labels you use and where you keep domain documentation. It skips anything it can already work out, so most runs need only two answers. GitHub requires gh, GitLab requires glab, and local Markdown or another accessible tracker are also options. The answers go into docs/agents/issue-tracker.md and docs/agents/domain.md, with docs/agents/triage-labels.md added if you use triage. Setup also writes an "Agent skills" block into the project's CLAUDE.md or AGENTS.md instructions.
Read those changes before proceeding. Pocock's setup documentation acknowledges two gaps: it can write to CLAUDE.md even when you use Codex, and it does not create the tracker labels for you. Codex users should make the same instructions available through AGENTS.md. Create any required labels yourself, then check that the agent knows where to find the project documentation and file an issue.
How does the main flow work?#
Pocock's recommended sequence is /grill-with-docs, /to-spec, /to-tickets, /implement, /code-review and /retro. Each step gives the next one something to work from. The point is to avoid having a specification, a ticket and an implementation that quietly describe different things.
Start with the questions#
/grill-with-docs interviews you about the plan and records the terminology you agree on in GLOSSARY.md. It also writes architecture decision records, or ADRs, for decisions that involve a real trade-off, are surprising and would be difficult to reverse. It should not need an ADR for every answer.
Imagine asking an agent to let customers cancel a subscription. Does cancellation take effect immediately or at the end of the paid period? Does the customer retain access? Those answers change the implementation. The interview gives you a chance to settle them before the agent chooses for you. /grill-me asks questions too, but /grill-with-docs keeps the resulting project terms and decisions in files that later sessions can read.
Turn the answers into work#
/to-spec turns the agreed conversation into a specification in your issue tracker. This is where spec-driven development becomes practical: someone should be able to read the spec and tell whether the resulting behaviour is correct. For the cancellation example, that means stating what happens to access after cancellation, rather than leaving the implementer to infer it.
/to-tickets divides the specification into smaller tasks and records which ones block others. Read the dependencies before starting implementation. If the access rule is still unresolved, splitting the work between a billing ticket and an account ticket will not resolve it. Both implementers need the same answer.
Build, review and improve the setup#
/implement works test-first and commits the changes. It uses the current branch and does not create a working branch for you, so check out the intended branch before starting. The tests still need human judgement: a passing test is useful only if it checks the behaviour the team agreed to deliver.
/code-review examines the change against the specification and your coding standards. Supply the standards you expect a human reviewer to apply. Without them, the agent has less to work with and can fall back on generic advice. /retro then proposes improvements to the setup based on the session. Review those suggestions before keeping them; an instruction that helped with one task may be wrong for the next.
Enjoying it so far?Get more like it in our AI Native newsletter.
Read the newsletterWhich workflow should you use for each task?#
Daniel Mackay's workflow guide makes a useful distinction: choose by how many sessions the work needs. A change in a large codebase may take one sitting. A smaller feature may need several sessions because its requirements are unclear or someone else has to continue it.
For a tiny, well-understood change, use the tdd guidance and /code-review. If a bug report already explains the expected behaviour and gives you a reproduction, a lengthy interview may add little. For a feature you can complete in one session, our suggested default is /grill-with-docs followed by /implement, with review before accepting the change. You keep the decisions without producing a separate planning document for every small task.
When work spans several sessions, use the full flow. Clear the conversation between tickets with /clear where supported, so the next session works from the saved specification and ticket. If you have to reconstruct the previous conversation, put the missing information into those documents. That is information the next engineer would need too.
For independent tickets that can run in parallel, /implement-spec coordinates implementation towards one integration branch. Check the dependencies first. For a larger project where the team is still deciding what to build, start with the wayfinder skill, /wayfinder. Use it to work through the open decisions, then move the parts you understand into the main flow. You can settle one part of a project without pretending the whole project is ready.
What do the other Matt Pocock skills do?#
The main flow accounts for six skills. The rest support tasks you may need before, during or after it. Pocock's AI Hero catalogue has the full instructions; the groups below give you a way to find the relevant ones.
Getting started#
/setup-matt-pocock-skills connects the collection to your repository's conventions. /ask-matt helps you choose a skill when you know the problem but are unsure which command fits. Describe what is unresolved rather than asking it to take you through every skill.
Shaping#
/wayfinder helps with open-ended work. /prototype lets you investigate a question through throwaway code that is never merged, while /research gathers evidence from primary sources. Choose according to what you need to learn: some questions need a decision, some need a working example and others need a source you can check.
Engineering#
The architecture skill people ask about is /improve-codebase-architecture, which helps identify possible refactorings. /diagnosing-bugs supports bug investigation, and /triage sorts incoming issues. /wizard creates a guided setup script for a person to follow. /implement-spec handles parallel implementation of a specification.
Productivity#
Alongside /grill-me, the handoff skill, /handoff, records a session so another can continue it. /to-questionnaire puts unresolved questions into a document for someone to answer. /teach supports learning across sessions, and /wait-what asks for a clearer explanation. /writing-for-agents helps prepare instructions and other text that agents will use.
Reference#
These skills provide guidance other work can draw on. pr covers pull request descriptions; codebase-design covers software structure; domain-modeling helps keep terminology consistent. grilling provides the interview approach, and tdd describes working from a failing test through implementation and refactoring. They are part of the collection, without all being extra stages you must run.
Are Matt Pocock's skills good?#
They are worth trying when the team needs help clarifying a task or preserving decisions between sessions. Their small, editable files also make it possible to change the instructions that are unhelpful. That does not establish that adopting the full collection will make a team faster.
In his Scott Logic review, Colin Eberhardt used the skills to rebuild his karting app. An interview of roughly five minutes produced about 45 lines of domain notes and an ADR. The specification was around 80 lines and became eight tickets. The first code review caught bugs. He liked the combination of questioning and domain modelling, and found the skills lightweight and adaptable.
He also found tests that mostly checked their own mocks, specifications that repeated engineering rituals without useful judgement, and a /wizard run whose knowledge of Supabase was out of date. Without a coding standard, the review fell back on a generic list of code smells. His experience supports inspecting the outputs, rather than treating completion of the workflow as evidence that the work is good. It is one developer's review, not a measurement of team-wide savings.
Our recommendation is to try the interview and review steps on work where requirements often need clarification. Add specifications and ticket breakdowns when another session or person needs to continue the work. Keep routine fixes short. Engineers pay for an interview with their attention, and longer documents consume model context when they are read. The skills are free; the process still takes time and model usage. A useful pilot should count both.
How should a team adopt Matt Pocock skills?#
Give someone responsibility for the team's copy. Record the upstream version or commit, review changes on a branch and read the changelog before updating. For an editable installation, the update command is:
npx skills update
File changes can affect existing project instructions. In v1.3, CONTEXT.md became GLOSSARY.md. If the team updates the skills but leaves instructions pointing at the old file, a new session may look in the wrong place. Check those references as part of the update, then try the workflow before merging it for everyone.
Write down the coding standards /code-review should use. Start with rules reviewers repeatedly have to explain, and point to code that follows them. A specific convention about where permissions are checked gives the agent something to inspect. General requests for clean, maintainable code give it much less.
Also agree on who can start implementation. /implement commits to the branch it is given. The ready-for-agent label can trigger unattended work when automation watches for it, potentially across a whole specification. Decide who may apply that label and who reviews the resulting changes. These decisions belong in the rollout, before the team begins experimenting with parallel implementation.
Run a two- to four-week pilot with one team and a real backlog. Measure time from starting a task to accepting it, how much review it needs and how often it comes back for rework. Include the time engineers spend answering the interview. Record token usage or model cost where available, alongside interventions and failed attempts. More generated tickets or faster code generation will not tell you whether the whole job became easier.
When the pilot ends, ask the engineers which outputs they actually used. Did a recorded decision prevent a disagreement? Could a fresh session continue without a long explanation? Did review find problems worth fixing? Keep the steps that helped and remove unnecessary ones for that type of work. That is the approach we recommend when training engineering teams in agentic coding: use a real task to decide which parts of the process deserve to become routine.






