Reviewing code you didn't write: the real work of AI-assisted delivery

Anthropic put out its 2026 Agentic Coding Trends Report this month, and the topline is what most technical readers already suspect: coding agents have moved out of the toy phase and into real production pipelines. CIO's analysis of the same shift argues that by 2026, agents will handle a growing share of build work while human engineers move up the stack into design, review, and judgment.

That matches our experience. What it doesn't tell you is where the time actually goes.

The generation step is not the bottleneck

On a typical Arkitekt build, an agent can produce a working feature — routes, database migration, tests, a basic UI — in an afternoon. If we measured ourselves by lines of code produced per hour, the numbers would look absurd.

We don't measure that, because it doesn't matter. Code that works on the happy path is table stakes. The work that determines whether we ship in days instead of weeks is everything that happens around the generation step.

What we actually spend time on

A few things, in rough order of where the hours go:

Scoping the change so an agent can succeed at it. Vague prompts produce vague code. Before an agent touches the repo, we write a short spec: what changes, what stays, what the acceptance criteria are, which files are in scope. This is unglamorous and it's most of the job.

Reading the diff. Every line an agent writes gets read by a human before it merges. Not skimmed. Read. This is where you catch the subtle stuff: a silently swallowed error, a query that works but scans a whole table, an auth check that got moved one layer too shallow.

Writing the tests we don't trust the agent to write. Agents are good at writing tests that pass. They are less good at writing tests that would fail if the code were wrong. So we write the boundary and failure-mode tests by hand. The agent handles the coverage-filler cases.

Deploying into infrastructure we already understand. Because we run our own managed stack, we're not debugging a new deploy pipeline every project. Same containers, same observability, same rollback story. The agent's code lands somewhere predictable.

The framing that helps

Richard Gill at Xata put it well: AI codes, humans engineer. The typing is the cheap part now. The expensive part is knowing what to build, catching what's wrong, and owning what ships.

That's why "AI-assisted delivery" isn't a shortcut around engineering discipline. It's the same discipline, applied to a faster loop. If you skip the review, the tests, and the scoping, you get software faster — and you get broken software faster.

We'd rather ship one thing that works on Tuesday than ten things that need a hotfix by Friday. The agent helps with that. It doesn't do it for us.