It Ain't Broke: Why Software Fundamentals Matter More Than Ever — Matt Pocock, AI Hero @mattpocockuk
TL;DR
Specs-to-code breaks down when you stop reading the code — Matt Pocock says repeated “just regenerate from the spec” cycles produced progressively worse output, basically “vibe coding by another name,” because software entropy still applies.
Old software books turned out to be the best AI coding curriculum — he leans on John Ousterhout, The Pragmatic Programmer, Frederick P. Brooks, Domain-Driven Design, and Kent Beck to argue that code quality, shared understanding, and system design matter more in the AI era, not less.
His viral 'grill me' prompt fixes a core AI failure mode: no shared design concept — the skill tells the model to interview you relentlessly, sometimes with 40 to 100 questions, until human and model actually share the invisible idea of what they’re building.
A ubiquitous language makes AI less verbose and more accurate — borrowing from DDD, he has AI scan the codebase and generate a markdown glossary of terms, which he says noticeably improves planning and even shortens the model’s internal reasoning traces.
TDD and tight feedback loops are the speed limit for AI agents — static types, browser access, and automated tests help, but his bigger point is that LLMs “outrun their headlights” unless test-driven development forces small, verifiable steps.
Deep modules are the architecture pattern that makes AI useful without frying your brain — instead of sprawling shallow modules, Pocock wants simple interfaces around dense implementations, so humans can design and test boundaries while delegating internals to AI.
The Breakdown
The comforting thesis: your old skills didn’t expire
Matt Pocock opens with a deliberately reassuring message for anxious developers: software fundamentals matter “more than they actually ever have.” He frames the whole talk around building a course called “Claude Code for real engineers,” and the headache of teaching AI coding in a world where the tools change every week.
Why specs-to-code keeps degenerating into garbage
He takes aim at the specs-to-code movement: write a spec, generate code, never inspect the code, then just tweak the spec and rerun. He tried it himself and got exactly the same result many people in the room had seen — each pass made the code worse until it turned into garbage. That led him to John Ousterhout’s definition of complexity and The Pragmatic Programmer’s idea of software entropy: bad code is code that’s hard to change, and repeated AI edits accelerate that decay if no one is managing design.
“Code is cheap” is the wrong idea in the AI era
Pocock directly rejects the slogan that code is cheap. His argument is sharper: bad code is the most expensive it’s ever been, because a messy codebase prevents you from capturing the upside of AI, while AI performs extremely well inside a well-structured one. That’s the thesis in one line: better fundamentals mean more leverage from AI, not less.
The “grill me” trick for reaching shared understanding
The first failure mode is simple: the AI didn’t do what you wanted because neither of you fully knew what you wanted. Borrowing from Frederick P. Brooks’ idea of the “design concept,” Pocock says human and model need a shared invisible theory of the thing being built. His fix is a prompt-skill called “grill me” — now sitting at roughly 13,000 GitHub stars — that pushes the AI to ask dozens of questions, sometimes 100, until that shared understanding exists.
DDD gives AI a shared language instead of endless rambling
The second failure mode is AI verbosity and misalignment. He compares it to the gap between developers and domain experts, then reaches for Domain-Driven Design’s “ubiquitous language”: a shared vocabulary reflected in both conversation and code. His corresponding skill scans the codebase and builds a markdown glossary, which he keeps open while planning; he says it dramatically improves alignment and makes the model think less noisily.
TDD stops models from outrunning their headlights
Next comes the classic frustration: the AI built the right thing, but it still doesn’t work. Pocock recommends the obvious feedback loops — TypeScript, browser access for frontend work, and automated tests — but says LLMs still misuse them because they attempt too much before checking anything. Quoting The Pragmatic Programmer’s “the rate of feedback is your speed limit,” he argues that TDD is especially valuable now because it forces the model into small, testable steps.
Deep modules are the architecture AI can actually navigate
From there he connects testability back to architecture. Good codebases are easier to test, and Ousterhout’s “deep modules” — lots of hidden functionality behind simple interfaces — are his preferred shape. AI tends to generate sprawling shallow-module systems full of tiny blobs and tangled dependencies; by contrast, deep modules give both human and model clear boundaries, making the code easier to explore, test, and evolve.
Design the interface, delegate the implementation
His closing practical idea is what he says has saved his brain: treat many modules as gray boxes. You design the interface, specify module changes in the PRD, test from the outside, and let AI handle much of the implementation inside the boundary — except in critical areas like finance where you still inspect more closely. He ends with Kent Beck’s line, “Invest in the design of the system every day,” and turns it into the talk’s final verdict: specs-to-code divests from design, but strong engineers still need to be the strategic layer above the tactical AI programmer.