LLMs generate code 12x faster than you can type, and they’re getting better every month. Some engineers call it slop. Others are shipping production features at breakneck speed. So which is it—revolution or really fast tech debt? The answer depends on something that has nothing to do with the AI: whether you actually know your patterns, your boundaries, and your architecture. Because code was never the bottleneck. And now that it’s basically free, that’s more true than ever.
Description
There’s a weird divide in software engineering right now. One group looks at AI-generated code and sees unusable garbage that’ll haunt codebases for years. Another group is absolutely blown away, shipping features faster than ever and wondering why anyone still types boilerplate by hand.
The reality? Both groups are right. And the difference comes down to one thing: domain and structure.
In this episode, we break down why LLMs excel in well-documented domains like web development (where we used to copy from Stack Overflow anyway) but struggle in niche areas with sparse training data. We explore the dirty secret nobody talks about: code was never the hard part. Architecture was. Boundaries were. Maintainability was.
Now we have tools that can generate thousands of lines of code in an afternoon. That means you can create a tightly-coupled mess at 12x speed. You can ship features that work today but will take three engineers two weeks to modify six months from now.
The engineers thriving in this new era aren’t the fastest typers or syntax memorizers. They’re the ones who know their patterns deeply—when to use microservices vs modular monoliths, how to define clean boundaries, why TDD isn’t just nice-to-have but a survival strategy. They understand that LLMs have the same context problem as junior developers: show them a tangled codebase where everything depends on everything else, and they’ll write code that compiles but breaks production at 3 a.m.
This is about the fundamental shift happening in software engineering. Your value isn’t in typing anymore. It’s in foresight. In knowing what happens when you scale. In designing systems that are maintainable not just by you, but by AI, by junior developers, by anyone who comes after you.
Because code is cheap now. It’s getting cheaper every month. But the ability to structure systems so they don’t collapse under their own weight? That’s getting more valuable.
Key Topics
- The speed gap: LLMs generate 1200 words per minute vs human typing at 100 wpm, and why this is only the baseline
- Why some engineers see gold and others see garbage: domain matters more than skill level
- The web development advantage: oceans of training data vs niche domains with sparse documentation
- The dirty secret: code was never the bottleneck—architecture, boundaries, and tech debt were (Stripe study shows devs spend 1/3 of time on tech debt, $3T global GDP impact)
- How LLMs are like incredibly productive junior developers: terrible at long-term planning
- Why you need to know your patterns: vertical vs horizontal slicing, domain models, event sourcing, when to use microservices vs monoliths
- Real examples: Shopify’s modular monolith with 2.8M lines of Ruby, Uber’s SOA transition struggles
- The context window problem: LLMs suffer from “lost in the middle” and need clean boundaries to succeed
- Test-driven development as a survival strategy: defining contracts and boundaries that make safe changes possible
- Your new job description: from feature factory to architect, from writing code to designing systems
- Why learning the basics deeply (the why, not just the names) is the only way to keep up
