AI coding agents didn't replace us — they changed what a day looks like

Somewhere in the last year the shape of a working day quietly changed. We did not fire anyone, hire a robot, or ten-times our output. But the hours look different, and pretending otherwise would be dishonest. AI coding agents — the kind that read your codebase, edit files, run commands and iterate — went from a party trick to a normal part of how a small studio ships. Here is what actually changed, minus the breathless part.

What they are genuinely good at

The wins are real, and they cluster in one place: work that is mechanical, well-specified, and verifiable.

• Scaffolding and boilerplate. New component, new endpoint, the tenth variation of a form. The agent writes the obvious 80% in seconds and you spend your attention on the 20% that needed a brain.
• Translation and tedium. Porting a pattern across files, migrating an API, producing the trilingual version of something, chasing a rename through a codebase. Work that was never hard, only slow.
• The first draft of a spike. "Build me a rough version of X so I can see if the idea is any good." Getting to a running prototype an hour faster changes which ideas you even bother to try.
• A second set of eyes. "Why is this undefined, what am I missing here." Often faster than a search, and it is looking at your actual code.

What they are still bad at

The failure modes are just as consistent, and knowing them is the whole skill now:

• Taste. An agent will happily produce something that works and is ugly, generic, or subtly off-brand. It has no opinion about whether the thing is good — only whether it runs. That judgement is still entirely yours.
• Knowing when it is wrong. The dangerous output is not the error that crashes; it is the plausible answer that is quietly incorrect. An agent states a confident wrong thing in exactly the same tone as a right one.
• Novel architecture. Ask for the tenth CRUD form and it shines. Ask it to make the load-bearing decision your whole system rests on and you are the architect again, using it as a very fast draughtsman.
• Its own blast radius. Left unattended it will confidently refactor more than you asked, or "fix" something that was not broken. Holding scope is your job.

The real shift: the work is now verification

This is the part that took us a while to say out loud. When an agent can produce a plausible implementation in seconds, writing the code stops being the bottleneck. Trusting it becomes the bottleneck. The centre of gravity of a developer's day moves from typing to reviewing — reading a diff you did not write, with the specific suspicion that it might be subtly wrong, and having the taste to reject work that merely functions.

That is a different muscle than the industry spent thirty years training. It rewards people who can hold a clear spec, who verify against the real running thing instead of the vibe of the code, and who know their domain well enough to smell when an answer is off. It punishes cargo-culting an agent's output into production because it looked confident.

Where we landed

We are not romantics about this, and not doomers either. Used well, an agent is the fastest junior draughtsman you have ever worked with — tireless, encyclopaedic, and in genuine need of adult supervision. It did not replace the craft. It moved the craft up a level: from "can you write it" to "can you tell whether it is any good, and prove it." That was always the harder and more valuable question. Now it is most of the job.

(If you want our take on the other kind of agent — the autonomous product kind everyone wants to bolt onto their app — we already wrote that one: mostly, no.)

FAQ

Do AI coding agents replace developers?

No — they move where the work happens. Writing the code stops being the bottleneck and trusting it becomes one, so the day shifts from typing to reviewing a diff you did not write. Whether the result is any good is still entirely your call.

What are AI coding agents actually good at?

Work that is mechanical, well-specified and verifiable: scaffolding and boilerplate, porting a pattern across files, migrating an API, producing the trilingual version of something, chasing a rename through a codebase, and getting a rough spike running an hour sooner. Work that was never hard, only slow.

Where do AI coding agents still fail?

Taste, self-knowledge, novel architecture and scope. An agent will happily ship something that runs but is generic or subtly off-brand, and it states a confident wrong answer in exactly the same tone as a right one. Left unattended it will refactor more than you asked.

Which developer skills matter more now?

Holding a clear spec, verifying against the real running thing instead of the vibe of the code, and knowing your domain well enough to smell when an answer is off. Reading a diff with the specific suspicion that plausible output might be quietly incorrect.

Can an agent's output go straight to production?

Not unreviewed. The dangerous output is not the error that crashes — it is the plausible answer that is quietly wrong. Cargo-culting it into production because it looked confident is the exact failure mode to avoid.