How I Build Software With AI Coding Agents

What I actually delegate

I use coding agents for most of the mechanical work now. This site is the clearest example: over a few weeks it gained a four-language front end, a services page, a contact form with its own API endpoint and storage, case studies assembled from existing content, and a progress widget fed by a Duolingo profile. Almost none of that needed me to type code by hand.

What I never delegate is knowing what should exist. An agent will happily build the wrong thing at high speed. The useful skill is writing a specification precise enough that being wrong is visible.

The failure that taught me to check output

While adding a maturity badge to the project pages, I had a new status field written to the database, the type extended, and the component updated. It compiled. The page rendered. The badge said "in development" on every project.

The cause was a controller that whitelisted the fields it returned, so the new field never left the server. Nothing in the type system objected, because every layer was individually correct.

Two days later the same pattern appeared in the sitemap. It was generated while the container image was built, when the backend is not reachable, so the list of project IDs came back empty and the sitemap shipped without a single case study. The build passed. The file looked fine.

Neither bug was exotic. Both were invisible unless you look at what the deployed system actually emits.

Where agents are genuinely strong

Mechanical breadth. Renaming a concept across forty files. Adding a fourth language to every place that already had three. Writing the test scaffolding for a repository that has none. Work that is wide, boring, and easy to verify is where the speedup is real, because verification is cheap when the change is uniform.

They are also good at the thing I used to postpone: the second pass. A model reviewing its own diff catches type errors, unreachable branches, and forgotten imports faster than I do at 11pm.

Where they fail quietly

They do not know what is true. Ask for a case study and you can get a confident paragraph about a product that does not exist. Every factual claim still needs a source, and "the tests pass" is not a source.

They also stop at compiling. A model will declare a feature complete because the build is green, when the feature is not wired into the page, the field is dropped by a serialiser, or the migration was never run.

The bottleneck moved

Before, the expensive part was writing the code. Now it is deciding precisely what to build, and proving that what was built is what you asked for. My days look different: less typing, more reading of diffs and more checking of live output.

That has a consequence for how I work. Small changes, verified in production, with a way back. A large agent-generated diff that "looks right" is the most expensive thing you can merge.