AI was supposed to help juniors shine. Why does it mostly make seniors stronger?

The question “Will coding be taken over entirely by AI?” has been asked to death already, and people keep trying to answer it. I’m not sure there’s anything truly new to say, but I want to share my own observations.

The early narrative was that companies would need fewer seniors, and juniors together with AI could produce quality code. At least that’s what I kept seeing. But now, partly because AI hasn’t quite lived up to the hype, it looks like what companies actually need is not junior + AI, but senior + AI.

Why?

Let’s look at where AI is good and where it falls short in coding.

Where it helps

• Cranking out boilerplate and scaffolding
• Automating repetitive routines
• Trying out different implementations
• Validating things quickly thanks to fast iteration
• Shipping features fast, as long as you know what you want

And who benefits most from that? Usually seniors. In the hands of a junior, these things are harder to turn into real value. Still possible, but much tougher.

Where it backfires

• Code review: AI can produce useful reviews, but it still struggles with reasoning reliably around edge cases. And AI-generated code tends to create exactly the kind of edge cases that need experienced judgment.
• Bad prompts: Who writes good prompts? Usually the people who actually understand what they’re building. If someone lacks the underlying knowledge, they might still get okay-ish results, but without proper checks in place that can easily turn into bugs and headaches.
• Architecture: I still wouldn’t trust AI to own architecture decisions without experienced review. It can suggest reasonable structures, but knowing which trade-offs matter in a specific system still requires context and judgment.
• Code quality: Choosing the right abstractions, applying patterns where they actually fit, and keeping code clean and context-appropriate is still uneven.
• Security: Security problems become especially dangerous when nobody involved can properly evaluate the generated code. This is not unique to juniors, but less experienced developers are more likely to miss subtle issues.
• Wrong learning: If someone can’t really evaluate the code, they may not realize what’s wrong with what AI produces. Inside a company, that can mean creating problems instead of value.

There are more examples, but the main point is this: AI is not really a threat to senior developers yet. It may even be the opposite. And this is not about criticizing juniors. It is about not throwing them into risky situations with unrealistic expectations.

Where we should use AI

• Fast prototyping: Great for trying out an idea quickly.
• Speeding up routines: Probably the most valuable use. Automate the things you already know well and repeat often.
• Multi-disciplinary work: Filling gaps in your knowledge, suggesting useful methods or libraries, and helping connect the dots when multiple domains collide.
• Function tests: Simple, repetitive, low-risk code you can easily double-check.

From my perspective, that is still the current state of things. We have to review what AI writes. It is far from perfect, and its outputs are non-deterministic, which is one reason deterministic checks like tests still matter.

But then there is another question: how much should you trust AI to write the tests that verify its own code?

It reminds me of something I tweeted: there was a prompt making AI say “I don’t know” when it didn’t know. My take was: “If such AI says ‘I don’t know,’ you can’t be sure it knows that either.”

Of course, the junior + AI pairing was tempting. It looked cheaper, and it fed the fear that “AI will take our jobs.” But when you compare software to other professions, the field still shows signs of immaturity. In construction, architects design. In software, even the architects are still laying bricks by writing code. Our roles are still not specialized or merit-driven enough, and cost-cutting dominates. That devalues the work and burns people out.

So instead of fully democratizing coding, AI currently seems to amplify experienced engineers more than it levels the field. Expectations did not quite match reality. We will see what happens next. I am optimistic about AI’s future, but in the short run we should probably reset our expectations before they warp any further.

Updated in 2026 for clarity. The original argument is unchanged.