Matt Pocock

Sources#

• Full Walkthrough: Workflow for AI Coding — Matt Pocock
• Uncle Bob on Software Fundamentals in the Age of AI

Summary#

Independent TypeScript educator turned AI-coding educator. Runs the AI Hero website. Authored a Claude Code course (recorded at 200K context window; Anthropic launched 1M context the day his course shipped). Built Sandcastle, a TypeScript library for parallel agent loops with Docker-sandboxed git worktrees.

Notable claims and stances#

• Software engineering fundamentals still apply. Central thesis of his AI Engineer 2026 keynote and workshop: "We forget that actually software engineering fundamentals, the stuff that's really crucial to working with humans, also works super well with AI." Cites Brooks's Design of Design, Pragmatic Programmer's tracer bullets, Ousterhout's Philosophy of Software Design, Fowler's refactoring rules.
• Smart zone vs dumb zone. Borrows Dex Horthy (Human Layer)'s framing: LLMs degrade quadratically with context size. Pegs the smart-zone marker around 100K tokens regardless of advertised window (see Context Window Smart Zone).
• Memento metaphor. Each session resets to the system prompt. Prefers clear over compact; compaction creates "sediment" that degrades subsequent work.
• Specs-to-code is wrong. Vibe coding by another name. The code is the battleground, not the spec.
• Grill, then plan, not plan, then read. Uses a relentless-interview skill (grill-me) to reach Brooks's "design concept" — shared understanding with the LLM — before writing the PRD. Doesn't review the resulting PRD because alignment was achieved during grilling (see Design Concept Grilling).
• Tracer bullets over multi-phase plans. Vertical slices that touch every layer beat horizontal layer-by-layer execution; agents naturally code horizontally and need to be pushed (see Vertical Slice Tracer Bullets).
• Kanban over sequential plans. A Kanban with blocking relationships parallelizes; a numbered phase list serializes.
• Deep modules win. Ousterhout's deep-module pattern makes codebases agent-friendly: small interface, lots of behavior, big test boundary (see Deep Modules for Agents).
• Reviewer in fresh context. Implementation in the smart zone leaves the reviewer in the dumb zone if both share context. Always clear before review.
• Push for reviewer, pull for implementer. Coding standards always-in-context for the reviewer; on-demand-via-skill for the implementer.
• Doc rot kills. Delete (or close) PRDs after implementation; old PRDs mislead future agents.
• Own your stack. Doesn't trust spec-kit / open-spec / Taskmaster / similar pre-built stacks because users lose observability when they break.
• Context trajectory, not just context size. Added in his 2026-08-19 interview with Robert C. Martin (Uncle Bob): a session acquires a direction early and everything after inherits it — "if you get it to say, okay, maybe we should test the UI here, then every single time it will test the UI again, no matter how many changes you get it to make. And the only way to clear the trajectory is to clear the context window." He uses it to justify role-scoped agents on a basis other than skill: an implementer's trajectory ("just get it working") and a hardener's ("100% coverage") are incompatible and cannot share a window. Martin accepts the framing and supplies the illustration — a bystander mentioning a soap opera near a conversation about coffee, after which every coffee answer is about the soap opera.
• Steering vs. mechanism. His own terminology for the split the same interview turns on: piling rules into CLAUDE.md/AGENTS.md is steering; a checker the agent must satisfy is a deterministic mechanism. He puts more steering on the reviewer than the implementer because the reviewer's task is less constrained and it already has the diff (see Latent vs. Deterministic Space).
• The reading asymmetry. "If you send [an agent] something, they read it. Which is very different to humans" — he puts a human's hit rate on a long spec at 20%, "5% maybe," and Martin completes it in the other direction: the things agents write, humans don't read. Neither draws a conclusion; it is the cleanest statement in the corpus of why document-mediated workflows behave differently in each direction.

Tools, skills, primitives he uses#

• grill-me skill — relentless interview before any plan
• write-a-PRD skill — destination document, never read after creation
• prd-to-issues skill — vertical slices into independently grabbable Kanban tickets
• improve-code-base-architecture skill — finds shallow-module clusters, proposes deep-module refactors
• Ralph Wiggum loop — bash once.sh runs Claude with full backlog as context, repeats
• Sandcastle — TypeScript orchestrator: per-issue Docker work tree, parallel implementer agents (Sonnet), reviewer agent (Opus), merger agent
• Status-line token-count widget — "essential information on every coding session" (knows when nearing dumb zone)

Workflow shape (his diagram)#

Idea → grill → research/prototype → PRD (destination) → Kanban (journey, vertical slices) → AFK loop (implement → review → merge → loop) → human QA → team review

The first half is human-in-the-loop; the AFK loop handles implementation with no human present; QA is the place where human taste re-enters the system.

Key quotes#

• "If your code base doesn't have feedback loops, you're never ever ever going to get decent AI decent output out of AI."
• "I needed to reach a shared understanding. I needed an asset, I didn't need a plan, I needed to be on the same wavelength as the AI."
• "Bad code bases make bad agents."
• "There are two essential documents that we need: a document that documents the destination, and a document that documents the journey."

Connections#

• Context Window Smart Zone — his clearest pedagogical framing of the constraint
• Design Concept Grilling — the grill-me skill is his
• Vertical Slice Tracer Bullets — applies Pragmatic Programmer to agent task decomposition
• Deep Modules for Agents — applies Ousterhout to agent-friendly codebases
• Agent Loop Pattern — Ralph loop is his canonical example
• Harness Shrinkage as Models Improve — counterpoint: he sees harness as still important even with strong models, but agrees implementation can go fully AFK
• Agentic Technical Debt — his deep-modules + grill-me + Sandcastle stack is the practitioner-pragmatist version of the same defense Anthropic prescribes for founders via CLAUDE.md
• Robert C. Martin (Uncle Bob) — his 2026-08-19 interview subject, and an independent arrival at "bad code bases make bad agents" from fifty years the other side of it
• Spec-Driven Development as the New Waterfall — his standing "specs-to-code is wrong" position, given a lineage and an economic argument by Martin, and where he proposes persistence as the definitional test

Sources#

• Full Walkthrough: Workflow for AI Coding — Matt Pocock — AI Engineer World's Fair workshop, 2026-04-24
• Uncle Bob on Software Fundamentals in the Age of AI — as interviewer, 2026-08-19 livestream with Robert C. Martin (Uncle Bob) (practitioner-opinion; auto-caption transcript): context trajectory, steering vs. deterministic mechanism, the reading asymmetry, and the 150K smart-zone figure