Presenters
Source
🚀 Why Software Fundamentals are Your Superpower in the Age of AI
Do you feel like your hard-earned engineering skills are losing their value in a world dominated by LLMs? Matt Pocock has a comforting, yet provocative message for you: software fundamentals matter now more than they ever have.
While many believe we are entering a specs-to-code era where we can simply ignore the implementation, the reality is much messier. If you treat code as a disposable byproduct, you fall into the trap of vibe coding. You run the compiler, get garbage, run it again, and get even worse garbage.
The truth? Bad code is the most expensive it has ever been. If your codebase is a mess, AI cannot help you. But if you apply timeless engineering principles, you unlock the full bounty of AI productivity.
📉 The Myth of Cheap Code and Software Entropy 💾
The “specs-to-code” movement suggests that we should only modify high-level specifications and let AI handle the rest. Matt Pocock argues that this approach ignores software entropy—the tendency for systems to drift toward disaster and collapse when changes are made without considering the whole design.
- The Challenge: Every time you prompt an AI to change a codebase without a solid foundation, the code quality degrades.
- The Impact: You end up with a system that is impossible to modify without causing bugs, rendering the AI useless.
- The Core Argument: Code is not cheap. A good codebase is an asset that allows AI to perform at its peak.
🎯 Tip 1: Reach a Shared “Design Concept” with the “Grill Me” Skill 🧠
One of the biggest failure modes in AI coding is misalignment. You have an idea, but the AI builds something entirely different. This happens because you and the AI lack a shared design concept—the invisible theory of what you are building.
To solve this, Matt introduced the Grill Me skill, a prompt that has garnered over 13,000 stars on GitHub.
“Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one by one.”
- The Result: The AI might ask you 40, 60, or even 100 questions before it starts coding.
- The Benefit: This turns the AI into an adversary that validates your logic, ensuring the final output matches your vision.
🌐 Tip 2: Establish a Ubiquitous Language 🛠️
AI often becomes too verbose or speaks at cross-purposes with the developer. To fix this, we look to Domain-Driven Design (DDD) and the concept of a Ubiquitous Language.
Matt developed a skill that scans your codebase and creates a markdown file containing a dictionary of terms.
- How it works: The tool identifies core terminology and organizes it into markdown tables.
- The Impact: By feeding this “source of truth” back to the AI, it uses less verbose language and produces implementations that align perfectly with the domain model.
🏎️ Tip 3: Don’t Outrun Your Headlights—Use TDD 📡
AI has a habit of doing too much at once, which leads to broken builds. In The Pragmatic Programmer, this is called outrunning your headlights. Your rate of feedback should be your speed limit.
- The Tool: Use TypeScript for static typing and give your LLM access to the browser for visual feedback.
- The Strategy: Implement Test-Driven Development (TDD).
- The Tradeoff: Testing is hard because it requires complex decisions about mocking and unit sizes. However, a testable codebase is a good codebase. TDD forces the AI to take small, deliberate, and verifiable steps.
📦 Tip 4: Build Deep Modules, Not Shallow Blobs 🧱
According to John Ousterhout’s A Philosophy of Software Design, we should strive for deep modules.
| Feature | Deep Modules 🟢 | Shallow Modules 🔴 |
|---|---|---|
| Interface | Simple and small | Complex and leaky |
| Functionality | Significant power hidden inside | Very little functionality |
| AI Performance | Easy for AI to navigate boundaries | AI gets lost in dependency hell |
Matt suggests a specific skill: Improve Codebase Architecture.
- The Action: Identify related code and wrap it in a deep module with a clean interface.
- The Benefit: You can treat these modules as gray boxes. You design the interface and delegate the messy implementation details to the AI, saving your cognitive energy for high-level strategy.
👨💻 Q&A: Insights from the Audience 🎤
Audience: Raise your hand if you’ve tried the specs-to-code approach and ended up with garbage. Matt Pocock: (Observing many hands) Exactly. It’s vibe coding. We cannot ignore the code; we must manage its design.
Audience: Does this AI-driven development make you more tired? Matt Pocock: (Many hands go up) It’s knackering! The cognitive load of reviewing AI code is intense. That’s why we need deep modules—so we don’t have to hold the entire implementation in our heads at once.
🦾 Conclusion: Be the Strategist, Not Just the Scripter 🎯
The message is clear: AI is a brilliant tactical programmer—a sergeant on the ground making changes. But a sergeant needs a strategist.
That strategist is you.
By investing in software design every day, using tools like Clojure Code, and mastering fundamentals like TDD and DDD, you ensure that your codebase remains a fertile ground for AI to assist you.
Code matters. Fundamentals matter. Your expertise is the bridge between AI-generated noise and high-quality software.
✨ For more insights and the full library of AI skills, check out the mattpocock/skills repo on GitHub or visit aihero.dev.