"Software Fundamentals Matter More Than Ever" — Matt Pocock

Matt Pocock, a developer educator known for his TypeScript teaching and the Claude Code for Real Engineers course, argues that classical software engineering fundamentals have become more critical — not less — in the age of AI coding agents. Drawing on 18 months of teaching developers to build with AI, he identifies six concrete failure modes and explains how decades-old principles resolve each one.

Pocock opens by challenging the "specs-to-code" movement, which proposes writing a specification, generating code from it, and iterating only on the spec rather than the code. In practice, he found that repeated regeneration produces progressively worse output — a manifestation of software entropy, as described in The Pragmatic Programmer. His core thesis: "bad code is the most expensive it has ever been," because a hard-to-change codebase prevents teams from capturing the productivity gains AI can offer. Good codebases therefore matter more than ever.

For failure mode one — the AI not understanding what you actually want — Pocock references Frederick P. Brooks' concept of the "design concept": the shared, invisible mental model of what is being built. He created a Claude Code skill called "Grill Me" that instructs the AI to "interview me relentlessly about every aspect of this plan until we reach a shared understanding, walking down each branch of the design tree." The skill's GitHub repo attracted roughly 13,000 stars. He argues this shared-understanding phase is more valuable than Claude Code's default plan mode, which rushes to produce an asset rather than reaching genuine alignment.

For failure mode two — AI verbosity and misaligned vocabulary — Pocock turns to Domain-Driven Design (DDD) and its concept of a ubiquitous language: a shared glossary used consistently across developer conversations, domain expert discussions, and the codebase itself. He built a skill that scans a codebase, extracts its terminology, and generates a markdown file of definitions. Feeding this file to the AI at planning time reduces verbosity and keeps implementation aligned with intent.

For failure mode three — code that doesn't work — he advocates test-driven development (TDD), citing The Pragmatic Programmer's principle that "the rate of feedback is your speed limit." Without TDD, LLMs "outrun their headlights," producing large batches of code before checking correctness. TDD forces small, deliberate steps.

Failure modes four and five relate to testability and cognitive load. Pocock draws on John Ousterhout's A Philosophy of Software Design to distinguish deep modules (substantial functionality behind a simple interface) from shallow modules (many tiny files with complex interfaces). Shallow codebases — which AI tends to produce by default — are hard for the LLM to navigate and hard for humans to hold in memory. He built an "Improve Codebase Architecture" skill that refactors shallow module clusters into deep modules with clean boundaries. This design pattern also enables what he calls "gray box" delegation: the developer designs the interface, the AI implements internals, and tests run against the boundary. Citing Kent Beck, he frames this as "investing in the design of the system every day," the opposite of the specs-to-code approach.

Pocock closes by reframing the developer's role: AI is the tactical "sergeant on the ground" making code changes, while the engineer must operate at the strategic level — maintaining the ubiquitous language, owning module interfaces, and stewarding system design. His skills and training are available at aihero.dev and github.com/mattpocockskills.