The 'Do More With Less' Paradox

If AI does all the junior work… where do the senior engineers come from?

I’ve been sitting with this question for weeks. The consensus in tech is loud and anxious: AI is coming for the junior engineers. It’ll write the boilerplate, fix the small bugs, handle the “easy” work. Fine. Makes sense.

But that consensus immediately spawns a paradox.

If nobody gets the reps, if nobody writes the “dumb” code, how does anyone build the intuition to write the hard code? How do you learn to architect a system if you’ve never seen a thousand bad implementations?

I Used to Think This Was a Pipeline Problem

A gap in the org chart. Simple math.

We lose the bottom rung, and eventually, the whole ladder collapses. We end up with a few hyper-expensive senior architects and a void beneath them, filled only by autonomous agents. It felt like a story of displacement. Elimination. The junior class, gone.

But that framework feels wrong now. Too clean. Too 1-to-1.

It assumes the work stays the same, and we’re just swapping out the worker—human for machine. I don’t think that’s what’s happening.

This Isn’t Elimination. It’s Liberation.

Here’s where I’ve landed—for now.

This isn’t about removing a class of worker. It’s about liberating them from a class of work.

The “junior work” we’re all worried about automating away… is it really the work that builds senior-level intuition? Or is it just friction? Just the drudgery we all had to go through to get to the interesting problems?

I’ve been asking myself: What if we’re conflating two different things? The struggle itself—which maybe does build character—and the toil. The repetitive, soul-draining, context-switching nonsense that eats up 60% of a junior engineer’s day.

We’re not removing the engineer. We’re removing the toil.

What If the Baseline Just… Rises?

What if “Day One” is no longer about learning Git syntax or how to write a for loop?

What if “Day One” is about directing an agent to build a component, reviewing its code for architectural soundness, and testing its assumptions against user needs? What if the new junior engineer isn’t a coder—they’re a systems thinker. A code reviewer. An AI-wrangler.

Their job isn’t to produce the lines of code. It’s to validate the intent behind them.

That frees up the human brain—the most valuable part of the equation—to focus only on the parts that agents can’t, or shouldn’t, touch:

• Stakeholder ambiguity.
• Complex, cross-domain trade-offs.
• Product “taste” and “feel.”
• Ethical implications.

Not the syntax. The strategy.

The Challenge Isn’t the Old Rungs

I used to worry about protecting the ladder. Making sure everyone could climb.

Now I’m wondering if we’re not even using a ladder anymore. What if we’re just… starting on the second floor?

That sounds efficient. Optimistic, even. But it also brings up a real question: What do we lose when we skip the first floor entirely?

Maybe nothing. Maybe just the parts that were always in the way.

Or maybe—and this is what keeps me up—maybe we lose something we can’t name yet. Some intuition that only comes from doing the thing the hard way first.

“This is the real unlock of ‘do more with less.’ It’s not about doing the same amount of work with fewer people. It’s about empowering the same number of people to do exponentially more high-level, strategic work.”

That’s the theory, anyway.

So Where Does That Leave Us?

I’m not sure yet.

We’re not facing a future with no engineers. That much feels true. We’re facing a future where every engineer is liberated to work on the problems that actually require them.

But I’m still figuring out what gets lost in that liberation. Whether skipping the grunt work also means skipping something essential. Whether the new baseline is higher—or just different.

For now, I’m treating this as an experiment. Watching what happens when the toil gets automated away. Watching whether the intuition still develops. Whether the ladder still holds.

Maybe the ladder metaphor was wrong all along. Maybe we’re not climbing. Maybe we’re just… building different things.

I’ll let you know what I find.