Writing code stopped being the slow part
Almost two years ago I wrote about giving AI a conventions document before asking it to refactor code. Back then AI was still a helper inside my editor, the thing that autocomplete and sometimes surprise me. Today I lead a small squad, and most of my own code is written by agents. I give a task, an agent reads the codebase, writes the change, runs the tests, and opens a pull request. Then I read it and argue with it haha.
Faster code I already expected. But the work around the code changed much more than I thought. When writing code becomes cheap, the expensive parts move somewhere else: deciding what to build, the review, proving it works, and the token bill.
Estimates stopped meaning much
Design docs usually carry effort estimates. Something like “3 dev days” sitting in a table cell. When an agent can write the first version in an hour, that number says almost nothing about anything.
So I stopped putting effort estimates in my design docs. A doc now names an owner and gives scope facts instead: how many endpoints, how many tables, or how many statements change. No duration, nothing that pretend to be a promise.
The question changed from “how long to write it” to “how long to review it and prove it works”. Those two is not the same thing at all, and the second one now eats most of the time.
Review became the bottleneck
Code and documents now arrive faster than people can read them. I learned this with an architecture pull request: 6 documents, around 1,500 lines, 9 reviewers. It took 6 weeks and about 14 reminder pings from a bot. Most reviewers never engaged. The few comments that came was questions that the documents should already answered.
So now I write for a reviewer who has no time. One document per pull request, and at the top there is a TL;DR box with the decision, why now, what changes for you, and what I need from you.
“If you only have ten minutes for this, what do you actually need from me?”
That’s basically what the TL;DR box answers for the reviewer, before they have to ask.
And I write a decision record only when a decision has real blast radius. Once an agent split one design into 7 pull requests, one per decision, which is more than any team will review. I cut it to 2.
For code review, I built an agent that drafts my reviews. When someone asks me for a review, it reads the pull request and opens a pending review on GitHub that only I can see. I read it, delete the part I disagree with, and submit the rest under my name. On two early reviews I kept 4 of 6 comments on one and 3 of 5 on the other.
The first drafts tried too hard to look thorough. Every comment was one long paragraph, around 70 words. One run labelled all 5 of its findings as issues — every single one, because apparently everything look like an issue to a model.
So I measured my own review history and put the numbers into the prompt. Of my last 94 reviews, 50 were approvals, 43 were comments, and only 1 requested changes. I wrote “blocks the merge” in 3 of my last 117 comments. My median comment is 27 words.
A reviewer’s job is mostly to separate what blocks from what doesn’t. A model left alone will try to look busy instead, so it needs to know how often a good reviewer just approve.
The rules moved from people’s heads into the brief
An agent starts every task like a new hire on day one. It doesn’t know the unwritten rules that every person on the team learn the hard way. My agents found those rules by breaking them:
- An agent stopped some processes with a pattern that matched every process of my user. It killed my whole desktop session. Now agents only stop processes they started themselves.
- An agent needed some data, found a database password in a config file copied from the cluster, and queried the database directly. Rule since then: database reads only go through the approved read-only tool, and secrets in config files are off limits.
- A full test run included a setup step that deleted and recreated test data. It wiped the seeded dataset that the rest of the suite depended on. Destructive setup now only runs behind an explicit flag.
- Three agents type-checked a big repository at the same time on an 8 GB server, and it ran out of memory. So heavy commands go through one lock, one at a time.
Each incident became one line in every brief. It is the same idea as my conventions document from 2025, except this one grows from real incident and the agent reads it on every task.
Tickets get read by agents too
Tickets and pull request descriptions are read by QA, DevOps, and product people, and many of them is not native English speaker. Now agents read them too. My build agent reads the ticket, its parent, and its subtasks before it write any code.
So I switched my tickets and pull request descriptions to Simplified Technical English (ASD-STE100). It was made for aircraft maintenance manuals, which sound a bit weird for a backend team. Short sentences, one idea per sentence, active voice, and one word for one meaning. It reads stiff, but nobody has to guess what a sentence means.
A vague ticket is more dangerous with agents, because an agent doesn’t stop and ask. Once, a set of 5 subtasks and 4 draft pull requests got built against the wrong phase of a project, because the scope in the ticket was not clear. The code was fine. It was just the wrong code, and we closed those 4 pull requests.
Done needs evidence
Agents say “done” with full confidence every time. Even when it not done. So for me “done” now means evidence. My usual flow for a ticket goes like this. The agent prepares the fix, two separate review agents try to break it, I test it locally, and the pull request includes a before and after recording. That last part is for the human reviewers by the way.
For the LLM feature we work on, I didn’t want to tune the prompt or switch the model based on feeling. So I built a benchmark from real chat history. The first headline result was +20 points. After an adversarial review, and after I reverting the rule changes I made in the middle of the experiment, the honest number was about +12. The same code run twice gave different results on 15 of 59 cases, which is why every case runs 3 times on each side now.
Watching the token bill
Running many agents in parallel burned my quota fast, so tokens became a budget for me, same like CPU or memory. I went back to one agent at a time, with review agents only where needed.
Then I audited where the tokens actually go. About 64% of the spend was cache rewrites. Agents were waiting on long-running commands for more than 5 minutes, which is longer than the prompt cache lives, so every time they woke up they paid to rebuild their whole context from scratch. One agent grew to almost a million tokens of context.
Now no agent waits more than 4 minutes in one call. An idle agent gets replaced by a fresh one with a handoff note instead of being resumed, and the work comes in small packages.
Not everything needs a model, either. In my review agent, the model only runs for the review itself and for one small step that sorts the replies. Collecting review requests, watching pull requests, and updating status are plain scripts. That sorting call cost about $0.016 through the full agent tool, and $0.000046 straight to the model API. So that call goes straight to the API now.
What I don’t delegate
Some things the review agent is not allowed to decide. It has a stop list: decisions about data integrity that need a repair script, race conditions in async code, anything where blocking depends on release timing, and architecture decisions. For those, it describes what it sees and ask me. It never rule on them in a comment.
Everything still goes out under my name. If a review comment is wrong, that’s my mistake in front of my colleagues, whoever drafted it.
I’m still adjusting these rules almost every week, and the brief keeps getting longer. Ask me again in six months — I bet the answer is different by then.