Skip to main content

Will AI Take Your Developer Job? A Realistic Look at Which Tasks Change and Which Don't

AI made code cheap, but review, judgment and ownership didn’t. Here’s which developer tasks are shrinking, which are changing, and which stay human.

Updated 9 min readMarkdown
Will AI Take Your Developer Job? A Realistic Look at Which Tasks Change and Which Don't

Writing code was never the scarce part of the job. The data is starting to show it.

TL;DR

  • AI coding agents sharply increased code output, but finished software barely moved. Review became the bottleneck.

  • The most exposed work is "turn a clear spec into code," and the squeeze is hitting junior roles first.

  • The skills gaining value are specifying, verifying, and owning what ships.


When firms adopted AI coding agents, something odd happened. A Harvard working paper that analyzed engineering data from hundreds of companies found this:

Code output Finished work Time to review a pull request
Up roughly a third No statistically significant rise Up about half

After firms adopted AI coding agents. Source: Chen and Stratton, Harvard working paper (not yet peer-reviewed). Exact figures vary slightly between versions.

More code. Not more software.

That one result says a lot about whether AI will take your job, because it points at what the job actually is. If typing code were the bottleneck, agents would have flooded the world with finished features. Instead the bottleneck moved: to deciding what to build, reviewing what got built, and owning it once it's running.


Code got cheap. Everything around it didn't.

Think about where your week goes. Writing code is one slice, next to reading code, reviewing other people's code, debugging, planning, deploys, and working out what the ticket actually means.

Say coding is a third of your time and an agent makes it 30% faster. The whole cycle gets about 8% shorter. That's a real gain, and nowhere near the 2x or 3x that demos suggest.

Then the new costs show up. Reviewers now face more and larger diffs, written by something that doesn't understand why the system is the way it is. In the Harvard data, the extra output piled up in the review queue. As one senior engineer interviewed for the paper put it, there is only one bottleneck at a time: speed up coding and the bottleneck moves somewhere else.

Here is the delivery pipeline, and where things stand now:

Mermaid Diagram

Green: now cheap. Red: the new bottleneck. Blue: where the scarce skills are.

Takeaway: The scarce skills are the ones around the code: specifying what should exist, verifying that it's correct and safe, and owning it when it breaks at 3 a.m.


Your job title matters more than you'd think

US government data splits "programmers" from "software developers," and the two have diverged sharply.

Occupation (US, BLS data) Employment change, 2023 to 2025
Programmers -27.5%
Software developers (more design-oriented) -0.3%

A staffing executive quoted by IEEE Spectrum said nobody predicted that programmers, rather than call-center workers, would take the biggest hit. He attributed it to how solitary and structured the work is.

Occupation categories are blunt instruments, and other forces are at work too. But the direction fits a clear pattern: the more your work looks like "take a well-defined spec and produce code," the more exposed it is. The more it looks like deciding what the spec should be, the less.


The squeeze is at the bottom

The evidence

  • Stanford researchers found that employment of software developers aged 22 to 25 fell nearly 20% from its late-2022 peak by mid-2025, while older developers' employment kept growing.

  • A study of US job vacancies, published by the IZA institute, found junior software postings dropping 14-15% relative to senior ones after ChatGPT's release, a gap that did not appear in mechanical engineering.

The pushback

  • One analysis reported by the Irish Times argues the apparent AI effect shrinks once you account for whether a role is remote, since coding jobs are disproportionately remote.

  • IBM has said it is tripling entry-level hiring, betting that juniors with AI can take on work that once needed more experience.

Why juniors, if it is AI? Junior work is mostly well-scoped tickets: clear spec, small blast radius, easy to check against tests. That is exactly what agents do best. What makes a mid-level or senior engineer valuable is mostly tacit: why the billing module has that strange special case, which service falls over under load, how this team really ships. None of that is in the repo.

The pipeline problem. Every senior engineer was once a junior who learned that tacit layer by doing the small stuff. Companies that stop hiring juniors are borrowing from a future in which nobody is ready to become senior.

Takeaway: The first rung is where "codified" work lives, so it's where AI bites first.


Feeling fast is not the same as being fast

In a 2025 randomized trial by the research group METR, experienced open-source developers worked in their own mature codebases, with and without AI tools.

Effect of AI on task time
What developers predicted beforehand 24% faster
What they believed afterward about 20% faster
What was measured 19% slower

That study used early-2025 tools, and it was small: 16 developers. METR's 2026 follow-up was too noisy to settle the question, and METR says developers are probably faster now than a year earlier.

The lasting lesson is about perception. Your gut feeling about your own speed, and about your own job security, is not data. Measure the first, and read the evidence on the second.


A developer's week, sorted

A rough rule of thumb for any task that lands on your plate:

Mermaid Diagram

And here is how common developer tasks land:

Task Trajectory Why
Boilerplate and CRUD scaffolding Shrinking fast Clear patterns, easy to check
Tests for existing code Shrinking fast The behavior is already defined
Mechanical migrations and refactors Shrinking fast Rule-based, verifiable by tests
One-off scripts, regexes, queries Shrinking fast Small and self-contained
Bug fixes with a clear repro Changing shape AI proposes, you verify the fix
Feature work in a familiar codebase Changing shape You direct and review more than you type
Code review Changing shape More volume, and now the bottleneck
Clarifying vague or conflicting requirements Staying hard Needs context and conversations
Hard-to-reverse design decisions (data models, service boundaries, security) Staying hard Costly mistakes, and someone must be accountable
Debugging production with partial signals Staying hard Messy and context-heavy
Negotiating scope Staying hard Runs on trust and relationships
Carrying the pager Staying hard Accountability can't be delegated to a model

What to do about it

  1. Get very good at review. Practice reading a diff like a hostile reviewer. The bugs that matter in AI-generated code tend to be quiet ones: a missing authorization check, a race condition, an error swallowed silently, a query that works on ten rows and dies on ten million.

  2. Write the spec, and write the tests first. The better you can state what "correct" means, in prose and in tests, the more you can safely delegate. Tests are how you make a fast, unreliable contributor trustworthy.

  3. Own something end to end. A service, a migration, an on-call rotation. Ownership is where tacit knowledge accumulates, and it's the hardest thing to hand to a tool.

  4. Learn the domain, not just the stack. An engineer who understands payments, logistics, or clinical workflows can judge what's right. An engineer who only knows the framework competes directly with an agent.

  5. Run an experiment on yourself. For two weeks, track how long comparable tasks take with and without AI. Use your own numbers instead of anyone's headline.

  6. If you lead a team, protect review capacity, keep pull requests small, and keep hiring juniors. Pair them with seniors so they get the tacit knowledge, not just the tickets.


Treat it as early evidence

The Harvard paper is a working paper, not yet peer-reviewed, and different versions report somewhat different numbers while agreeing on the conclusion. The tools are changing faster than studies can keep up.

And "no detectable drop in engineering headcount yet" is not a promise. A later revision of the paper adds a forward-looking model in which firms eventually get more output with fewer engineers. That's a simulation, not an observation, but it's a fair reminder that the story isn't finished.


The bottom line

AI is unlikely to take "software engineer." It is far more likely to take the narrow version of the job: the person who converts tickets into code and does little else. That version is shrinking now, and it is shrinking first at the entry level.

The version that is growing in value decides what should exist, checks that it's right, and stays accountable for it. If you can't yet say which version your current role is, that is the most useful thing to figure out this week.


Sources


Published via ZyVOP — Write once in Markdown, auto-backup to GitHub, and syndicate to Dev.to, Medium & Hashnode in 1 click.

About the author

  • One platform to write, cross-post to Dev.to, Medium, WordPress, Hashnode, and Bluesky, and protect your SEO with canonical links. Zero paywalls and full content ownership.

No comments yet. Be the first to comment.