Matt Pocock's 3 New Skills Close the AI Coding Loop

0:00Matt Pocock (the TypeScript educator whose skills have become a de-facto standard for disciplined AI-assisted coding) shipped a new version of his skills — and three of the additions close the loop of the AI software-development life cycle. Eric Tech walks through what each one is, how it works, and where it sits in the workflow.

Recap: the existing skills

0:23To place the new ones, a quick recap of the pipeline already in place:

• grooming — collect as much context as possible before the agent builds anything (higher accuracy).
• spec — convert everything agreed in grooming into a proper plan.
• ticket — break that plan into tickets, sorted by feature, not by layer, so each ticket is implemented by a single agent and the context window stays protected.
• /implement — test-driven implementation.
• code review — a fresh context window, following the 12 refactoring patterns from Martin Fowler's Refactoring.

/implement-spec

2:32The first new skill solves a real gap: after you convert a spec into tickets, you'd previously have to manually process those tickets one by one. /implement-spec takes the spec and tickets, organizes the tickets by dependency (dependency-free ones first), and starts multiple AI agents working in parallel worktrees — then merges everything into a single branch. You can think of it as bundling the TDD skill, the code-review skill, and several parallel worktrees into one command. It's the "make many agents build it at once" step.

/pr — proofs, risk & trust

3:39Writing code is no longer the bottleneck — reviewing the flood of PRs an AI produces every day is. /pr makes each pull request reviewable in seconds, structured into three sections:

• Summary — rendered as diagrams, not walls of text, so you see relationships at a glance instead of reading through everything.
• Evidence — did it actually improve performance? screenshots, passing tests, proof it works — rather than "should be fine."
• Merge danger — if this breaks in production, what's the impact? can you roll back? what's the blast radius?

5:27The point of laying out proofs and worst-case scenarios up front: a small, easily-reversible change can just go through; a big, hard-to-redo change is when you stop and have a human actually check. His version of the skill isn't gospel — Eric notes you'd tailor it (especially if you're not from a technical background, strip the jargon) so it makes sense to your team.

/retro

7:59Shipping the feature isn't enough if the AI keeps repeating the same mistakes. /retro looks back over the entire conversation and improves two things — context and guardrails:

• Context — if the agent wastes time hunting for the right files, /retro proposes an AGENTS.md listing key files and where to find them, so it doesn't scan everything. It also trims redundant, overly-long parts of the system prompt.
• Guardrails — fixed rules the agent follows: APIs it shouldn't call, import styles, wrong folders — often encoded as lint rules to enforce consistent code taste and a coding standard.

9:05One important caveat Pocock himself gives: don't turn this on as autopilot. Run it periodically, and keep a human in the loop to approve the changes /retro proposes — otherwise Claude treats everything it sees as nitpicking and the project shifts from building features to endless self-improvement.

The full loop

9:53Where each new skill sits in the SDLC: /implement-spec between the tickets and code review, /pr after code review to make review fast for humans, and /retro after that — closing the circle so the next feature or bug fix is more efficient than the last. The whole thing is one continuous, improving loop rather than a one-shot build.

Claims checked

Sources & further reading