Build1 publisher3 min readPublished
A team pushing 70 to 100 pull requests a week reports a 30 to 40 percent first-pass catch rate across 4,200 PRs. The parts that travel are the file-level chunk boundary and the draft gate; the percentage stays with the stack.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
The diff gets fetched twice, in effect. `actions/checkout@v4` runs with `fetch-depth: 0` [8], which pulls the entire history, and the next step downloads the diff separately with `gh pr diff` into `pr.diff` [9]. The path shown reads the file itself rather than local git history; `ai-review.mjs` reads the file [20]. A full-history clone is a cheap habit right up until the repo is not small.
The chunk boundary is the design decision I would copy, and the stated reason is the right one: an arbitrary line split hands the model half a function, while a file split gives it one complete before and after [11]. It also sets a floor. File is the smallest unit in the split, so a single 3,000-line file stays a single request no matter how the aggregate threshold is tuned. The other throttle worth noting is the `if` block, which skips dependabot, `release/` branches and drafts [7]. The draft exclusion is the only one an author can operate directly.
What the catch rate measures is narrower than it reads. The prompt casts the model as a senior Java/Spring Boot engineer and asks for only real, high-confidence issues, with an explicit do-not-flag list starting at style preferences, minor naming and Javadoc on non-public methods [12][13]. So the denominator is issues that somebody eventually found: a defect the AI missed and no human caught is not in it. The post, up to the point where its text stops mid-prompt, gives no false-positive rate, no count of flagged issues, and no comparison against whatever linting the pipeline already ran [21]. Without a baseline, 30 to 40 percent is an improvement over an unstated starting point.
The before-state arithmetic holds up better. Four to six hours a day across five days is 20 to 30 hours a week, spread over 70 to 100 PRs. That is between about 12 and 26 minutes of senior attention per pull request [1]. Twelve minutes is roughly the time it takes to read a medium diff once, which is why the queue was producing "you forgot to close the stream" comments from an expensive reviewer [2].
One figure does not reconcile. Six months is about 26 weeks, and 100 PRs a week caps that window near 2,600. Reaching 4,200 requires roughly 162 a week [2]. Either the cadence has grown past the stated range, the measurement window is longer than six months, or the count covers more repositories than the single review queue described, and the post leaves open which of the three explains the gap.
From this I would take the file-level chunk, the draft gate, and the choice to put comments inline rather than in a summary at the bottom of the thread, which the author says gets ignored [17]. I would not take the percentage without re-measuring against my own defect mix. The claim that reviewers now spend their time almost entirely on architecture and business logic rests on the writeup's own numbers: it reports the 4 to 6 hours a day before the change but gives no equivalent figure after [22].
Ranked by verification strength, evidence, and original report placement.
Six months ago the team shipped an AI first-pass reviewer into its GitHub Actions pipeline.
The reviewer runs on every PR and posts inline comments on the diff within 90 seconds of the push.
The workflow triggers on pull_request types [opened, synchronize] for branches main and develop.
The job's if condition skips PRs where the actor is dependabot[bot], where head_ref starts with release/, and where the pull request is a draft.
The workflow checks out with actions/checkout@v4 and fetch-depth: 0.
Publishers with included, body-backed reporting in this cluster.
1 article · September 8, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
GitHub's Java agent runtime ships as a Maven dependency, and the tool schema comes from reflection1 publisher
build
Copilot's credit meter moves the cost decision into the model dropdown1 publisher
build
Partition, not consolidation: what a 43-minute Jenkins queue actually cost1 publisher
build
Copilot's extension path charges a public webhook before any skill code runs1 publisher
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Copyable config, unaudited numbers
The workflow and the prompt are printed in full, so the trigger list, the three-part skip condition, the 1,000-line branch and the do-not-flag rules can be read line by line and reproduced. The results cannot be read that way. The 30 to 40 percent catch rate, the 4,200 pull requests and the 4 to 6 hours a day all come from the same author with no method attached, and the text runs out mid-sentence inside the review script before any false-positive accounting appears.
One team's pipeline
What we can observe is one repository's workflow, running six months on the author's own account, plus the Anthropic SDK call inside it. No other team, organisation or repository in this reporting has picked up the pattern, and nobody outside the team has confirmed the pull request volume it runs on.
A percentage without its denominator
The title figure carries more weight than the reporting can hold up. A first-pass catch rate means little with no false-positive count beside it, and the arithmetic strains as well: six months at the stated cadence tops out near 2,600 pull requests, not 4,200. The transferable parts are better evidenced and more modest than the percentage, namely the file-level chunk boundary and the gate that keeps drafts and dependabot out.
Author's own system, author's own numbers
This is a practitioner write-up on dev.to with nothing on sale and no vendor relationship disclosed. The pull is reputational rather than commercial: the post exists to show that a design the author built works, and every favourable figure in it was produced and selected by the person making the argument. The self-limiting framing, that the reviewer is a filter rather than a replacement, cuts against overselling.
High on the wiring, low on the payoff
Treat the mechanics as dependable and the outcome as untested. Anyone can lift the workflow, the prompt and the chunking rule and get the same behaviour, because they are on the page. Whether a first pass configured this way catches 30 to 40 percent of anything in a different codebase is not something this reporting can establish, and the truncated text leaves the false-positive question open.