Matt Pocock — TypeScript educator, creator of Total TypeScript, and author of the viral "Claude Code Skills" repo — argues that AI coding doesn't make good engineering practices optional; it makes them essential. After 18 months teaching developers to build with AI agents, he presents a systematic framework grounded in classic software engineering books: six common AI failure modes, each paired with a proven engineering principle and a concrete Claude Code skill. The developers who succeed aren't the ones who delegate everything to AI — they're the ones who fall back on fundamentals.
Matt begins by addressing the specs-to-code movement head-on. The premise is seductive: write a specification of how an application should work, use AI to turn it into code, and if there's a problem, go back to the spec — not the code. Change the spec, run the "compiler" again, get new code.
Matt tried it. The audience tried it. The result was universal:
His diagnosis: specs-to-code is just vibe coding by another name. The idea that we can ignore the code and let it manage itself fundamentally misunderstands what makes software systems degrade.
Instead of trying to fix the "compiler," Matt went back to the classics to understand why iterative AI code generation produces progressively worse results.
A Philosophy of Software Design (Ousterhout) — defines complexity as "anything related to the structure of a software system that makes it hard to understand and modify the system." Good codebases are easy to change. Bad codebases aren't.
The Pragmatic Programmer (Hunt & Thomas) — the concept of software entropy describes what Matt was seeing. Every time you make a change to a codebase thinking only about that change — without considering the design of the whole system — the codebase gets worse. Each specs-to-code iteration was increasing entropy.
If you have a codebase that's hard to change, you can't take advantage of what AI offers. AI performs exceptionally well in good codebases. It struggles in bad ones. Therefore: good codebases matter more than ever, which means software fundamentals matter more than ever.
You had a clear idea in your head, but the AI built something completely different. The communication barrier is real.
The Book: Frederick P. Brooks' The Design of Design introduces the concept of the design concept — the invisible, ephemeral shared understanding of what you're building that floats between collaborators. The problem: you and the AI don't share one.
The "Grill Me" skill (from Matt's viral 13,000+ star GitHub repo) turns the AI into an adversary that asks 40, 60, even 100 questions before it's satisfied a shared understanding exists. The resulting conversation can be turned into a PRD or directly into issues for an AFK agent.
Matt's strong opinion: "This is better than the default plan mode in Claude Code. Plan mode is extremely eager to create an asset — it really wants to create a plan and start working. Whereas I think it's a lot nicer to reach a shared design concept first."
You're talking at cross-purposes. The AI uses too many words, and it feels like you're not speaking the same language.
The Book: Eric Evans' Domain-Driven Design and the concept of ubiquitous language — a shared vocabulary where conversations among developers, expressions in code, and conversations with domain experts all derive from the same domain model.
The Solution: A skill that scans the codebase, identifies terminology, and generates a markdown file with tables of all domain terms and their definitions. This file serves as a shared dictionary between you and the AI.
By reading the AI's thinking traces, Matt discovered the ubiquitous language file:
The AI understood what you wanted and built it, but the result is broken. The obvious fix: feedback loops — static types (TypeScript), browser access for front-end apps, and automated tests. But even with these tools, the LLM doesn't use them well. It does too much at once, producing huge amounts of code before thinking to type-check or test.
The Book: The Pragmatic Programmer calls this "outrunning your headlights" — driving too fast for conditions. "The rate of feedback is your speed limit."
The Solution — Test-Driven Development (TDD): TDD forces the LLM to take small steps. Create a test first, make it pass, refactor. The red-green-refactor cycle prevents the AI from generating mountains of untested code.
TDD sounds great in theory, but testing is genuinely hard. How big a unit do you test? What do you mock? What behaviors do you test? All decisions are interconnected. The key insight: good codebases are easy codebases to test.
The Book: Ousterhout's deep modules concept — relatively few, large, deep modules with simple interfaces, not shallow modules with complex interfaces.
A codebase full of deep modules is structured inside clear boundaries with interfaces on top. These interfaces are easy to test — you test at the boundary, verify through the interface, and you're done. This is a codebase that rewards TDD.
The Solution — "Improve Codebase Architecture" Skill: Explore the codebase, find related code scattered across shallow modules, and wrap it in deep modules with clean interfaces.
Everything is working — feedback loops are firing, code is shipping faster than ever. But you're exhausted. A shallow-module codebase makes it harder for both the AI and your brain. A deep-module architecture simplifies this by letting you treat modules as gray boxes.
The Solution: For non-critical modules (not finance, not security-sensitive):
Whenever touching code, planning, or prompting, you need to be aware of the modules in your application. The module map needs to be part of your ubiquitous language. It needs to be built into your planning skills. Matt's PRD skill explicitly includes module changes and interface modifications.
The Book: Kent Beck — "Invest in the design of the system every day."
This is the fundamental difference between specs-to-code and what actually works:
The strategic level requires software fundamental skills that have been around for 20+ years:
All skills mentioned are available in Matt's GitHub repo (mattpocock/skills, 13,000+ stars): Grill Me, Ubiquitous Language, TDD, Improve Codebase Architecture, and Write a PRD.
