Matt Pocock's Claude Code Skills: The 7 He Runs, in Order, to Ship 21,000 Lines
A developer just shipped 21,000 lines of code. He didn't write any of them, and while they were being written, he wasn't even at his desk. That developer is Matt Pocock, and he did it with his own skills: a set of small instruction files for Claude Code, free on GitHub, with 327,319 stars (counted Nov 18 2026).
The short version: he runs seven skills in a fixed order, and he only shows up twice. He is there for the first four stops, gone for the fifth, and back for the last two. On Nov 18 he posted a 70-minute video of the whole run on a real feature. We watched every minute, then opened the repo and read the files. Here is each stop, what the file really says, and one thing you can try today.
The whole road at a glance
| Stop | Skill | What happens | Who is there |
|---|---|---|---|
| 1 | /grill-with-docs | Claude interviews you before any code. About 40 questions in his session. | You |
| 2 | domain-modeling | Keeps GLOSSARY.md, one agreed name per thing, plus short decision notes. | You |
| 3 | /prototype | Three very different throwaway versions. You keep one. | You |
| 4 | /to-spec and /to-tickets | Writes down what was agreed (47 user stories), cuts it into 9 tickets. | You |
| 5 | /implement-spec | A fresh agent per ticket, in parallel, then a two-part review. | The agent, alone |
| 6 | The review | The big change is split into a stack of 7. You read the one that can't be undone. | You |
| 7 | /retro | Reads the sessions and your review comments, and proposes fixes to the setup. | You |
Stop 1: /grill-with-docs (the interview)
Before any code gets written, Claude interviews him. He opens with the problem, not with what to build: "If I give it the why, then the agent feels a lot more empowered to go away and actually produce a solution itself."
The file behind this surprised us more than the video. It is seven lines, and only one is an instruction: call the skill tool twice, for grilling and for domain modeling. The real work is inside those two. Grilling is 30 lines, and three rules do the heavy lifting:
- Ask every question you can ask right now, in one numbered round.
- Give a recommended answer with each one, worded so that "yes" accepts it.
- Finding facts is the agent's job. Decisions are yours.
The second rule is the clever one. Near the end, answering is just "yes, yes, yes, yes." And if 40 questions sounds like a lot, he has an answer: "You should be the one in charge of it. The agent is not grilling you."
Try this today: describe a problem, not a solution. Then type /grill-me. That is the same interview, for anything. A business plan, a big purchase, a career move. No code needed.
Stop 2: domain-modeling (GLOSSARY.md and ADRs)
This one runs underneath the interview. Fancy name, simple idea: one file called GLOSSARY.md, with one agreed name for every thing in your project.
Why does a list of words matter? Matt's own example from the README: before the glossary, the agent wrote "There's a problem when a lesson inside a section of a course is made real." After, it wrote "There's a problem with the materialization cascade." Twenty-three words became seven. Every session after that gets shorter, and the names in the code finally match.
The same skill also writes down decisions, in short notes called ADRs (architectural decision records). But only when three things are true: it's hard to reverse, it would surprise someone later, and there was a real trade-off. His reason for keeping them is an old story about a fence: "Do not remove a fence until you know why it was put up in the first place."
Try this today: ask Claude to list every word in your project that means two different things. Pick one name for each and save them in GLOSSARY.md.
Stop 3: /prototype (three versions, not one)
Some questions you can't answer by talking. Like, how should this feel to use? So the skill says: don't build one version. Build several radically different ones on the same page, with a switch at the bottom. Three by default, all of them throwaway.
Why three? "Especially if it builds something that you don't like, that often tells you more than what you might get from something you do like." When he opened them, two out of three were bad. That's the point.
Try this today: next time you ask for a screen, ask for three very different versions of it, and a way to flip between them.
Stop 4: /to-spec and /to-tickets
Two skills, back to back. The first rule in the spec file is our favorite line in the repo: do not interview the user. By now everything has been said, so it just writes it down. In his run, that was 47 user stories, plus a list of what is out of scope.
Then /to-tickets cuts the spec into slices. Each slice is small enough for one fresh session, and each one says what has to finish before it can start. He got nine.
All of this paperwork has one purpose: to leave the agent nothing to guess.
Stop 5: /implement-spec (he walks away)
One command, and then: "I'm going to walk away, and when I come back I should have working code."
Here is what runs while he's gone. The file says the tickets are not a list. They are a map of what blocks what. So every ticket that is ready starts at once. Each one gets its own agent, its own copy of the code, and a fresh memory.
Fresh matters. Matt's view, which he credits to Dex Horthy, is that when an agent gets to around 150K tokens (roughly, how much it has read and written in one session), "it starts acting a little bit stupider." With one ticket per agent, none of them gets deep enough to get sloppy.
When the tickets finish, a review runs, and it checks two things separately. Does the code follow your standards? And does it do what the spec asked? In Matt's run it found one hard violation and some extra work nobody asked for, and started fixing both before he came back. To this: 21,000 lines, in one pull request (a bundle of changes waiting for approval).
Stop 6: the review (one-way and two-way doors)
He's back, and nobody can read 21,000 lines. So he borrows an idea that lives in the pull request skill: doors. A two-way door is a change "you can merge and then revert anytime." A one-way door "is merged and then is very difficult to unmerge."
He asks the agent to split the pile into a stack of seven smaller ones. Six are two-way doors. One is a one-way door, because it changes the database. One out of seven. That's where his attention goes.
Stop 7: /retro (12 comments, one root cause)
He left 12 review comments. Then he typed /retro and pointed it at all 30-odd sessions.
It all came down to one root cause. The agents weren't being careless. They were copying him. His own code and his own docs showed the patterns he was complaining about, one of them 2,078 times in 698 files. His reaction: "I am trying to turn an oil tanker around, apparently."
So telling the agent to try harder would have done nothing. The retro file has a rule for exactly this: if a mistake is mechanical, don't write another instruction. Build a check that fails, like a lint rule or a test. Save the written standards for real judgment calls, and give those to the reviewer, not the builder.
Where a human still matters
In Matt's words: "Grilling and retro are really the two main points at which I interact with the system." The start, and the end.
To be fair
This is not for every task, and Matt says so himself. If the change is really small, "you can probably just one-shot the thing." We also did not run a test of our own here. The numbers about the run are the ones he says or shows in his video, and the file quotes are from the repo's main branch as read on Nov 18 2026.
How to begin (4 steps)
- Install it. It's one line, and it's in the README: claude plugin install mattpocock-skills@claude-plugins-official
- Run the setup command, /setup-matt-pocock-skills, once in your project.
- For your next real change, start with /grill-with-docs.
- When it's done, run /retro.
Even if you skip everything in between, those two will change how you work.
Get the 7-Stop Ship Sheet
We put the whole road on one page: all seven skills, what each file really says, the commands, and the try-this-today steps. Comment HANDSOFF on the video, or grab it below. Then watch Matt's full video. (70 minutes). The skills are free in his GitHub repo, and he has his own page for them.
Source: "Watch me ship a 21,000-line feature with mattpocock/skills" by Matt Pocock, published Nov 18 2026, and the skill files in github.com/mattpocock/skills (main branch, read Nov 18 2026). Quotes are lightly trimmed for reading. Independent, not affiliated with Matt Pocock, AI Hero or Anthropic.
Free PDF: The 7-Stop Ship Sheet
The 7-Stop Ship Sheet: all seven skills on one page, what each file really says, the commands, and the try-this-today steps.
Join 27,000+ readers of the Hyperautomation AI Report
Quick answers
What is mattpocock/skills?
It is a free, open-source set of small instruction files (called skills) for coding agents like Claude Code, made by Matt Pocock. The repo is on GitHub under the MIT license and had 327,319 stars when we counted on Nov 18 2026. Each skill tells the agent how to do one job, such as interviewing you before it writes code or reviewing its own past sessions.
How do I install Matt Pocock's skills in Claude Code?
The install is one line from the repo's README: claude plugin install mattpocock-skills@claude-plugins-official. Then run /setup-matt-pocock-skills once in each project. The README also has install lines for Codex, GitHub Copilot, Gemini CLI and other agents.
What does /grill-with-docs do?
Before any code is written, Claude interviews you about the problem. It asks numbered questions, each with a recommended answer worded so that "yes" accepts it. In Matt's session that was about 40 questions. The file itself is seven lines with one instruction: call two other skills, grilling and domain-modeling.
Can I use these skills if I don't write code?
One of them, yes. The /grill-me command runs the same interview for anything: a business plan, a big purchase or a career move. You describe a problem, not a solution, and Claude asks questions until nothing is left assumed. The rest of the road is built for software projects.
Do I need all seven skills for every task?
No, and Matt says so himself. If the change is really small, in his words, "you can probably just one-shot the thing." The full road is for changes big enough that a wrong guess is expensive. If you only try two, start with /grill-with-docs and end with /retro.
What did /retro find in Matt Pocock's 21,000-line run?
He left 12 review comments, and the retro traced all 12 to one root cause. The agents were copying patterns that his own code and docs already showed, one of them 2,078 times in 698 files. So the fix was not another instruction. The retro file says that for a mechanical mistake, you build a check that fails, like a lint rule or a test.