The Junior Developer Problem Is More Complicated Than You Think

Rekhi's recent Medium piece "Why Replacing Developers with AI is Going Horribly Wrong" has been making the rounds. A colleague in leadership flagged it to me. I read it. I agree with parts of it — but I think it misses some important nuance.

Worth noting: the author is a student, and the piece reads more as an emotional argument than a technical one. That's not a dismissal — the emotional argument is largely correct. But it's worth separating the real structural problems from the catastrophizing.

Here's my take.

---

We're somewhere on the Gartner Hype Cycle

The disillusionment is already happening. Cloudflare recently announced plans to hire interns at scale. That's not an accident — it's a signal. We may be near the bottom of the trough in terms of open junior positions, but that won't last. What we're watching in real time is the cycle correcting itself.

---

"If you don't hire juniors today, you won't have seniors tomorrow" — well, sort of

This argument is logically clean but built on a shaky assumption: that we'll need senior developers in the same form and quantity as today. We won't.

The role will evolve. Some new mainstream archetype — call it an "orchestrator" — will emerge, with a clear junior-to-senior progression of its own. The pipeline doesn't disappear. It transforms.

---

The institutional memory problem is real

One thing the article nails: AI doesn't know why a decision made in 2019 that looks weird was actually the right call at the time. It doesn't understand implicit contracts between systems that only ever lived in one engineer's head.

This is a genuine, unsolved problem — and it's one reason projects like entire.io are interesting. The idea is to programmatically record architectural decisions as they're made, so the reasoning doesn't evaporate when people leave. Worth watching.

---

"Babysitting code" is the new normal — adapt or leave

The article mourns that developers who loved writing code now feel like they're just reviewing AI output. That feeling is real. But it's not going away.

The harder question is: what does adaptation actually look like? I don't think the answer is keeping juniors busy with manual bug fixes and boilerplate — not least because they won't want to do it. Human laziness is a feature, not a bug. Nobody will voluntarily choose grunt work when they don't have to.

The better path: hire junior developers and let them work the way they actually want to work — with AI as a collaborator, not a crutch.

---

On judgment — the article's strongest point, and where I'd push back

The article's best argument is about judgment. The author's conclusion is essentially: the best engineers are the ones who know when to distrust AI, and that skill only comes from years of writing code manually, making mistakes, and learning from them. A developer who spent three years reviewing AI output hasn't become a senior developer — they've become an experienced reviewer of AI output. Different skill set entirely.

I think this is mostly right, but it assumes a passive reviewer. If you approach AI-generated code with genuine critical thinking — asking "explain this to me," "what tradeoffs did you make and why," "what principles guided this decision" — you can reconstruct much of that learning deliberately. The AI will sometimes confabulate its reasoning, which is exactly why critical thinking matters: you need enough baseline understanding to know when the explanation sounds plausible but wrong.

That's what the new junior orchestrator role should look like: someone who interrogates the output, not just ships it. Judgment can be built this way. It's harder, and it requires intention — which most junior developers reviewing AI code today are not applying.

---

The exodus is real, but the draw isn't what you think

Developers are going freelance. Starting small companies. Moving into adjacent fields. I get it — I feel the pull too. But not because of the slop AI generates. Because of the possibilities it opens up.

That reframe matters. The people leaving aren't fleeing a degraded profession. The sharp ones are running toward something.

---

The junior developer problem is real. The institutional memory problem is real. The identity crisis in the profession is real. But the story isn't simply "AI is breaking software engineering." It's that software engineering is being renegotiated — and the terms aren't set yet.