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.
| Source | What it found | Why you should squint |
|---|---|---|
| Stanford Digital Economy Lab, as reported by LeadDev | Early-career US software dev employment fell by nearly 20% since late 2022 | Observational, so it can't separate AI from rate hikes and post-pandemic over-hiring |
| SignalFire, State of Talent 2025 report | Entry-level hiring at the 15 biggest tech firms fell 25% from 2023 to 2024 | Big firms only, one year |
| Harvard study on generative AI adoption1 | Junior employment dropped roughly 9-10% within six quarters of a company adopting generative AI | I'm working from summaries, not the paper itself |
| Irish Times, Oct 14 2026 | Entry-level hiring in AI-augmented jobs fell 16.2% year on year in Q2, vs 10.8% for those jobs overall | One country, one quarter |
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:
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.
| Who | Optimizing for | What falls through the crack |
|---|---|---|
| Companies | This quarter's cost | The pipeline of future seniors |
| Juniors | Getting hired at all | A way to build depth when the agent takes the reps |
| Seniors | Output (which AI just raised) | Time to mentor anybody |
| Schools and bootcamps | The curriculum cycle | Feedback from a market that moves faster than they do |
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: "a human who can explain every changed line"
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. Skip one year of hiring and 2033 has a third fewer seniors than it could have. Skip three years and it gets ugly fast.Want to play with the pipeline math? (toy model, every number is invented)
// 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
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.But what if the whole replacement story is just hype?
🔮 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?
1 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.
Top comments (34)
Reflect to a title: Mostly I build software for human first mentality Terminal is your Friend |> ; Hexaw the programming language, plus above these I created a game which is courious about Singularity.
Do not miss my invite to join a rebellion request!
That human-first approach is probably more important than ever in this conversation. The tools and languages are interesting, but we shouldn't lose sight of the people behind the work. I'll take a look at the rebellion too! 😄
Compressed tedium” is a great way to say it. We learn the most from the boring tasks and the bugs that take hours to fix. If AI does all of that for us, we miss the part that teaches us. I like the idea of doing one task a week without AI. It’s simple and anyone can try it.
I think the tricky part is that those boring tasks don't feel like learning while you're doing them. You only realise later how much you picked up from fixing something that seemed insignificant at the time. That's why I wouldn't want AI to take all of that away, especially from someone just starting out.
Totally agree! When I started learning to code there was no AI to help me, and I still remember the mistakes I made and the bugs I spent hours trying to fix. Those lessons stuck with me because I had to figure them out myself. When AI fixes everything for you, you get the answer but you don’t really remember how you got there. The struggle is what makes it stick with you forever. Great post :)
"Compressed tedium” is the phrase I’ll steal. The part I think gets overlooked is your incentives table: it’s rare to see someone lay out that every actor is behaving rationally and that’s exactly why the gap persists. The other thing that deserves more attention is the PR template line about explaining every changed line without reopening the agent chat. It’s cheap, it’s testable, and it exposes the difference between a team that owns a change and a team that just deployed one.
What I can’t get past is that the plan still has no accountable owner. A YAML file and a template are good habits, but if a generated change causes an incident, “the team owns it” only works if someone can point to the human who reviewed the logic and the rollback path. Otherwise the post correctly diagnoses the gap and then hands the fix to people who already have no time.
I’d be glad to compare notes on this, and happy to connect with others who are trying to make the junior pipeline concrete rather than just debated.
If you want a realistic next step, run it as a one-sprint experiment: every AI-assisted PR gets a named human owner, a short explanation of the logic, and a rollback note; then measure review time and escaped defects against the previous sprint. Small enough to actually finish, and it gives you data instead of a policy file nobody reads.
Yeah, I think the accountable-owner point is fair. I focused more on the process in the article and didn't make the ownership part concrete enough.
I like the idea of making the person responsible for the PR explicit. Not another approval layer, just a clear name attached to the change. If an AI-assisted PR gets merged, there should be someone who can say, “I reviewed this, I understand what it’s doing, and this is how we get it back out if something goes wrong.”
The one-sprint experiment you suggested is probably the easiest way to see if this actually works. A named owner, a short explanation of the change, and a rollback note don't seem like much overhead. Then we can compare review time and escaped defects with the previous sprint and see what the numbers actually say.
I also like your point about making the junior pipeline concrete rather than just debating it. That's really the problem I'm trying to get at with the article. I'd be happy to compare notes as you try this out.
"If the plan is nobody's job, why would it ever get made?" is the line that stuck with me. In India the junior ladder was the main way in for a lot of us: join somewhere, do the boring tickets, learn on the job. If agents eat those first-year tasks, the ladder doesn't get shorter, it loses its bottom rungs. I don't have the plan either, but I'd bet it starts with teams deliberately keeping some easy work for people to learn on, even when an agent could do it faster.
I think that’s the part I’m still trying to work out too. The problem isn’t really that agents can do those first-year tasks faster. It’s that if we remove all of them, we also remove a lot of the situations where someone learns how a real codebase actually works.
I like the idea of deliberately keeping some of that work for juniors, but I’d take it a step further. Maybe the junior still gets the simple ticket, but uses the agent as a tool rather than handing the whole task over to it. They make the change, review what the agent produced, explain the important parts in the PR, and have a reviewer challenge their reasoning.
That way we're not pretending the old workflow is coming back. We're changing what the junior is expected to learn from the work.
The harder part, as you said, is ownership. Someone on the team has to actually decide what work is kept as learning opportunities and make sure it doesn't get squeezed out every time there's a deadline. Otherwise the agent will always win because it's faster.
Your version is better than mine. Keeping the ticket but making the junior explain the agent's change in the PR teaches the part that actually matters, reading code you didn't write and defending it. And you're right about ownership. If nobody's name is on "learning work", the first deadline eats it.
Doing one task a week with the agent off and then diffing against the agent's version is a practical way to keep reps, because the diff shows both what you would not have thought of and what the agent got wrong. The PR template line about someone on the team being able to explain the change is the part I'd adopt first, since it costs nothing. How would you handle a change that only the person who prompted it can explain?
I'd struggle to approve that PR, honestly. If the person who prompted the AI is the only one who can explain the change, that's a sign something is missing. I'd ask them to walk another teammate through the logic without relying on the original prompt. If they can't, I'd rather have them revisit the code than merge something nobody else on the team fully understands.
Asking them to walk a teammate through the logic without the prompt is a good test, because it checks understanding instead of authorship. It also spreads the knowledge, so the change is not owned by one person and one chat history. Have you had a PR where that walkthrough changed the code before merge?
The napkin math hits hard because it's the exact timescale nobody in a planning meeting is incentivized to care about. "Save money this quarter, discover in year seven that all your mid-levels are gone" is not a line that survives a budget review.
Your point about seniors doing mostly review is the part I keep circling back to. Reviewing generated code well requires precisely the judgment you build by writing a lot of bad code first — so we're quietly optimizing away the training set for the skill we're about to need most. That's not a paradox anyone has to intend; it just falls out of everyone acting rationally.
On your closing question: if my team stopped hiring juniors tomorrow, in 2033 the seniors would be whoever came in through an adjacent door — data, ops, QA, support — because those paths still involve real debugging with real consequences. It's a worse pipeline, but not zero. Which is maybe the quiet hope buried in all this: the ladder doesn't have to stay the only way up, we just haven't built the others on purpose yet.
I hadn't really thought about people coming into engineering through those other paths, but it makes sense. QA and support especially can teach you things you don't always pick up when you're just writing code. Maybe the bigger issue is that we're so focused on the traditional junior-to-senior path that we're not putting enough thought into what other paths could look like.
Exactly — and the frustrating part is those paths already work, we just don't formalize them. Support engineers who debug customer issues all day build better diagnostic instincts than most juniors. We just don't call it engineering training, so nobody designs it that way.
Yeah, I think that’s the part I hadn't appreciated when I wrote the article. We may already have some of the alternative paths sitting inside companies; we're just not treating them as part of the engineering pipeline.
A support engineer who spends a year figuring out why real customers are hitting weird failures is learning a lot of the same judgment we'd want from a junior developer. The missing piece is probably giving that experience somewhere to lead — opportunities to work closer to the code, take on more technical problems, and eventually move into engineering if that's what they want.
That actually makes the problem feel a little less bleak to me. Maybe we don't need to recreate the old ladder exactly. We need to stop assuming there's only one ladder in the first place.
The support engineer point is spot on. They see the system at its absolute worst and develop an empathy for the code you can't get from a tutorial. Formalizing that bridge gives you engineers who actually understand customer pain. "Stop assuming there's only one ladder" is a great way to frame it.
Your incentives table describes a classic general-training externality. When a firm pays senior engineers to mentor juniors, it builds portable judgment that another employer can hire away in year three, while cutting junior seats drops this quarter's payroll cost immediately. Because every firm faces the same math, nobody prices the 2033 senior review bottleneck into today's headcount budget.
That dynamic is also why voluntary rules like protected mentoring hours tend to slip under margin pressure. For a policy like your team-ai-policy.yml to hold across firms, junior seats have to pay back inside the first year as structured verification work, or employers have to pair training with retention structures that keep trained mid-levels from walking out the door.
I hadn't thought about the retention side of this as much, but that's a fair point. Even if a company invests in training juniors, there's no guarantee it'll benefit them a few years down the line. I also like your point about making junior roles useful through verification work from the start. That feels like a much more practical way to approach this than simply asking companies to spend more time mentoring.
The 'learn to code' parallel is the sharpest bit in here — true, free, and not a plan for anyone except you. The year-seven line is the one I'd steal for planning meetings though. Genuine question: in your model, who actually owns the plan? The firm has no incentive, the industry has no mechanism — is it just nobody's job by design?
I think that's the uncomfortable part: it mostly is nobody's job right now. Firms are focused on their immediate needs, and there's no real incentive to think seven years ahead. I don't think there's one owner who can fix it, but teams can at least stop treating junior development as something that will somehow take care of itself.
The year-seven point is the one that should worry planning meetings. Cutting junior seats saves money this quarter, and the cost shows up years later as a shortage of people who can review generated code with any real judgment. Since every firm faces the same math, nobody budgets for it.
One reply suggested making junior roles about verification from day one, and I think that is the practical version of a plan. Writing acceptance cases, reproducing the messy edge cases, and explaining a change to a teammate without the original prompt are exactly the skills that turn into review judgment later.
At Ascendra Ventures we see the same thing in fixed-scope work. Typing got cheap, but deciding what done means and proving it did not, and that part still needs people who learned it somewhere.
Of the options in your table, which one do you think a small team could actually start with next month?
I'd start with one real task per sprint where a junior owns the work, then walks a senior through the decisions they made. No elaborate policy needed. Just making that time non-negotiable would be a good start. The hard part isn't introducing the practice, it's making sure it doesn't disappear the moment deadlines get tight.
From a small agency's side, the part nobody plans for is the apprenticeship. Juniors used to learn by doing the boring tickets: the plugin conflict, the broken form, the migration checklist. Those are exactly the tasks AI now drafts in seconds. If we hand all of them to a model, in five years there's nobody who has debugged a real client site at 2 a.m. and knows why the fix worked.
What we're trying: juniors still get the boring tickets, they may use AI, but they have to explain the fix back in plain words before it ships. Slower this quarter, cheaper in three years.
I think this is probably closer to the answer than trying to ban AI from the boring work altogether.
Letting juniors use AI but still making them understand and explain the fix keeps the learning part of the job. The important thing isn't whether the first draft came from them or the model. It's whether they can look at the problem, understand what changed, and explain why that change actually fixes it.
And I really like the “slower this quarter, cheaper in three years” point. That's the trade-off I think teams need to be willing to make. If every easy ticket is given to an agent because it's faster today, we may save time now while quietly making it harder to build experienced developers later.
The interesting part would be seeing how you decide which tickets are worth keeping as learning opportunities. I'd be curious to hear how that works in practice.