Skip to content
All articles

Agents Write the Code. Our Job Got Bigger.

Dean Jain

Dean Jain

Senior Staff Software Engineer · Enterprise AI, Data & Cloud Architect

· 9 min read

CareerEngineering CultureAgentic AI
---
config:
  theme: dark
  fontSize: 16
  themeVariables:
    fontFamily: "Comic Sans MS, Comic Neue, Chalkboard SE, cursive"
    fontSize: "16px"
  flowchart:
    wrappingWidth: 150
    nodeSpacing: 18
    rankSpacing: 34
    padding: 14
    subGraphTitleMargin:
      top: 6
      bottom: 10
---
%% animate
flowchart TB
    subgraph OLD["⌛ Then: I wrote the code"]
        direction LR
        O1["👤 I write it"]:::neutral --> O2["👤 A peer reads it"]:::neutral
        O2 --> O3["🚀 Merge"]:::good
    end
    subgraph NEW["⚡ Now: agents write the code"]
        direction LR
        N1["👤 I specify it"]:::gate --> N2["🤖 Agents generate<br/>several in parallel"]:::agent
        N2 --> N3["✅ Gate proves<br/>what can be proven"]:::server
        N3 --> N4["👤 I judge what<br/>no machine checks"]:::gate
        N4 --> N5["🚀 Merge"]:::good
    end
    OLD ~~~ NEW
    classDef neutral fill:#ECECEC,stroke:#8A8A8A,stroke-width:2px,color:#0F172A
    classDef good fill:#BFEFC8,stroke:#3FA34D,stroke-width:2px,color:#0F172A
    classDef gate fill:#D7C3F2,stroke:#8E5BD0,stroke-width:2px,color:#0F172A
    classDef agent fill:#FFE08A,stroke:#E8A33D,stroke-width:2px,color:#0F172A
    classDef server fill:#A8E6D0,stroke:#2FA37C,stroke-width:2px,color:#0F172A

Figure 1: The typing moved to the machine. Specifying the work and judging the result stayed human, and both got bigger.

Most engineers I talk to are asking one question. If the agent writes the code, what am I for?

Here is the shape of the answer. Writing code got fast. Accepting code did not. LinearB’s 2026 benchmark looked at 8.1 million pull requests, the proposed code changes that wait for a human to approve them. AI-generated ones sat over sixteen hours before a reviewer even opened them, against about three and a half for human-written ones. Then only a third of the AI ones were accepted (32.7%), against five in six of the human ones (84.5%).

The WAIT queue did not move to the machine. It moved to us.

Producing code is cheap now. Deciding that code is correct is not, and that decision is the job. It’s harder than the job it replaced, and I’ve met very few engineers who were trained for it.

TL;DR

  • The queue moved from writing to accepting. LinearB has AI-generated changes waiting over sixteen hours for a reviewer against about three and a half, and merging at less than half the rate. Review time is now the scarce thing on a team.
  • Looking right is not being right. Veracode finds AI code well-formed over 95% of the time and safe 55% of the time, and that second number has not moved in two years.
  • Nobody can feel their own speed. The best controlled trial, from METR, found experienced developers wrong about their own productivity by roughly 40 percentage points, in a codebase they owned.
  • Three qualities went from optional to essential. Writing down what correct means, designing the proof, and reading unfamiliar code fast.
  • The market has already re-priced this. Indeed’s Hiring Lab puts senior roles at 69.3% of US software development postings, the highest of any industry it tracks, and entry-level at 4.5%, the lowest.
  • This piece is the what, not the how. Everything here says the job changed. Two follow-ups, on the spec you write before the agent starts and on the gate you put in front of what it produces, are coming over the next few weeks.

1. What changed

Almost everyone uses these tools now. Google’s DORA program, which has measured how software teams build and ship for over a decade, found 90% of nearly 5,000 technology professionals using AI at work. Stack Overflow’s 2025 survey put it at 84%.

Almost nobody trusts them. In that same survey, more developers actively distrust the accuracy of AI tools (46%) than trust them (33%). Only 3% highly trust the output. The single most common complaint, from 66% of those who answered, is code that is “almost right, but not quite.”

That phrase is the whole problem in four words. Wrong code gets caught. Almost-right code doesn’t

Three measurements show where it costs you.

  • 📏 Changes got bigger. In LinearB’s data, at the 75th percentile, meaning the largest quarter of changes, AI-assisted ones run over 400 lines against 157 for work a person wrote alone. Fully agentic ones sit at about 290. That is more to read, on every change, permanently.
  • 🔒 Security did not keep up with syntax. Veracode tested over 150 models on 80 tasks, each built so the same function can be written safely or unsafely. The code is well-formed over 95% of the time. It is secure 55% of the time, essentially unchanged across two years of model releases.
  • 🧱 The codebase quietly degrades. GitClear tracks moved code, its stand-in for refactoring, meaning old code rewritten to be simpler instead of new code piled on top. It fell from 21% of changed lines in 2022 to 3.8% in 2026. Across the 623 million changes GitClear analyzed from 2023 on, duplicated blocks rose 81%.

Read the third one twice. Agents add. They almost never consolidate. Nothing in your test suite complains about that, which is why it shows up as a slow rot rather than an incident. You don’t get an alert for a codebase getting harder to change.

How much to trust these numbers. LinearB, Veracode and GitClear all sell something adjacent to what they measure, and DORA belongs to Google, which sells AI coding tools. None of their datasets can be checked from outside. I use them because nobody independent is measuring at this scale. The claim I lean on hardest has the least conflict behind it. It’s from a developer survey with nothing to sell, and the top complaint in it is code that looks right and isn’t.

One more finding, because it’s the most quoted and the most misunderstood. METR, a nonprofit that runs controlled trials on AI, gave 16 experienced developers 246 real tasks in codebases they already maintained. With AI they took 19% longer while believing they had been 20% faster. METR has since marked that result out of date, and its later rerun estimates a speedup instead.

Take the correction at face value: the agents are probably making people faster. That makes my point rather than breaking it. If producing code got faster, the gap between how fast work is made and how fast it can be checked got wider. And the part that still stands is the part I care about. Those developers couldn’t feel the difference in their own speed, on their own code. Intuition isn’t a measuring instrument here.

2. The qualities that now pay

This is the list I’d hand an engineer today, against what the same word meant when a person did the typing.

QualityWhen you wrote the codeNow that agents do
↑ ✍️ ResponsibilityOwn your task to the outcomePut your name on work you didn’t type. An agent can’t be accountable for anything
↑ 🔍 AwarenessSpot the edge caseSpot “almost right”, which is the hardest kind of wrong to see
↑ 🙋 HonestyTell the truth about estimatesSay “I don’t understand this change” instead of approving it
↑ ✂️ PragmatismKnow which corners are safe to cutKnow what not to build. Agents made building the wrong thing fast and cheap
↗ 🔬 Attention to detailNaming, style, the shape of a functionInterfaces, data shape, and invariants, meaning rules that must hold whatever the input
↗ 🧊 ComposureStay calm when production is downStay suspicious when every check is green
★ 📝 SpecificationHeld in your headWritten down, before generation starts
★ 🧪 Verification designWrite tests afterwardsDecide up front what would prove this, and what a machine can prove for you
★ 📖 Reading fluencyUsefulMost of your working day

The arrows: ↑ went up in value, ↗ still counts but at a higher level, ★ used to be optional and is now the job.

Responsibility rose the most, and it’s the only one on that list with no technique behind it. You either sign or you don’t.

3. What the market is paying for

The market has already re-priced this. Indeed’s Hiring Lab reported in July 2026 that senior roles were 69.3% of US software development postings in the first quarter, the highest of any industry they track, and entry-level was 4.5%, the lowest. Stanford’s Digital Economy Lab works from ADP payroll records. Between November 2022 and June 2026, employment for 22 to 25 year olds in the most AI-exposed occupations fell about 11%. In the least exposed, the same age group grew about 10%.

Read the caveats before the headline, because both authors put them there. Stanford states plainly that this is descriptive, not causal, and their result barely changes when they remove computer occupations entirely. That makes it an economy-wide pattern for young workers rather than a software story. Indeed’s figures are postings rather than hires, and Indeed names other suspects: remote work, interest rates, and companies correcting a pandemic hiring spree.

So the door didn’t close. It moved, and it moved toward the more interesting half of the job.

What the market stopped paying for is typing, and typing was never the good part. What it pays more for now is judgement: deciding what correct means and putting your name on the answer. If you’re early in your career, that’s the encouraging part, because nobody has ten years of experience at it. The engineers ahead of you spent those years getting fast at the thing the agents now do. On the work that actually got scarce, everybody is a few years in at most.

Somebody has to sign the change. In my corner of the world, a regulator eventually reads that name.

The one move I’d make, at any level, is to own the merge gate for one surface area. Pick something small that nobody is looking after. Write down what correct means there, build the checks, and be the person who decides. It needs no permission, no new title and no headcount, and you can start on a Tuesday.

For a junior I’d argue that beats the apprenticeship it replaced. The old one was writing code and waiting a week for someone senior to tell you what was wrong with it. The new one is reading a hundred changes you didn’t write, deciding which are right, and finding out almost immediately whether you were. That loop is faster, and it teaches judgement instead of syntax.

Key takeaways

  • Stop measuring yourself by code produced. That number’s going to keep rising whatever you do, and it has stopped being evidence of anything.
  • Learn to write down what “correct” means. Inputs, outputs, the rules that must hold whatever the input, and what must not change. This is the skill with the steepest new value.
  • Get faster at reading code you didn’t write. It’s most of the working day now, and almost nobody trains for it deliberately.
  • Be the person who signs. Responsibility is the one quality on the list with no technique behind it, and it’s the one an agent can never take.
  • Own the gate for one surface area. Write the specs, build the checks, decide what correct means there. It needs no permission and no new title.

Further reading