Blog · Field notes · · 5 min read
How to estimate a build when an agent does the typing
The typing is no longer the cost. Here is a reference class from 66 merged branches and 8,948 Claude Code sessions: what a build really takes, where the schedule actually slips, and five rules to estimate by.
The old way to estimate a software project was to count the typing. How many screens, how many endpoints, how many days for one person to write them. When an agent does the typing, that count stops predicting anything. The typing takes minutes. What takes the time is deciding, reviewing, and waiting, and none of those scale with lines of code the way typing did.
I have a record to check that against. Between March 10 and October 10, 2026 Claude Code ran 8,948 sessions on my two machines: 2,193 I drove by hand, 6,755 that agents started on their own. That is 31,771 prompts I typed, 951,820 tool calls and 2,130,122 messages (the full census is on how I work). Every one of those figures is a floor, the census says so too. Here is what that record says about estimating.
What you are really estimating
The census holds one number that moves the whole question. Before April 8 a prompt I typed produced about 22.4 messages of work behind it. After April 8 it produced 78.9. Same person, same keyboard, 3.5 times the work per instruction. The human side of a build did not get 3.5 times faster, because it was never the typing. It is the part that stayed the same size: knowing what you want, and looking at what came back.
So estimate three things separately, and stop adding them into one number of days:
- Decisions. What has to be settled before anyone, human or agent, can build the right thing. This is the part that slips, because it waits on you.
- Build. The agent's run. Short, and a narrow spread once the work is defined.
- Review and ship. Reading the diff, running it, checking the deployed result. Scales with how much changed, not how long it took to write.
A reference class, built from my own merges
The best estimating advice has not changed: do not guess from the inside, look at how long similar work took. So I measured it. Every git clone on one of my machines, every branch merged since March 10, first commit on the branch to the merge. 66 branches, 44,778 changed lines in all, across 5 repositories, and every figure here is a floor because only the clones on that machine were read. 51 of the 66 merged from September on: earlier I mostly committed straight to main, so the early months have almost no branches to time.
branch size branches median 80th pct 90th pct
under 100 lines 28 under 1 min 5 min 27 min
100 to 999 lines 27 16 min 55 min 1.4 h
1,000 lines or more 11 1.2 h 3.3 h 7.5 h
all 66 5 min 56 min 2.3 hRead the table as ranges, not as a promise. A branch under 100 lines is a coffee. A branch of a thousand lines or more has a median of about an hour, and one time in five it takes more than three. That 80th percentile column is the number to hand to someone waiting on you, because it is the one you will blow through one time in five.
The tail is waiting, not building
The longest branch in that set took 510 hours from its first commit to its merge. Nothing about the build took 510 hours. It sat. The next longest is 7.5 hours at the 90th percentile of the big branches, a normal working day. The extreme end of a record like this is more often a branch that waited than one that was hard. An honest estimate for agent work names the decision it is waiting on and who owns it, because that decision is the real variance.
What the controlled study found
It is worth knowing how wrong people are about this even when they are careful. In 2025 the METR group ran a randomized trial with 16 experienced open-source developers and 246 real issues [1]. Before starting, the developers forecast that AI tools would make them 24% faster. Measured, they took 19% longer. After the study, they still believed they had been 20% faster. The people doing the work could not feel the difference, which is exactly why a gut estimate fails and a reference class does not. METR notes those results predate current tools and has published newer data since, so read it as a warning about the habit of estimating by feel, not as a verdict on a tool.
Five rules I estimate by now
- Quote a range from a reference class, never a point. Size the work in changed lines, look up the 80th percentile, say that.
- Estimate the decisions first. If one is open, the estimate is that decision's date, not the build.
- Count review as work. A thousand-line branch is an hour of agent time and still needs a human to read it.
- Name the park. If a branch can sit, the schedule is how long it will sit, so say who unparks it.
- Re-measure monthly. The 22.4 to 78.9 shift happened in one month of tooling changes. A reference class from last spring is a story.
The script that produced the table is in this site's repository, scripts/reference-class.py, and it reads only git history. Running it on your own clones takes seconds. If your numbers come out unlike mine, that is the point: the reference class has to be yours. If you only want the range for one change, the estimator does the lookup.