Ship like the best engineers: Matt Pocock's AI workflow

AI The Hype Kevin · 9m 05s · Watch on YouTube · 21 sources

Decision Card

Effort: An afternoon: install the plugin with claude plugin install mattpocock-skills@claude-plugins-official, run /setup-matt-pocock-skills once in a repo, then type /grill-me on one real feature idea and ride the full grill → to-spec → to-tickets → implement → code-review → retro loop (2–4 hours including the ticket builds).

Honest take: The video’s central number is softer than it sounds: the “150,000 token smart zone” rule for sizing tickets does not appear anywhere in the actual to-tickets skill (which only says “fit in a single fresh context window”), and Pocock’s own write-up calls the figure “hotly debated” and moving. The video also gives a one-sided account of the “waterfall” criticism: the Uncle Bob exchange is only asserted, not shown, and the “spec is deleted after shipping” rebuttal does not answer whether a 46-question interview is cheaper than just iterating on a prototype.

Concrete next steps:

  • Read the two files the whole workflow hangs on (10 min): the one-line grill-me and the ~30-line grilling skill at https://github.com/mattpocock/skills. Decide whether you want the plugin or just those four sentences in your own CLAUDE.md.
  • Try /retro on an existing long session before adopting anything else (20 min). It is suggest-only, so it is the lowest-risk skill to test, and it tells you whether your repo has the “agent spent 10 minutes finding the billing code” problem.
  • Compare against the upstream show-me skill at https://github.com/humanlayer/skills (15 min) if PR descriptions are your pain point. Pocock’s pr is an adaptation; the original may fit better if you do not want the merge-danger section.
  • Skip if your work is mostly single-session changes where you already know the decisions. Pocock’s own guidance is that anything small enough for one session gets planned in one session, and the full spec/ticket pipeline only pays off on multi-ticket features.

TL;DR

Kevin walks through Matt Pocock’s open-source skills workflow (v1.3, shipped October 4, 2026): an interview skill forces every product decision onto the human before code exists, then spec, tickets, TDD, two-reviewer code review, a PR description with a “merge danger” call, and a session retro. The thesis is that agents fill unstated decisions with guesses, so the human’s remaining job is to make the decisions explicit; the plumbing is almost trivially small.

Key Points

  • A one-sentence prompt like “let users pause their subscription” silently commits the agent to guesses about billing, pause duration, the already-packed order, and email copy. 00:17
  • grill-me inverts the flow: the agent interviews you, mapping a decision tree and asking the “frontier” (decisions whose parents are settled) in numbered rounds with recommended answers. Facts are delegated to a helper agent; decisions stay with you. 01:02
  • Typical question counts: about six for a small change, around twenty for a normal one, once forty-six while recording a lesson. 01:43
  • grill-with-docs maintains a GLOSSARY.md in the repo during the interview (pause vs. skip, words to avoid), and wait-what rephrases the agent’s last message using that glossary. 02:00
  • Questions that can’t be settled by talking (UI layout) go to a throwaway prototype session with several deliberately different screens; you click and pick. 02:41
  • to-spec writes the problem, fix, and numbered user stories after agreeing the test “seams” (ideally one); the spec is filed as an issue labelled ready for agent. 02:57
  • to-tickets slices the spec into vertical, dependency-linked tickets each sized for one fresh session, justified by the “smart zone” idea that reasoning degrades past roughly 150k tokens. 03:29
  • implement-spec (new in 1.3) runs one agent per ready ticket in its own worktree and lands everything on one branch; TDD is red/green only, since the agent “never, ever, ever” refactored. 04:16
  • code-review hands the diff to two fresh agents: one against the spec, one against coding standards plus Fowler code smells. The implementing agent never saw the standards on purpose. 04:48
  • retro reads the session and suggests environment fixes (instructions, lint rules, checks). Pocock refuses to automate it because a self-fixing agent chases false positives. 05:43
  • Real-world example: a 41-user-story spec became 10 linked tickets in four minutes and merged as 28 commits, ~14k lines, a bit over two hours after the spec. 06:34
  • Sixteen of 27 skills are user-invoked only, so the agent never loads them; the entire set reportedly costs ~660 tokens of context. The grill-me skill itself is one line. 07:46

Notable Quotes

“You wrote one sentence, so it filled every gap with a guess and kept going. Agents are polite like that.” 00:42

“The spec is the destination. The tickets are the journey.” 03:26

“A mistake a machine can spot gets a check, full stop, and the written coding standards keep only the judgment calls.” 06:11

Verified Claims

1. Skills v1.3 shipped on October 4 and graduated implement-spec, pr, and retro. 00:14 Sources: GitHub release v1.3.0, PR #1120 Verdict: Confirmed. Release page is dated 04 Oct; the PR moves all three from in-progress/ to engineering/ and bumps the plugin from 25 to 27 skills.

2. The repo has more GitHub stars than React. 00:11 Sources: mattpocock/skills (307.0k at fetch time), facebook/react (251.8k at fetch time), Digg report of Gergely Orosz’s post Verdict: Confirmed. Roughly 307k vs. 252k as of 2026-10-30.

3. grill-me is one line long and just calls the grilling skill, which is ~28 lines. 08:12 Sources: grill-me SKILL.md, grilling SKILL.md Verdict: Confirmed. Body is exactly Call the Skill tool with "grilling". The grilling file is ~33 lines including frontmatter and blanks, and does describe the frontier, numbered rounds, recommended answers, and sub-agents for environmental facts.

4. grill-me has over a million installs on skills.sh. 08:07 Source: skills.sh/mattpocock/skills/grill-me Verdict: Confirmed. Page shows 1.5M installs.

5. Tickets are sized by dividing estimated tokens by 150,000, the “smart zone” borrowed from Dex Horthy. 03:32 Sources: to-tickets SKILL.md, Pocock’s “What is the dumb zone?” post, agent-brain summary of Horthy’s smart/dumb zones Verdict: Disputed. The skill itself says only “fit in a single fresh context window” with no number. Pocock’s own post gives ~150k but calls it hotly debated and rising. Horthy’s own framing is usually ~40% of the window, not a fixed 150k.

6. The TDD skill dropped its refactor step; refactoring moved to review. 04:34 Source: tdd SKILL.md Verdict: Confirmed. Loop is red → green per seam; refactoring is explicitly assigned to code-review.

7. Code review uses two fresh sub-agents: one against the spec, one against standards plus Fowler smells. 04:48 Source: code-review SKILL.md Verdict: Confirmed. Two parallel sub-agents, fresh context each, reports aggregated without merging.

8. retro only suggests; it turns machine-detectable mistakes into checks and keeps judgment calls in written standards. 05:43 Sources: retro SKILL.md, tenten.co v1.3 write-up Verdict: Confirmed. Skill presents candidates ordered by severity and does not apply them; defaults to building a lint/pre-commit/CI check and reserves CODING_STANDARDS.md for judgment calls.

9. The pr skill is adapted from Dex Horthy’s show-me and includes a merge-danger section. 05:19 Sources: Dex Horthy’s /show-me article, humanlayer/skills, mattpocock/skills issue #1320 (CREDITS link), GitHub release v1.3.0 Verdict: Confirmed. Release notes describe pr as “summary visual, before/after evidence, and a merge-danger call”; the repo’s CREDITS file links show-me to HumanLayer.

10. v1.3 removed the merge-conflict skill because the harness handles it. 07:59 Sources: PR #1120, tenten.co write-up Verdict: Confirmed. Removed with commit message “No longer needed”; the secondary source gives the rationale that frontier harnesses resolve conflicts natively.

11. Uncle Bob argued the “waterfall” case on Pocock’s live stream. 07:10 Source: Podwise listing of “LIVE: Uncle Bob on Software Fundamentals in the Age of AI” (19 Aug 2026) Verdict: Inconclusive. The stream exists, but no source I found confirms waterfall was the topic of pushback.

12. The installed skill set costs about 660 tokens of context. 07:52 Source: Claude Code issue on disable-model-invocation hiding skills Verdict: Inconclusive. The mechanism (user-invoked skills are stripped from the agent’s view) is confirmed and the README reports 16 user-invoked of 27, matching the video. The 660-token figure itself could not be sourced.

Tools, Papers & Standards Mentioned

Follow-up Questions

  1. Does front-loading 20 to 46 decisions in an interview actually reduce total rework compared with a prototype-first loop, and on what feature sizes does the break-even fall?
  2. The code-review skill withholds coding standards from the implementer on purpose. Does a reviewer-only standards pass catch more or fewer violations than giving the implementer the same list, and at what token cost?
  3. What is a defensible, model-specific “smart zone” threshold today? Horthy frames it as ~40% of the window, Pocock as ~150k and rising; a reproducible benchmark on current frontier models would settle the ticket-sizing rule.

Sources