And what it means for the developers of tomorrow
Something shifted around September 2025. You could feel it in developer communities, in job postings, in how teams were being assembled. Developers who had spent years writing code line by line were suddenly just... prompting. And the output was good. Good enough to ship.
This isn't a speculative think piece about a future that might arrive. It's already here, and the numbers are starting to catch up with what many of us in the industry have been quietly observing.
Let's start with the hard data, because the anecdotes alone are easy to dismiss.
Google's 2025 DORA Report, one of the most comprehensive annual studies of software development practices, found that AI adoption among software professionals has surged to 90%, a 14% jump from the year before. Over 80% of respondents say it has enhanced their productivity. This isn't fringe behavior anymore. It's the baseline.
Stack Overflow's 2025 Developer Survey tells a similar story: 84% of developers now use AI tools in their development process. And among those using AI agents specifically, around 70% say agents have meaningfully reduced time spent on development tasks.
Meanwhile, on the employment side, things look starkly different for younger developers. A Stanford Digital Economy Study found that employment for software developers aged 22 to 25 declined nearly 20% from its peak in late 2022. In the US, overall programmer employment fell 27.5% between 2023 and 2025, according to Bureau of Labor Statistics data, though the drop was far less severe for software designers (senior, higher-abstraction roles), hinting at where the demand is actually going. Entry-level hiring at the 15 biggest tech firms fell 25% from 2023 to 2024 alone.
The IT sector's unemployment rate jumped from 3.9% to 5.7% in a single month in early 2025. Computer science graduates now have a 6.1% unemployment rate, higher than liberal arts graduates.
If one story crystallizes this shift, it's Spotify's.
During its Q4 2025 earnings call, Spotify co-CEO Gustav Söderström said something remarkable: the company's best engineers "have not written a single line of code since December." Not because of burnout or budget cuts. Because of an internal AI system called Honk, built on top of Anthropic's Claude Code.
The workflow is striking. An engineer on their morning commute can message Claude via Slack from their phone, ask it to fix a bug or add a feature to the iOS app, receive a new build back on Slack, and merge it to production, all before arriving at the office.
This isn't a startup demo. Spotify has 751 million users. And it shipped over 50 new features and changes throughout 2025. Honk merges more than 650 AI-generated pull requests into production every month, with the company reporting up to 90% time savings on complex code migrations. Over 1,500 AI-generated pull requests have already been merged.
The Honk system connects natural language prompts in Slack and GitHub to a full coding pipeline: the AI writes, tests, builds, and opens the pull request. Spotify's senior engineers shifted from writing code to supervising code. As Söderström put it, they "only generate code and supervise it."
Spotify isn't alone. Duolingo, DoorDash, Instacart, and Uber are all experimenting with agent-based development workflows. The pattern is consistent: one experienced engineer with AI tooling, doing what once required a team.
Here's the dynamic that practitioners are noticing before the official data catches up: clients increasingly prefer one strong mid-level developer with Claude Code over an entire traditional team. The economics are simply too compelling to ignore.
This makes intuitive sense when you look at what junior developers have traditionally been hired to do: writing boilerplate, fixing small bugs, testing, documentation, generating CRUD code, and working through low-complexity tasks. These are precisely the things AI handles best right now.
A survey of 9,000 software engineers found that 90% believe finding a job is significantly harder than it was in 2020. Only 6% are confident they could match their current salary if they lost their job. Meanwhile, 66% of enterprises are reportedly reducing entry-level hiring as a direct response to AI capabilities.
Here's the uncomfortable question buried inside all the productivity optimism: where do senior developers come from?
The current generation of senior engineers built their judgment over years of doing the exact boring work that AI now handles. Writing the CRUD code. Debugging the stupid bug. Understanding why a fix worked, not just that it did. This is how engineers develop the mental models that let them catch AI errors five years from now.
If you don't hire junior developers today, you will have no senior developers tomorrow. This is not complicated math, but it seems to be getting lost in the excitement over short-term efficiency gains.
Some companies that aggressively replaced developers with AI are already experiencing project delays and unexpected inefficiencies. AI is powerful, but without human oversight, it can create as many problems as it solves. The problem is that the human oversight required is expert oversight, and expert oversight requires having, at some point, been a beginner.
One analyst put it plainly: internship postings in tech dropped 30% since 2023. The pipeline for future senior developers just got quietly dismantled, and nobody has fully reckoned with the consequences yet.
There will likely be a senior developer shortage in five to seven years that is entirely self-inflicted.
This is where the conversation gets genuinely interesting, and genuinely unsettled.
Universities are scrambling to respond. UC San Diego launched a GenAI in CS Education Consortium (backed by $1.8M from Google.org), bringing together educators from North America, Europe, and Africa to reshape curricula. Columbia Engineering is reworking its programming courses to emphasize code reading and review over code writing, integrating AI as a tool earlier in the sequence. An 80% majority of CS teachers agree that core concepts in CS education need to be updated.
But the deeper question is about first principles. We don't teach assembly language anymore. We don't usually teach Fortran. As the abstraction layer rises, what we call "programming" shifts upward too. Some argue we're simply on the brink of another such shift, where the meaningful skill becomes directing systems rather than writing them.
There's a real case to be made here. If AI handles syntax, then the valuable skills become: systems thinking, problem decomposition, knowing what to build and why, understanding trade-offs, and knowing when to distrust the AI. These are things that can be taught, but perhaps not the way CS has traditionally taught them.
What doesn't survive the transition is rote syntax memorization, churning through boilerplate assignments, and learning programming in a language-specific way divorced from real problem-solving. CS education almost certainly needs to be more language-agnostic, more focused on reasoning and architecture, and faster to adapt, built as a meta-curriculum rather than a static syllabus.
The METR research group published a study earlier this year that found AI tools initially slowed down experienced open-source developers by about 20%, because the developers resisted ceding control over tasks they'd internalized deeply. But by August 2025, so many developers refused to participate in "no AI" control conditions that the study's methodology broke down. Developers had become so dependent on AI assistance that being asked to work without it felt like a regression.
That's a telling data point. AI isn't replacing developers so much as becoming inseparable from them. The question is what kind of developer survives and thrives in that fusion.
The answer, increasingly, looks like this: engineers who understand systems deeply enough to direct AI effectively, catch its failures, evaluate its output, and make judgment calls that require genuine domain expertise. Not coders. Architects. Not syntax experts. Problem solvers.
The role of "developer" is transforming, not disappearing. But the transformation is real, and the entry path into the profession is being fundamentally disrupted in ways we haven't fully reckoned with yet.
What we're watching unfold is something like this:
The optimistic framing is that we're clearing a path toward a higher-abstraction form of engineering, one where you need to understand systems, not syntax. The pessimistic framing is that we're sawing off the branch we're sitting on by eliminating the training ground through which expertise is built.
Both framings are probably partially right. What's certain is that this is not a drill, and September 2025 was not the beginning. It was just when enough people noticed at once.
The question for everyone involved in building, hiring, and educating developers isn't whether AI is changing software development. It obviously is. The question is whether we're being thoughtful enough about what we might be losing in the process.
Sources: Google DORA Report 2025, Stack Overflow Developer Survey 2025, Stanford Digital Economy Lab, IEEE Spectrum, TechCrunch, METR Research, Bureau of Labor Statistics, Columbia Engineering, UC San Diego GenAI CS Education Consortium