I build a pull request review tool, so I end up quoting review numbers a lot, and almost all of them are old: SmartBear’s Cisco study, Google’s one-business-day rule, a few Microsoft Research papers. None of them tell you how open source actually reviews code in 2026, with coding agents opening PRs and AI apps leaving review comments. So I pulled 10,112 merged pull requests from 103 popular GitHub repos and counted. These are the pull request review statistics I got, with the method, the per-repo data, and the parts I don’t trust.
How the data was collected
I picked repos by language: for 16 languages, the most-starred public repos with more than 8,000 stars, pushed to after November 10, 2026, not forks, mirrors or archived, and with at least 60 PRs merged in the study window. Up to 7 per language. I dropped three collections that aren’t software projects (an interview-notes repo and two algorithm collections) and three repos whose PRs are opened by a copy bot from an internal review system, where the review never happens on GitHub. That left 103 repos.
From each repo I took the 100 most recently merged PRs, merged between August 1 and November 20, 2026, through the GitHub GraphQL API on November 22, 2026. 94 repos had a full 100; 9 smaller ones had between 64 and 99. Each repo counts about equally, so a project that merges 400 PRs a day doesn’t drown out one that merges 400 a year.
The definitions, since every number below depends on them:
- A review is a submitted GitHub review (approve, request changes, or comment) from someone other than the PR author, not a bot, submitted before the merge.
- A bot is a GitHub Bot account or a login ending in “bot” or “[bot]”. Bot-authored PRs are left out of every human metric.
- Time to first review runs from when the PR was marked ready for review (or opened, if it was never a draft) to the first review. It only covers PRs that got one.
- Time to merge runs from open to merge, in wall-clock hours, weekends included.
- Review comments are the inline comments inside those reviews.
- A silent approval is a PR that was approved with no inline review comments and no request for changes.
Half of merged PRs had no review
Of 9,059 human-authored merged PRs, 4,347 (48%) had no review from anyone but the author. The median repo sat at 52%, so a few outliers aren’t driving it. 41% of all PRs had neither a review nor a single comment from another human before merge, and about half of the unreviewed PRs (49%) were merged by the person who wrote them.
Who opened the PR matters a lot. Repo owners merged 499 of their own PRs and 99% of those had no review, which is mostly single-maintainer projects shipping straight to main through a PR. For outside contributors (n = 4,335) the no-review share was 43%, for org members (n = 2,977) 47%, and for collaborators (n = 1,095) 46%. I expected outside contributors to be reviewed far more often than insiders. They were, but only by a few points.
Treat that 48% as an upper bound. Some big projects approve through bot commands in comments or through tools outside GitHub, and none of that shows up as a GitHub review. Kubernetes and rust-lang/rust both use command-driven merge bots and still show 22% and 23% of PRs with no GitHub review. More on that under limitations.
Most approvals are silent
4,365 PRs were approved, and 74% of them (3,221) were approved with zero inline comments and no request for changes. The median repo was at 77%. Only 27% of reviewed PRs got even one inline comment, and reviewers requested changes on just 7.7% of them.
A silent approval on a 12-line typo fix is fine. The problem is that the share stays high as the diff grows: 52% of approved PRs over 1,000 lines still had no inline comment (n = 376). Across every PR of 500 lines or more (n = 1,550), 24% were silent approvals and another 48% had no review at all. It’s the same pattern as rubber-stamping code review, at scale. (An approval can still carry a written summary in its body, which I didn’t count, so some of these were less silent than they look.)
Time to first review and time to merge
Among the 4,712 PRs that got a review, the median wait was 8.5 hours. 28% got one within an hour. The tail is where it hurts: 14% waited more than a week.
| Measure | Median | 75th percentile | 90th percentile | PRs |
|---|---|---|---|---|
| Time to first review | 8.5 hours | 63 hours (2.6 days) | 303 hours (12.6 days) | 4,712 |
| Time to merge | 20.4 hours | 116 hours (4.8 days) | 468 hours (19.5 days) | 9,059 |
18% of PRs merged within an hour of being opened and 7% took more than 30 days. Members and collaborators got their first review in a median 5.9 and 2.8 hours and merged in about 12.5; outside contributors waited 13.2 hours for a first review and 42.8 hours to merge. If you want a target for your own team, Google’s one business day maximum is still the one most people cite, and how long code review should take goes through why the tail matters more than the median.
Bigger PRs wait longer and get read less
I bucketed PRs by lines changed (additions plus deletions). The median PR in the sample was 71 lines; the 90th percentile was 988.
| Lines changed | PRs | Median hours to first review | Median hours to merge | Review comments per PR | Review comments per 100 lines | Silent approvals | Changes requested |
|---|---|---|---|---|---|---|---|
| Under 50 | 3,887 | 4.6 | 14.2 | 0.16 | 0.98 | 85% | 5.1% |
| 50 to 200 | 2,373 | 12.2 | 23.2 | 0.44 | 0.41 | 72% | 8.0% |
| 200 to 500 | 1,249 | 13.7 | 25.7 | 0.73 | 0.23 | 65% | 9.1% |
| 500 to 1,000 | 652 | 14.0 | 32.8 | 1.16 | 0.16 | 56% | 8.3% |
| Over 1,000 | 898 | 15.2 | 43.9 | 2.69 | 0.02 | 52% | 16.3% |
Comments per PR go up with size, about 17 times from the smallest bucket to the largest. Lines go up a lot faster. Per 100 lines changed, the smallest PRs got 0.98 comments and PRs over 1,000 lines got 0.02, roughly 50 times fewer. That 0.02 is pooled (all comments in the bucket divided by all lines), so a handful of enormous diffs pull it down; at the bucket’s median size of 1,983 lines, 2.69 comments is about 0.14 per 100 lines, which is still 7 times thinner than small PRs.
Time to first review nearly triples between the first two buckets (4.6 to 12.2 hours), then flattens. Time to merge keeps climbing, and the largest PRs are the only bucket where change requests jump (16% of reviewed PRs). So reviewers do pick big PRs up, they just don’t comment on them in proportion to their size. If you want a size target, the data backs the usual advice in how big a pull request should be.
Columns: hours to first review use only reviewed PRs (2,012, 1,254, 638, 361 and 447 by bucket). Silent approvals are a share of approved PRs (1,940, 1,163, 579, 307 and 376). Changes requested is a share of reviewed PRs.
Bots write 10% of PRs and review a quarter of them
Of all 10,112 merged PRs, 1,053 (10.4%) were opened by bots: dependency updaters, release and backport bots, and sync bots. Of the 9,059 human PRs, 23.5% got at least one review from a bot account before merge, mostly AI review apps. That varied a lot by repo: none at all in 30 of the 103 repos, more than three quarters of PRs in 17.
Bot reviews are excluded from every human metric above. A PR that only an AI reviewer looked at counts as unreviewed here, on purpose.
Pull request review statistics by language
Languages with at least 500 human PRs in the sample. Each row is 6 or 7 repos, so read it as “these projects”, not “this language”: one fast-moving repo can swing a row.
| Language | PRs | Median hours to first review | Median hours to merge | No review | Silent approvals |
|---|---|---|---|---|---|
| C | 672 | 20.2 | 66.5 | 37% | 61% |
| C# | 600 | 9.6 | 29.9 | 34% | 75% |
| C++ | 508 | 4.8 | 34.9 | 7% | 68% |
| Dart | 682 | 20.6 | 5.7 | 58% | 82% |
| Go | 645 | 11.8 | 15.0 | 52% | 76% |
| Java | 531 | 17.4 | 43.5 | 62% | 72% |
| JavaScript | 574 | 3.6 | 48.1 | 54% | 79% |
| PHP | 609 | 0.9 | 8.4 | 75% | 88% |
| Python | 564 | 5.3 | 18.9 | 36% | 73% |
| Ruby | 578 | 10.8 | 22.7 | 17% | 79% |
| Rust | 560 | 12.0 | 15.4 | 58% | 63% |
| Scala | 503 | 8.8 | 20.5 | 41% | 85% |
| Swift | 628 | 10.9 | 28.2 | 63% | 73% |
| TypeScript | 592 | 1.1 | 1.6 | 58% | 80% |
C++ stands out with only 7% unreviewed, and Ruby with 17%. Both rows are mostly large, long-running projects with many maintainers. Kotlin (419 PRs) and Elixir (394) fell under the 500-PR bar and are only in the CSV.
Cite this data
The per-repo table is free to use: pr-review-study-2026.csv (103 rows, one per repo). It has the language, PR counts, bot share, median PR size, median and 75th percentile hours to first review and to merge, the no-review, approval, silent-approval and changes-requested shares, review comments per 100 lines, the share of PRs a bot reviewed, and the merge date range each repo’s sample covers. No usernames or personal data. It’s licensed CC BY 4.0: use it for anything, with a credit and a link back to this page.
Suggested citation:
Pyor (2026). How open source reviews pull requests: data from 10,112 merged PRs. https://pyor.review/blog/pull-request-review-statistics-2026
For the older research these numbers sit next to, see code review statistics worth citing, and for what to track on your own team, code review metrics.
Limitations
- Popular open source is not your company. Private repos often require approvals through branch protection, and reviewers there are paid to do it. Expect higher review rates and shorter waits inside teams.
- GitHub only sees GitHub reviews. Approvals through comment commands, merge bots, mailing lists or a call don’t count, so “no review” overstates unreviewed code. The 41% with no review and no human comment is the stricter version.
- I counted inline comments, not the text in an approval body or in the PR conversation. A “silent” approval may still have a written note.
- Merged PRs only. Closed-without-merge PRs aren’t in the sample, so there’s no rejection rate here, and the slowest PRs, the ones still open, are missing from the merge times.
- The 100 most recent merges cover a single day in the busiest repos and the whole window in the quietest, and each repo is weighted about equally regardless of volume.
- Single-maintainer repos, a few of which made the sample, pull the no-review share up. The per-repo median (52%) is close to the pooled figure, so they don’t change the headline.
- Bot detection is a heuristic. A bot without “bot” in its name counts as a human, and a person whose login ends in “bot” counts as a bot.
- Times are wall clock, so weekends, holidays and time zones are all in there.
Frequently asked questions
How long does it take to get a pull request reviewed?
In 103 popular open source repos, the median human-authored PR that got a review waited 8.5 hours for it, counted from when it was ready for review (n = 4,712 reviewed PRs merged between August 1 and November 20, 2026). The tail is long: a quarter waited more than 63 hours and one in seven waited more than a week.
What percentage of pull requests are merged without review?
In this sample, 48% of human-authored merged PRs had no GitHub review from anyone other than the author before merge (n = 9,059). 41% had neither a review nor a comment from another human. Some of those were reviewed through comment commands or outside GitHub, so treat the figure as an upper bound on unreviewed code, not an exact count.
How many review comments does a typical pull request get?
Very few. Only 27% of reviewed PRs got a single inline review comment, and 74% of approvals came with none (n = 4,365 approved PRs). The average PR under 50 lines got 0.16 inline comments; the average PR over 1,000 lines got 2.7, which works out to far fewer comments per line changed.