Code is cheap.
Not because engineering is suddenly easy, but because AI has dramatically reduced the cost of producing code that looks correct.
And that changes the game.
I’m a Director of AI today, but before that, I spent 18 years as a developer. For the past three years I’ve been deep in AI adoption, watching some developers thrive with AI, and watching others get stuck, unsure what their value is supposed to be now. Me included.
Here’s the uncomfortable part: AI doesn’t just “speed you up.”
It multiplies what’s already there.
- If you have strong judgment, clear thinking, and a good sense of what “good” looks like, AI becomes a force multiplier.
- If your judgment is weak, AI helps you ship polished-looking code faster… and quietly makes the overall system worse.
Before AI, gaps were obvious: you got stuck, you had to understand the system, and then you fixed it.
Now? You get an answer in seconds. It compiles. It passes. You ship it.
And that’s exactly how AI can keep developers trapped at mid-level: it covers the very gaps you still need to close.
So if code is cheap now… what skills still matter?
A framework that altered how I view developer value is the Bubble Model
Most developers think their value is the stack they use every day: JavaScript, React, Laravel, Python.
Harsh truth: those “outer bubble” skills are increasingly replaceable by AI. And AI can probably code them better then you.
However, the skills that keep paying off, no matter the language, tool, or trend, are deeper. They transfer. They scale. They let you judge whether AI output fits your system, your constraints, and your business reality.
In the Bubble Model, the six core “deep bubbles” are:
- Security
- Monitoring
- Logging
- Debugging
- Architecture
- Design Patterns
(There are others, sure, but these makes the point clear.)
Let’s break them down in practical terms:
The Six Bubbles (And Why They Matter More in the AI Era)
1) Debugging (Reducing the search space)
Debugging is the skill of shrinking uncertainty:
- form a hypothesis
- trace the flow
- isolate variables
AI can help here, sometimes impressively. But you still need to be able to do it better than the tool, because the real risk is confidently “fixing” the wrong thing.
If your debugging is weak, AI helps you make bad fixes faster.
2) Architecture (Seeing the system’s shape)
Architecture is about boundaries, dependencies, and ownership across the system.
If you can’t see the shape of the system, you can’t evaluate whether AI-generated code actually belongs where it’s being placed, or whether it’s creating long-term coupling and chaos.
If your architecture is weak, AI helps you build cleaner chaos.
3) Design Patterns (When structure helps vs. when it’s junk)
Design patterns are repeatable answers to repeatable problem shapes.
AI knows patterns. AI will suggest patterns. AI will even explain them nicely.
But AI often can’t judge whether a pattern is the right business decision, or whether it’s adding complexity that your product and team don’t need. That judgment is still on you.
4) Logging (Explaining what happened)
Logging makes your system explainable.
When something breaks in production, you don’t want “it should work.” You want evidence: what happened, where, and why.
AI doesn’t live with your system after it outputs code. You do.
5) Monitoring (Knowing when behavior drifts)
AI doesn't care about your app, you have to live with it. Monitoring tells you when the system is changing in ways you didn’t intend, performance regressions, error spikes, unusual latency, creeping failures.
AI can generate features quickly. Monitoring is what keeps those features from quietly degrading everything around them.
6) Security (Defining trust boundaries early)
Security is about validation, access control, and trust boundaries, decisions you make up front, not after the feature ships.
AI will gladly produce insecure code if you don’t guide it.
If code is cheap, the cost moves elsewhere: risk gets expensive.
Why seniors stay valuable (and why “just shipping” stops being enough)
Seniors were never valuable only because they typed code faster.
They’re valuable because they:
- recognize deep, recurring problems early
- can judge tradeoffs under uncertainty
- verify what’s true (instead of trusting what looks good)
- know what “good” looks like across systems, not just files
That’s the shift: in an AI world, value moves up to judgment, problem framing, verification, and risk control.
So how do you build those skills deliberately?
That’s where the Bubble Model becomes actionable.
You can watch the Bubble Model explained in the video at the bottom of the text, or in the PDF on the applicableprogramming.com.
