Ten times the pull requests, twenty times the wait

Q@qa-pagemcp · 6 min read · 5 things · Updated Nov 17

How ShareDot's build loop grew from pushing to main into Circuit: 2,732 PRs, nine months, one human approver.

In February we pushed straight to main and deployed by hand. In November, one person approved 182 pull requests in a week, almost all of them written by one AI and judged by another. Along the way each pull request got about twenty times slower to merge, and we think that was the right trade.

This is our own repo's history, measured: 2,838 pull requests, every label and comment on them, 6,244 CI runs and nine months of deploy records.

Five eras in nine months

1. Push to main (Feb 2 – Apr 7). No CI and no protection. 2.0 merges a day.

2. CI, but nothing enforcing it (Apr 8 – Sep 22). GitHub Actions, self-hosted runners and an automatic deploy to dev arrived in a single commit. Then nothing about the process changed for 5.5 months and 1,612 pull requests. 9.6 merges a day.

3. A ruleset and a merge queue (Sep 23 – Oct 13). Main finally got rules, and a label from a human became the only way in. 18.7 merges a day.

4. The Verifier (Oct 14 – Nov 6). A second agent reads every pull request before the human does, and the queue refuses anything without its PASS. 16.7 merges a day.

5. Circuit (Nov 7 – today). Issues as the unit of work, a PM session that never writes code, one builder per slice, and GitHub as the only channel between agents. 21.7 merges a day.

What it looked like

Pull requests merged per month:

  • ▏ 19 Feb
  • █ 58 Mar
  • ███ 143 Apr
  • █████ 265 May
  • ██████ 282 Jun
  • ██████ 316 Jul
  • ██████ 302 Aug
  • █████████ 433 Sep
  • ████████████ 579 Oct
  • ███████ 335 Nov (17 days)

Median time from open to merge, by era:

  • ▏ 16 min Push to main
  • ▏ 22 min CI only
  • █ 46 min Ruleset + queue
  • ██████ 3.6 h Verifier
  • ██████████ 5.9 h Circuit

Read those two lists together. Throughput and latency rose at the same time, and that only looks like a contradiction if a pull request is a person's afternoon. When agents write the code, a waiting pull request costs nothing but calendar time, and you can have 36 of them open at once.

The rebase relay

For 5.5 months the process had one human-shaped hole in it. An agent would open a pull request. Another would merge first. Someone had to ask each open session whether its branch needed a rebase, wait for the answer, and then press the merge button. That someone was the only human on the team, working as a message bus.

About rulesets - GitHub DocsGitHub Docs · Article

The ruleset that ended 5.5 months of unprotected main: squash only, branch up to date, two required checks.

The ruleset says a branch must be up to date with main before it merges. On its own that makes the relay worse, since every merge now invalidates every other open branch. The queue is what makes the rule livable: it takes approved pull requests one at a time, updates each, waits for CI, and squash-merges.

Both shipped within 48 hours of each other. Median label-to-merge in that era was 6.9 minutes, with no human in it.

The builder and the judge

Who wrote each month's merged pull requests:

  • May Codex 89%, Claude 9%
  • Jul Claude 80%, Codex 20%
  • Aug Codex 63%, Claude 36%
  • Sep Codex 50%, Claude 47%
  • Oct Claude 83%, Codex 12%
  • Nov Claude 85%, Codex 9%

It was never one handover. The two traded the lead three times before the roles settled. Codex wrote the merge queue. Claude wrote the Verifier. Today Claude builds and Codex judges.

Claude CodeClaude · Product

The builder: 85% of our pull requests this month.

What the judge found

By October we could merge 23 pull requests a day, and our own audit said only 28% of them were right the first time. Three in four defects we caught, we caught after the merge. The human's attention was going to rework.

So we moved the defect-finding to before the label. Since October 13 the Verifier has issued 1,652 verdicts on 639 pull requests.

  • ██████████ 873 FAIL
  • █████████ 779 PASS

More than half of all verdicts are a FAIL. Only about 4 in 10 pull requests pass on the first read. That is where the hours in the list above come from: it is the cost of finding out before your users do.

The number we would put on a slide is this one. First-read PASS rate by size of change:

  • █████████████ 81% under 100 lines
  • ███████ 46% 100 to 400
  • ████ 22% 400 to 1,000
  • ███ 18% over 1,000

A pull request that passes on its first verdict merges in 2.1 hours. One that needs four or more takes 15.1. Small changes are not a style preference. They are the difference between an afternoon and a day and a half.

Where the time goes now

Under Circuit, the life of an average pull request splits like this:

  • ████████ 34% waiting for the first verdict
  • █████████ 36% fix rounds until PASS
  • ██████ 24% waiting for the human's label
  • █ 6% queue and merge

CI is not on the list. It runs in 4 to 6 minutes at the median and fails 2 to 7% of the time.

Three things we did not expect to find:

  1. The pipeline keeps one person's hours. In nine months there is not a single merge between 5 and 10 in the morning, Bali time. The approver sleeps then, and so does the laptop the Verifier runs on.
  2. Merging outran releasing. October had 40 production releases. November has had 9, while merges set records. As we write this, 103 merged pull requests have not reached production, and the median wait from merge to prod went from 10 hours to 26.
  3. Quality only moved at the end. Our rough measure of first-time-right (no fix to the same area within 48 hours) sat between 30% and 36% through the queue and the first weeks of the Verifier. In Circuit's first 11 days it is 51%. It is early, and it is the first time the number has gone up.

What we would tell another team

  • Protect main on day one. We waited 5.5 months, and paid for it with a human relaying rebase requests between agents.
  • A queue turns a rule into a habit. "Up to date before merge" without a queue is a tax. With one, it is free.
  • Make approval one cheap gesture. Ours is a label. It can be given before the review passes, and it merges the moment everything is green.
  • Put a second model in front of the human. Expect it to fail half of what it reads, and expect that to feel slow.
  • Cap the size of a change. Under 100 lines passes four times in five. Over 400 passes one time in five.
  • Count releases, not merges. A merged pull request that is not in production has taught you nothing yet.
  • Agents should talk through the repo, not through you. Issues, labels, statuses and comments are a message bus that survives every restart.

What we are fixing next


Method: everything here comes from GitHub's own records for one private repository, February 2 to November 17, 2026. Builder attribution uses branch names and commit trailers. Verdicts are parsed from pull request comments. November is a partial month and Circuit is 11 days old, so read its numbers as early.

Made by @qa-pagemcp

Make yours