Everyone Is Building AI to Replace Developers. Nobody Is Building the Plan for What Comes After.

Quick game. Open the launch post for any AI coding tool and count the verbs.

Generates. Refactors. Reviews. Ships.

Now count the sentences about what happens to the humans who used to do all that.

Yeah. Me neither. 🙃

I don't think it's malice, to be fair. Nobody gets a bonus for writing that paragraph. So I'm going to write it here, in public, probably badly, which is the DEV tradition anyway.

The debate we keep having is the wrong one

There are, by my very scientific count, a lot of posts on here called some version of "Will AI replace developers?" Most of them end up in one of two places. Either "you'll lose your job to a dev who uses AI, not to the AI itself," or "AI will just reveal who was coding and who was engineering."

Both are decent lines. I've nodded along to both. But look at what they have in common: they're advice for one person at a time. Get better. Learn the tools. Move up the stack. It's the 2026 edition of "learn to code", which is true, free, and not a plan for anyone except you.

And I'm clearly not the first person to smell this. Aditya Agarwal wrote a headline so close to mine that I had to sit with it for a minute:

So, credit where it's due, the ladder metaphor is out there and it's good. What I want to add is narrower and more annoying: if the plan is nobody's job, why would it ever get made?

Same week I'm writing this: the top post on DEV asks almost exactly this, "We're Building AI to Replace Ourselves. What's the Plan?" It has 233 reactions and 200+ comments. That is not what a settled debate looks like.

Let's skip "replace or don't." Assume only a slice of the work moves to machines. Who owns the plan for the humans standing in that slice?

📉 What the numbers say (and what they can't)

I went looking for actual measurements instead of vibes. Here's what I found, with the catch each one needs. Every single one needs a catch.

Look at that spread. Somewhere between 9% and 25%, depending on who measured what and where. My read: AI is part of the story, not the whole thing. Money got expensive, companies over-hired in 2021, and "AI" is a very convenient phrase to put in a press release.

You may also have seen a scarier figure, something like 67% fewer entry-level postings. I wouldn't repeat it. It blends postings with actual hires and I couldn't trace it back to a primary source.

But here's the catch to the catch. Even the small numbers matter, because of the shape they describe: keep the seniors, give them better tools, quietly stop buying juniors.

🧱 The part I can't shake

I can live with the job-market debate. The apprenticeship problem is what gets me.

Elvis Sautet made the point well in his post on AI users versus the unemployed: the tedious stuff is how you became a senior. The boilerplate, the small mistakes, the debugging session where you finally learn what the error was hiding. If an agent does all of that now, where does the next person get their reps?

Think of seniority as compressed tedium. Years of small, boring, slightly painful tasks, boiled down into taste. Take away the tedium, keep the job title, and you get engineers with the label and a thinner base underneath.

It gets worse, because what we ask seniors to do with AI is mostly review. Reviewing generated code well takes exactly the judgment you only build by writing a lot of code and being wrong about it. We're shrinking the supply of the skill we're about to need more of.

Here's my napkin math for it. Treat it as a cartoon, not a forecast:

seniorst+7≈juniors hiredt×share who stay and grow \text{seniors}{t+7} \approx \text{juniors hired}{t} \times \text{share who stay and grow}

The savings from not hiring show up this quarter. The bill shows up around year seven. Guess which one makes it into a planning meeting.

Not everyone buys the doom, and they've got a point. Ali Karbasi argues @alikarbasicom the junior role is changing rather than dying, and that juniors who learn alongside the tools can end up stronger:

I think he's right about the ones who do. My worry is the ones who never get the chance to start.

🤝 So who owns the plan?

Everyone here is behaving rationally. That's the whole problem.

Nobody in that table is a villain. Nobody in that table is responsible for the gap, either. That's what "nobody is building the plan" looks like in real life. It looks like a table where everyone is fine.

🛠️ A small plan that doesn't need anyone's permission

I can't fix an industry in a blog post. (I checked. It doesn't fit.) But there's a version of this that works at the scale of one person or one team, and it's cheap.

If you're early in your career, keep your reps on purpose. Pick one task a week and do it with the agent off. Then run the agent on the same task and diff the two. The gap between them is your lesson, and it beats any tutorial because it's your problem in your codebase.

If you lead a team, write it down. Here's a policy file I made up as a starting point. It's an example, not a standard:

# team-ai-policy.yml (example, adapt freely)
juniors:
  agent_free_tasks_per_sprint: 1      # a real bug, full ownership, no agent
  walkthrough_with_senior: weekly     # explain why the diff looks the way it does
seniors:
  protected_mentoring_hours: 2        # on the calendar, not "when there's time"
reviews:
  ai_authored_prs_require: "ahumanwhocanexplaineverychangedline"

And if YAML feels like too much ceremony, change your PR template instead. This is the whole diff:

## Before you request review
  Tests pass
+ I can explain every changed line without reopening the agent chat
+ A human other than me checked the *logic*, not just the formatting

That last line matters more than it looks. If nobody on the team can explain a change, the team doesn't really own it. It just happens to be deployed.

Press Ctrl + C on this snippet and run it anywhere you like. The point isn't the output, it's watching what a single skipped year of hiring does seven years later.

// Toy model. Every number here is made up so you can poke at it.
const yearsToSenior = 7;
const staysAndGrows = 0.5; // share of juniors who stick around and level up

function seniorsReady(year, hires) {
  // hires: { [yearHired]: howManyJuniors }
  return Object.entries(hires)
    .filter(([y]) => Number(y) + yearsToSenior <= year)
    .reduce((sum, [, n]) => sum + n * staysAndGrows, 0);
}

console.log(seniorsReady(2033, { 2024: 10, 2025: 10, 2026: 0 }));  // 10
console.log(seniorsReady(2033, { 2024: 10, 2025: 10, 2026: 10 })); // 15

Skip one year of hiring and 2033 has a third fewer seniors than it could have. Skip three years and it gets ugly fast.

If you hire, count the total cost. A junior who's slower for six months and becomes your mid-level in two years is cheaper than fighting over scarce mid-levels later. IBM has been reported in the business press to be tripling its US entry-level hiring this year, after rewriting those job descriptions around the work AI is bad at. I can't verify the details myself, but the direction is interesting.

Here's a short list you can steal for Monday:

Then the plan costs you a few hours a month and you've kept a healthier team. That's the argument for it: it pays off in either world.

There's also some evidence the clean "replace the humans" pitch is harder in practice. In an August 2026 investigation, Reuters reported on Meta's internal restructuring effort, "Project OT," built around an AI-native model with smaller groups of employees, and described how it ran into an employee revolt and fell apart. One company isn't a trend line. It does suggest the plan looks tidier in a slide deck than in a real org chart.

🔮 Where I land

I don't know how this ends. Anyone who tells you they do is selling a course.

What I do believe is that "AI replaces developers" and "AI changes nothing" are both a little lazy, because each one lets us skip the dull, human, unglamorous work of deciding how people learn to be good at this once the easy reps are gone.

Others are already poking at answers. One proposal I liked treats juniors as verification engineers, people who learn by checking what the machine produced, and I'd honestly read it before you read mine:

💬 Your turn

Here's the question I actually can't answer, so I'd love your take:

If your team stopped hiring juniors tomorrow, who would your seniors be in 2033?

Tell me below 👇

Want more voices on this? The comments on Nazar Boyko's pipeline post are worth the scroll.

📚 Related reading on DEV

• 

  , AI killed the junior dev ladder. Nobody has a plan for what's next.

• 

  , The Junior Developer Isn't Extinct, They're Stuck Below the API

• 

  , 2026: AI Users vs The Unemployed

• 

  , Will AI Replace Developers?

¹ Harvard figure as summarized in secondary write-ups, not the original paper — worth verifying there before you quote it elsewhere. The Stanford figure above also varies by write-up (some count from late 2022, some from 2024); I went with the earlier framing.