A VP of Engineering at a Series A fintech posted a single junior full-stack role in April. By the following morning she had 640 applications. She read maybe forty of them before closing the req and doing what three other founders in her Slack group had already done that quarter: she gave the ticket to a senior engineer and told him to run it through Cursor.
Nobody made a villainous decision in that story. Every choice was individually reasonable. Six hundred and forty resumes for one role is not a hiring pipeline, it is a flood, and a $20-a-month AI subscription genuinely does more useful work per dollar than a graduate who needs eight months of ramp time. But multiply that reasonable decision by every engineering team that made it this year, and you get something that looks a lot less reasonable from a distance.
The Math Everyone Ran Separately
The calculation is not complicated, which is exactly why so many teams ran it independently and arrived at the same answer. A junior developer costs somewhere between $70,000 and $110,000 a year in the US, needs real onboarding time before shipping anything without heavy supervision, and produces code a senior engineer still has to review line by line. An AI coding tool costs less than a team lunch, is available at 2am, and never asks for a raise.
US entry-level tech job postings fell 67% between 2023 and 2024, according to Stanford Digital Economy Lab’s analysis of ADP payroll data. The share of juniors and new graduates in IT employment has dropped from roughly 15% to 7% over three years. Job listings labeled “entry-level software engineer” actually grew 47% over the same stretch, which sounds contradictory until you learn that most of those roles were filled by engineers with three or more years of experience. Companies wanted the title’s price tag, not the person the title used to describe.
I want to be direct about something here: none of this is startups behaving badly. It is startups behaving exactly like the incentives told them to. That is the part worth sitting with.
Why AI Helps the Senior and Drags the Junior
This is the part that gets flattened in most of the hand-wringing about junior hiring, so let’s slow down on it. AI coding tools are not neutral with respect to experience level. They make a senior engineer faster because a senior engineer already knows what correct looks like and can spot the moment an AI-generated function quietly does the wrong thing. The same tool handed to someone still forming that judgment does not accelerate them. It hides the gap where their judgment should be.
Microsoft’s Mark Russinovich and Scott Hanselman have been blunt about this in public: agentic coding tools give senior engineers a genuine productivity boost while imposing what they call “AI drag” on early-career developers, who lack the experience to steer, verify, and integrate what the model produces. Stack Overflow’s 2026 developer survey backs this up from a different angle. Seventy-six percent of developers using AI tools report shipping code they did not fully understand at least some of the time. Senior engineers report spending 20 to 35% more time reviewing code when juniors lean heavily on AI assistants, because the review now has to catch mistakes the junior didn’t know they were capable of making.
Here is the part that should make any engineering leader uncomfortable: the very thing that made junior developers valuable, the slow accumulation of judgment through making mistakes on smaller stakes work, is the thing AI tools skip past. You don’t build that judgment by watching a model produce plausible-looking code. You build it by writing the wrong version yourself, seeing why it breaks, and doing it again. Remove the reps and you don’t get faster juniors. You get juniors who never quite become seniors.
The Bifurcation Nobody Is Pricing In
The market right now looks less like a simple downturn and more like two markets pulling apart. Junior and generalist supply has never been higher, competing for a shrinking number of entry-level openings. At the same time, genuine scarcity is building at the senior end, for engineers who can operate complex systems in production, review AI output with real judgment, and take ownership when something breaks at 3am. The layoffs of 2023 and 2024 reshaped who’s looking for work. They did nothing to close the senior gap. If anything, they widened it, because the mid-level engineers who might have grown into that gap are the ones who got cut first.
Andy Jassy’s own AWS organization has been living this tension publicly. When asked about replacing junior engineers with AI, the response from AWS leadership was that doing so was “one of the dumbest things” a company could do, not because AI can’t write code, but because a company with no juniors today has no seniors in five years. That’s not a hot take. It’s just arithmetic run one layer further out than most quarterly hiring decisions bother to go.
What 2032 Looks Like If Nothing Changes
Run the timeline forward and the picture gets specific fast. A junior developer typically needs three to five years of real, mentored work to become a mid-level engineer capable of owning a feature end to end. Mid-level engineers need another few years under senior guidance to become the people who can architect a system, not just implement one. If the current cohort of would-be juniors never gets hired, there is no cohort maturing into mid-level roles around 2029, and no cohort maturing into senior roles around 2032 to 2035.
That’s not a distant, abstract risk. It’s the exact window most of the founders reading this will still be running engineering teams, at a moment when the industry will have fewer senior engineers than it has today, not more, chasing systems that have only gotten more complex in the meantime. The AI tools available by then will presumably be better. They still won’t have sat through the production incident that taught someone what a race condition actually feels like at 4am, versus what it looks like in a textbook.
The Companies Betting the Other Way
Not everyone is making the same call, and it’s worth noticing who isn’t. IBM is tripling entry-level hiring in the US in 2026. Netflix started onboarding new graduates again after roughly 25 years of hiring senior-only. Cloudflare is bringing on more than 1,100 interns and new grads. Shopify runs close to 1,000 internships a year. These are not charity programs. They’re companies with long enough planning horizons to notice that the senior engineers they’ll need in 2032 have to start somewhere, and that “somewhere” has just gotten a lot emptier across the rest of the industry.
The mentorship model that seems to be working where it’s being tried is not the old model with an AI tool bolted on. It’s a pairing model: a senior engineer sits with a junior while the junior works with an AI tool, watching not what gets produced but what the junior accepts, what they question, and what they miss entirely. The senior’s job stops being “answer the question” and becomes “teach the judgment.” That’s a slower, more deliberate use of senior time than most fast-growing startups think they can afford. It’s also the only mechanism anyone has found that actually produces the next generation of senior engineers, rather than just the next sprint’s velocity number.
What This Means If You’re Running a Small Team
Most companies in the five-to-100-employee range reading this cannot run a full mentorship pipeline. That’s a fair constraint, not an excuse. But the choice isn’t binary between “hire a full junior bench” and “AI replaces the junior role entirely.” On-demand resources built around senior engineers solve the immediate problem, code that ships correctly, systems that hold up under real load, without pretending a junior-plus-AI combination currently does the same job at the same reliability.
If your team is deciding how AI tools fit into your development process at all, that decision deserves more thought than “give everyone a Cursor license and see what happens.” AI consulting done properly builds review and verification into the workflow itself, the exact discipline that turns AI from a tool that drags down inexperienced judgment into one that extends experienced judgment further. And where you do need to build new capability fast, AI-powered development with senior engineers already in the loop gets you the speed without asking a junior developer to develop judgment they haven’t had the reps to build yet.
The Honest Position
I’m not going to tell you every startup should staff a junior developer bench right now. Most seed-stage companies genuinely cannot afford the ramp time, and pretending otherwise would be the same kind of cheerleading I try to avoid in the other direction. What I will say is that the industry-wide version of this decision, made independently by thousands of reasonable teams, adds up to something none of those teams actually chose: a missing generation of engineers who would have grown into the senior talent the whole industry will be short of within a decade.
You don’t have to solve that problem alone. But you should at least know you’re standing inside it, and make your hiring and AI-adoption decisions with the ten-year picture in view, not just the next sprint. The teams that will have an easier time in 2032 are the ones asking this question now, while it’s still cheap to answer.