Where AI coding agents earn their keep, and where they do not

I have been writing software for money for twelve years and writing it for fun since I was seven. So I came to coding agents with curiosity, not panic. After enough real use, my view is boring and probably unpopular. They are very good at some things and quietly dangerous at others, and the gap between the two is where teams get burned.

Here is where I have landed.

Where they genuinely help

There is a class of work that is necessary, well understood, and tedious. That is exactly where an agent shines.

• Boilerplate and glue code, the wiring between things you already understand.
• Test scaffolding against code with clear behavior.
• Exploring an unfamiliar API or SDK so you skip an hour of doc spelunking.
• Mechanical refactors when the test coverage is good enough to catch a slip.
• A rough first draft you were going to rewrite anyway.

On this kind of work an agent is like a fast junior who never gets bored. I get a draft in seconds and spend my time editing instead of typing. That is a real gain and I use it every day.

Where they quietly add risk

The trouble starts when the work needs judgment and the output still looks confident.

• Subtle business logic where a plausible answer and a correct answer look identical.
• Anything security sensitive, where a confident wrong choice is worse than no choice.
• Architecture decisions that you will live with for two years.
• Code you do not actually understand but merge because it passed the tests you thought to write.

The failure mode is not that the agent writes garbage. It is that it writes something reasonable looking that is subtly wrong, and a tired reviewer waves it through. The bug does not announce itself. It waits.

The part nobody likes admitting

Generated code is cheap to produce and expensive to own. The keystrokes were never the bottleneck on a serious project. Understanding was. If you let an agent outrun your understanding, you have not saved time, you have borrowed it at a bad rate and the bill comes due during an incident.

How I actually use them

I treat an agent like a capable junior whose work I am accountable for. I keep the loop tight and the tasks small. I never merge code I cannot explain to someone else. And I spend the time it saved me on the parts that actually need a human, which is review, design, and deciding what not to build.

Used that way they make me faster without making the codebase worse. Used as an autopilot they make a mess that looks like progress until it does not. The tool is not the story. The discipline around it is.