Among code review metrics, the first to read is the plainest: was this pull request reviewed by a colleague, that is, by someone who is neither its author nor a bot? DeployIt counts that for every pull request, with who opened it, who reviewed it, how long it took and the verdict (approved, changes requested). Read per developer and by quarter, the count tells you whether a second person looked at the work before it landed. It does not tell you how well they looked.
This page is for the CTO or the engineering manager who wants review figures they can explain to the team that produces them.
Last quarter, how many pull requests did each developer open, and how many were reviewed by a colleague?
Here is the quarter. A review counts when it comes from a colleague: neither the author of the pull request nor a bot.
| Developer | PRs opened | Reviewed | Reviews given |
|---|---|---|---|
| Camille R. | 41 | 36 | 52 |
| Idriss B. | 33 | 19 | 12 |
| Léa M. | 28 | 26 | 47 |
Which code review metrics are worth reading?
Review tooling produces many numbers: comments per review, lines per pull request, rounds of feedback. Most describe volume. Three describe what a manager wants to know.
Was the change seen by a second person? This is the share of pull requests reviewed by someone other than their author, and the subject of this page.
How long did it take? One public reference: Google's engineering practices guide sets one business day as the maximum time to respond to a review request, and explains that the aim is the speed of the team as a whole, not of one developer (guide, checked on 17 November 2026). It is Google's rule for Google. Take it as a point of comparison, not as a target.
How did it end? GitHub describes three outcomes for a review: a comment, an approval, or a request for changes (GitHub Docs, checked on 17 November 2026).
One caution before counting anything. A study by Bacchelli and Bird, published at ICSE in 2013, found that finding defects remains the main motivation for code review, yet reviews turn out to be less about defects than expected: they bring knowledge transfer, team awareness and alternative solutions (abstract on the Microsoft Research site, checked on 17 November 2026). A review count is not a count of bugs caught. It is evidence that the work was shared.
What does “reviewed by a colleague” count?
The rule fits in one line: a pull request is reviewed by a colleague when its reviewer is neither its author nor a bot.
The author is excluded because rereading your own work is not a second pair of eyes. GitHub applies the same logic to approvals: the author of a pull request cannot approve it (GitHub Docs, checked on 17 November 2026). Bots are excluded because an automated check does not answer the question “did someone else on the team read this?”
Two datasets carry the facts, and they are listed in the docs:
- A pull request: who opened it, who reviewed it (a colleague, not its author or a bot), and how long it took.
- A review: who reviewed which pull request, whether they are a colleague of the author, and the verdict (approved, changes requested). On GitLab, only approvals are known.
The first answers “was my work reviewed?” for the person who opens pull requests. The second answers “who reviews, and for whom?” for the person who gives reviews. A developer appears in both. Each merged commit keeps the fact as well: shipped, reviewed by a colleague or not.
As for every statistic, only work that reaches the landing branch of each repository counts, and it counts when it arrives.
What does a counted review say, and what doesn't it?
Five cases settle most of the questions a team will ask.
- A pull request merged by its author, with no other reviewer. Not reviewed by a colleague.
- A pull request approved by a bot only. Not reviewed by a colleague either.
- Approved by a colleague two minutes after it was opened. Counted. The fact says that a second person reviewed the change, and how long it took. It does not say how closely the diff was read: two minutes is plenty for a three-line fix and very little for a new module.
- Changes requested, then approved. Counted: a colleague reviewed the change, and the review carries a verdict (approved, changes requested).
- Reviewed aloud in a pairing session, with no review on the pull request. Nothing to count. DeployIt reads commits, pull requests and reviews; it does not read screens, messages or the time spent on a task. If your team works this way, the figure will be low for a reason you already know.
So a counted review says three things: a colleague reviewed, in how long, with which verdict. It says nothing about the depth of the reading, the quality of the comments or the bugs avoided.
Two other measures are read next to it. For what the merged code looks like, DeployIt has the code score. For what broke afterwards, it counts defects, “to confirm” then “confirmed”.
Why read review metrics by quarter?
Because a month is small. Example: a developer opens six pull requests in a month and merges one urgent fix alone, so their share reviewed by a colleague falls to 83%. Over a quarter with twenty pull requests, the same fix leaves it at 95%. The month tells you about one evening; the quarter tells you about a habit.
DeployIt reads the statistics by month, quarter, half-year or year. For reviews per developer, start with the quarter, and compare a team with its own previous quarter before anything else.
Two reading rules apply here too. Absences declared for a person are part of the statistics, so a thin period is read for what it is. And a closed period can still move, for example when two identities are merged into one person: every summary carries the time it was last computed.
How do you get these figures from Claude?
A person with the Leadership profile asks in plain language. Claude calls stats_schema to learn the datasets and the definition of each measure, then stats_query, a structured query (dataset, period, filters, groupings, measures, limit), and composes the table. Three questions to start with:
- “By quarter since January, what share of each developer's pull requests was reviewed by a colleague?”
- “Who reviewed whose pull requests last quarter?”
- “Which pull requests merged last month were not reviewed by a colleague?”
The developer_profile prompt returns one developer's record over a period; team_report does the same for the team. There is no dashboard to open and nothing arrives by email: the table is the one you ask for.
DeployIt tracks each developer, and the reviews a person gives are part of what is measured. The company informs the people it tracks before connecting its repositories: during the trial or on a plan, tracking starts then, with 6 months of history. Tell them what “reviewed by a colleague” counts while you are at it. Then bring the figure to the person as a question, for instance in a 1:1 anchored in what was delivered.
What DeployIt does here
DeployIt is an MCP server. Your company gets one link, https://mcp.deployit.ai/<company>/<code>; each person adds it to Claude (on the web, on the desktop or in Claude Code) and signs up with a name and an email, which is not verified; their questions are logged under that name. Everyone starts with the Everyone profile: questions about the product, answered from the code; a filter removes the code, the file paths and the names of team members it recognises from the answers, without proving their absence, and a leak test tells you what still gets through. An administrator gives the Developers profile (excerpts) or the Leadership profile (developer statistics) to whoever needs it. Repositories are connected from GitHub or GitLab; DeployIt makes no commit, branch or pull request, and only adds one webhook per repository.
The whole product, profile by profile, is described in DeployIt: ask your code and follow each developer's work from Claude.
Next step: the demo answers without statistics, so your own review figures start with the 30-day trial. Inform your team, connect your repositories, add your company link to Claude, ask an administrator for the Leadership profile, and put the question at the top of this page.
Price. Free plan: 15 questions a week for the whole company. A 30-day trial, no card. Plans from €290 a month excluding tax for up to 25 tracked developers: see pricing.
Ask your code from Claude
30-day trial, no card. Or try the demo first: add https://mcp.deployit.ai/demo to your Claude connectors.
Frequently asked questions
What are the most useful code review metrics?
Start with three: the share of pull requests reviewed by a colleague, how long the review took, and the verdict (approved, changes requested; on GitLab, approvals only). Then look at who reviews whose work, to see whether reviews rest on one or two people. DeployIt records these facts per pull request and per review, and Claude composes the table per developer and per period.
Does a self-approved pull request count as a code review?
Not in DeployIt: a review counts when it comes from a colleague, and the author of the pull request is excluded, as are bots. GitHub itself does not let an author approve their own pull request (GitHub Docs, checked on 17 November 2026). A pull request merged by its author with no other reviewer is read as not reviewed by a colleague.
Do bot reviews count as code review?
A review left by a bot is not counted as a review by a colleague in DeployIt. The measure answers one question: did a second person on the team look at this change? Automated checks are useful, and they answer a different question.
What is a good code review turnaround time?
There is no universal figure. As one public reference, Google's engineering practices guide sets one business day as the maximum time to respond to a review request (checked on 17 November 2026). DeployIt records, for each pull request, who reviewed it and how long it took; compare a team with its own previous quarter before comparing it with someone else's rule.
Should code review metrics be tracked per developer?
DeployIt tracks them per developer: the pull requests each person opened, whether a colleague reviewed them, and the reviews each person gave. The company informs the people it tracks before connecting its repositories. Read per person, the figure is a question to put to someone, with the pull requests in front of you.
Continue reading
Find the commit that introduced a bug: follow the fix back to it
For a CTO and their developers: how a fix leads back to the commit it repairs, why the defect it reveals stays “to confirm” until an administrator or an investigation confirms it, and why the last 60 days are never final.
Developer performance metrics that hold up: the ones read from merged commits
For a CTO or a CEO choosing what to measure: the per-developer metrics that hold up come from merged commits (delivered, reviewed, tested, defects, code score), and each one has limits to state.
Developer metrics in your data warehouse: one key, two MCP calls
For a data team: how to load per-developer statistics into a warehouse or a BI tool with a Data tool key. The request and its header, stats_schema then stats_query, the row limit, the cursor, and what to reread on each pass, shown as the trace of a call.