"I read every generated line before it stays." That sentence sits in a file of rules I wrote for an AI pair engineer, the instructions a model reads before it writes a line of code for me. A few lines above it: one step per message, at most two files per step, and wait for my go. Further up: I commit, the model never does.
I did not write those rules to slow the model down. I wrote them because of a question I had left open.
Generation autoscales. Review still runs at the speed of one person reading.
- The question I could not answer last year, and the numbers that answered it.
- Twice the pull requests, nearly twice the review time, and a team that feels faster than it is.
- Why my own rules for working with a model are really a rationing device, and what a team has to ration.
The Question I Left Open
In Will AI Let Teams Scale? I wrote that the technology had scaled and the people building it had not, and that you cannot autoscale judgment, or trust, or the shared context that makes a team good. Then I asked whether AI would close that gap or widen it, and admitted I did not know.
I have a better answer now. Not a final one, but one with data under it.
Where the Time Went
In July 2025 Faros AI published telemetry from more than 10,000 developers on 1,255 teams. Developers on high-adoption teams completed 21 percent more tasks and merged 98 percent more pull requests. Over the same period, review time on those pull requests rose by about 91 percent, and average pull request size rose by 154 percent. Faros's own reading is plain: "human review remains a bottleneck". At company level, the gains mostly did not show up in delivery at all.
The writing doubled. The reading nearly doubled too, and the reading is done by people.
There is a second finding I keep returning to, because it is about how we judge ourselves. In 2025 METR ran a controlled study with sixteen experienced open-source developers working on 246 real issues in their own repositories. With AI tools allowed, they took 19 percent longer. Afterwards they believed AI had made them 20 percent faster. METR's redesigned 2026 study points to a speedup instead, and METR itself calls that evidence very weak, so I would not lean on either number. What survives both studies is the gap between how fast it felt and what the clock said.
A team that feels faster than it is will not notice where its time went. It went into reading.
My Rules Are a Rationing Device
Look at my working rules again with that in mind. One step per message. At most two files per step. Keep diffs small. Wait for my go. I read every generated line before it stays. I commit.
Every one of those rules does the same thing: it limits how much the model can produce to how much I can read with care. The model could write ten files in the time I read two. The rules make sure it does not, because the moment the writing outruns the reading, I am approving code I have not understood, and my name goes on it anyway.
That last part is the point. A commit is a signature. Whoever presses it is saying: I have read this and I will answer for it. I made the argument about ownership in You Cannot Prompt Ownership. This is the arithmetic underneath it. If the model can write faster than anyone can sign, either the signatures get thinner or the queue gets longer. The Faros numbers are what the queue looks like.
I use the same habit outside those rules. On my own projects the model drafts, and I review everything it produces before it stays. In a pilot I run at work, the test assistant stops after every step and waits for a person. None of that is caution for its own sake. It is the only way I know to keep my signature worth something.
What a Team Has to Ration
On a team the scarce thing is not one person's attention but the team's: the senior engineers who can read a change and know what it touches. That capacity grows slowly, the way it always has, by people reviewing real work and being reviewed.
So a team that lets generation run free does three things at once. It floods its best readers. It pushes changes through with thinner review, because the queue is long and the release is due. And it quietly removes the work juniors used to learn from, because the model wrote the first draft they would have struggled with. The bottleneck I described a year ago does not move. It gets worse, and harder to see.
What I would ration instead is simple to say. Size the changes to what a reviewer can read in one sitting. Make every review comment say whether it blocks, so the reading is spent on what matters, which is the habit I described in Blocking, or Preference?. And keep juniors reviewing generated code, with a senior beside them, because reading is now the skill the team is shortest of. The system knowledge none of this can replace is the subject of Thirty Percent of the Code.
The Answer, for Now
Does AI close the gap or widen it? On the evidence I have, it widens it, unless a team does what my rules do for me: lets the writing run only as fast as someone can read it and sign it.
A team ships only as fast as someone can read the change and put their name to it.
I asked the question a year ago and said I would rather hold it honestly than pretend to an answer. I still hold part of it open. Better tools for review may change the arithmetic. Until they do, the speed that matters is the reading.
Judgment grows in people who read real work and are read in return. How a team protects that, when the first draft increasingly comes from a model, is the question for the Lead pieces still to come.