AI coding tools have a well-documented paradox: they help experienced engineers more than beginners. Addy Osmani, who’s watched this pattern up close across thousands of developers, calls it the knowledge paradox — seniors use AI to accelerate what they already know how to do. Juniors try to use it to learn what to do, and the results diverge sharply.
I don’t think that’s a footnote. I think it’s the most consequential side effect of AI-assisted development, and almost nobody is planning for it.
I’ve watched this pattern build for over a year. It’s only now becoming impossible to ignore.
Why Seniority Matters More, Not Less
AI generates code fast. It does not, by default, generate code that’s secure, that handles edge cases, or that accounts for how a change ripples through the rest of the system. It optimises for completing the task in front of it — the happy path — because that’s what “done” looks like from inside a single prompt.
Catching what it misses requires someone who already knows what a security gap looks like before it’s exploited. Someone who’s seen a “small” change take down a dependent system, or watched a query that was fine at low volume become a performance bottleneck at scale. Someone who understands the whole ecosystem, not just the function they were asked to write.
That’s senior engineering judgement. AI doesn’t replace it — it depends on it. Every agent framework, every review gate, every “constraints are features” argument I’ve made about the ADLC assumes there’s a human at the top who can tell good output from confident garbage. Take that person away and the system has no ceiling on how wrong it can be while still looking finished.
The Mechanism: AI Doesn’t Contemplate Consequences
This is worth being specific about, because “AI misses edge cases” undersells it. What AI generally won’t do on its own:
- Trace cascading effects. A change that looks self-contained in one service can quietly break a contract another team depends on. AI reasons about the file in front of it, not the graph of everything that calls it.
- Anticipate scale. Code that’s correct at ten requests a second can fall over at ten thousand. AI has no signal that tells it which numbers are real for your system.
- Model the attacker. Security isn’t a checklist AI can complete from the code alone — it requires imagining how someone would misuse the thing you just built.
These are exactly the things senior engineers and quality engineers are trained — through years of being burned by them — to look for automatically. It’s not that AI can’t be told about these risks. It’s that it doesn’t surface them unprompted, and someone has to already know to ask.
The Hiring Trap
Here’s where it turns into an industry problem rather than a personal-growth one. If a senior engineer plus AI can now do the output of what used to take a small team, the economically rational move for a company is to hire the senior and skip the juniors who used to make up that team.
That’s a reasonable short-term decision for any single company. It’s a bad long-term decision for the industry, because today’s senior engineers were yesterday’s juniors who got the reps in — the debugging sessions, the production incidents, the code reviews where someone senior explained exactly why an approach would break in six months. If companies stop hiring for that stage, they’re not saving a cost. They’re quietly discontinuing the only pipeline that produces the seniors AI-assisted teams now depend on more than ever.
I don’t think this is hypothetical. I think it’s already shaping hiring decisions, and it will get harder to see because the damage shows up years later, in a labour market that quietly ran out of people who can do the judgement work AI can’t.
What Responsible Teams Should Do About It
I don’t have a tidy solution, but I have a starting point: stop treating juniors as a cheaper way to produce the same output, and start treating them as the investment that produces your future seniors.
Concretely, that means:
- Deliberately assign the review and debugging work AI creates — not just the fast wins. Reading and correcting AI output is a legitimate way to build the pattern recognition that used to come from writing more code by hand.
- Pair juniors with seniors on the “why,” not just the “what.” The value isn’t showing someone the fix. It’s showing them how you knew where to look.
- Measure judgement, not just throughput. If your review process only checks whether the tests pass, you’re optimising for exactly the thing AI already does well, and none of the thing it doesn’t.
AI didn’t remove the need for seniority. It raised the price of admission, and quietly put the pipeline that produces seniority at risk. Fixing that is a deliberate choice, not a side effect of adopting better tools.
This is a companion piece to Making the Case for QE in the Age of AI — same argument, applied to who gets to build the judgement AI depends on.