What 10x AI Code Does to a Delivery Pipeline
Table of Contents
Every few weeks someone in my feed announces that coding is solved. In a narrow sense they have a point. An agent will write a few hundred lines of working boilerplate faster than I can read them.
Writing code was never the slow part of shipping software, though. Last year I built the backend for DreamPath, an adaptive learning platform, without typing the code myself. Over about four months a coding agent opened 276 pull requests, a bit more than two a day on average. Each one had to be read, questioned, sometimes sent back, and merged. Generating them took no effort from me. Reviewing them took most of my time.
So if your team is rolling out coding agents, ask what happens to your merge requests before you ask which model to use.
Code is inventory#
Picture a car factory. If the press that stamps doors gets ten times faster and nothing else on the line changes, you don’t get more cars. You get a pile of doors.
Code in an unmerged branch is that pile. It doesn’t do anything for users, it drifts away from main, and someone has to deal with it eventually. If your integration, testing and deployment are slow today, agents won’t fix that. They’ll make the pile bigger.
A team that reviews ten merge requests a week without strain can’t absorb fifty by trying harder. Reviewers start skimming, conflicts stack up, and delivery, the thing the agents were supposed to speed up, gets slower.
Shared prompt libraries don’t travel#
One of the first things teams do is start a shared page of prompts that work. I get the impulse, but I haven’t seen it pay off. A prompt works because of what surrounds it: your architecture, your naming, the code already in the repo. Move it to another project and it behaves differently.
What does carry over is the loop:
- Give the agent a task.
- Check what comes back.
- When it gets something wrong, write the correction into the project’s rules.
- Run it again.
Step 3 is the one people skip. On DreamPath the service package and the background job package ended up importing each other (PR #79), and Go refuses to compile an import cycle. The agent tried to fix it by adding more interfaces in new packages, which made things worse. I drew the dependency graph on paper and wrote down which direction imports were allowed to go. That written rule kept being useful long after the prompt that triggered it was forgotten.
Worktrees help, but not with merge conflicts#
Once you run more than one agent locally, a single checkout gets in the way. You can’t have an agent halfway through rewriting an API in your working directory while you switch branches to fix something on main.
Git worktrees solve that. Each branch gets its own directory, so agents and people stop overwriting each other’s files. They do nothing about merge conflicts, though. Two agents changing the same files on parallel branches will still collide at merge time. A few things help:
- Give each agent its own module or service, so changes don’t overlap.
- Rebase agent branches on main often, so conflicts show up while they’re still small.
- Keep tasks small enough to merge the same day. Long-lived feature branches and agents are a bad mix.
Put your review rules where the agent can read them#
A lot of what reviewers catch line by line is predictable: a handler calling the database directly, a missing retry, new code with no tests. Those checks can run on the developer’s machine before a merge request exists, if you write them into the agent’s rules file. They have to be specific. “Write clean code” changes nothing. Rules like these do:
- Read docs/architecture.md before changing code. Handlers never call the repository layer directly.
- Wrap every external HTTP call in SafeFetch and retry 5xx responses with exponential backoff.
- A task isn't done until there are tests for every new branch in the logic.
Treat that file like code. When review finds a problem the rules should have caught, add a rule.
What people should still review#
Once the rules catch the routine problems, human review can move up a level. I now spend most of my review time on three things: API contracts and the places where services meet, how state is stored and what happens when two things change it at once, and whether the docs still match the code.
DreamPath’s job queue is a good example (PR #247). Two workers could pick up the same job. Every line of the code
looked fine. You only saw the problem by thinking about the system as a whole, and the fix, SELECT ... FOR UPDATE SKIP LOCKED in Postgres, was something the agent knew perfectly well and didn’t use until I asked for it.
It also changes where extra effort is worth it. Application code is now cheap to regenerate, so polishing it rarely pays. Tests and staging environments are another matter. They’re how you check the output of a probabilistic tool before it reaches production, and that’s where I’d spend the time.
Automate the rest of the pipeline#
The most common mistake I see is treating LLMs as a code-writing tool and stopping there. If you only automate code generation, you’ve automated the easiest part of the job and made integration harder.
To get real speed out of agents, automate the rest as well: the context they work from, the tests that check their output, the local checks that run before anyone reviews, and the deployment. Otherwise you’re just making the pile of doors bigger.