<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Tess Ainsley</title>
    <description>The latest articles on DEV Community by Tess Ainsley (@tessainsley).</description>
    <link>https://dev.to/tessainsley</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4122327%2F2122a377-c50c-42f5-970f-f78721b7fa24.png</url>
      <title>DEV Community: Tess Ainsley</title>
      <link>https://dev.to/tessainsley</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/tessainsley"/>
    <language>en</language>
    <item>
      <title>GitHub's PR overview page shows gate state, not coverage</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Wed, 11 Nov 2026 14:15:07 +0000</pubDate>
      <link>https://dev.to/tessainsley/githubs-pr-overview-page-shows-gate-state-not-coverage-2nae</link>
      <guid>https://dev.to/tessainsley/githubs-pr-overview-page-shows-gate-state-not-coverage-2nae</guid>
      <description>&lt;p&gt;GitHub began rolling out an opt-in Overview page for pull requests on 5 November 2026, and the design decision behind it is worth reading closely. The page moves the merge box to the top and rebuilds it to carry the same information in less than half the space, so the first thing you see on a pull request is whether it can merge and what to do next. On a repository where agents open most of the pull requests, that summary is accurate about the gate and silent about whether anyone read the change.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://github.blog/changelog/2026-11-05-new-pull-request-overview-page-in-public-preview/" rel="noopener noreferrer"&gt;changelog&lt;/a&gt; states the goal plainly: finding what is blocking progress and working out what to do next, because time spent scrolling adds up as people review more pull requests. That is a fair description of the problem. The question worth asking is what a compact readiness summary can assert, and which of its assertions change meaning once the author is a bot and the approver is one too.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the overview page compresses
&lt;/h2&gt;

&lt;p&gt;Three things move to the top of the page. A compact view of checks, comments and approvals keeps the supporting signals nearby. The actions available to move the pull request forward sit next to it, and updating your branch is the example GitHub gives. Merge readiness and the merge control come last, in the same panel.&lt;/p&gt;

&lt;p&gt;The second part of the preview is aimed at the conversation rather than the gate. Comments can be filtered to All, Unresolved or Mine, sorted newest first, and a summary in the upper right shows recent review comments and review requests, with controls to mark a draft ready for review or close the pull request. GitHub describes the preview as a starting point and collects feedback in the &lt;a href="https://github.com/orgs/community/discussions/212186" rel="noopener noreferrer"&gt;pinned community discussion&lt;/a&gt;, and the classic overview stays available from the same menu.&lt;/p&gt;

&lt;p&gt;Read the list of signals and notice what they have in common. Checks, approvals and merge conflicts are all machine-computed states. They are the right things to compress, because they are cheap to read and unambiguous when they are correct. The ambiguity sits one layer down, in how each state got there.&lt;/p&gt;

&lt;h2&gt;
  
  
  A skipped job reports success
&lt;/h2&gt;

&lt;p&gt;GitHub's own &lt;a href="https://docs.github.com/api/article/body?pathname=/en/pull-requests/reference/status-checks" rel="noopener noreferrer"&gt;status checks reference&lt;/a&gt; says it outright: a job that is skipped reports its status as success and will not prevent a pull request from merging, even if it is a required check. That is how required checks work rather than a quirk of one reviewer, and it means the readiness summary can show a green from a check whose work never happened.&lt;/p&gt;

&lt;p&gt;For a human-written pull request that rarely matters, because the human skipped it and knows why. On an agent-heavy repository it matters more. A review job skipped for a path filter, a size limit, a draft state or an author exemption reports the same green as a review job that read the diff. The summary at the top of the page does not distinguish them, and that summary is now the first thing a reviewer reads, above the diff and above the conversation where the reason is written down.&lt;/p&gt;

&lt;p&gt;This is the same failure mode I looked at across providers in &lt;a href="https://agentwrotethis.dev/blog/what-your-merge-gate-sees-when-the-ai-review-never-ran/" rel="noopener noreferrer"&gt;what a merge gate sees when the AI review never ran&lt;/a&gt;, where CodeRabbit documents that its Skipped and Rate limited states both count as passing for a required check. GitHub's documentation says the equivalent thing about any skipped job. Putting the result at the top of the page makes it more legible without making it more informative.&lt;/p&gt;

&lt;h2&gt;
  
  
  The action the summary offers can discard the approvals it counts
&lt;/h2&gt;

&lt;p&gt;There is a sharper interaction between two documented behaviours. The overview page lists updating your branch as an action to take when something is blocking. Separately, GitHub's &lt;a href="https://docs.github.com/api/article/body?pathname=/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches" rel="noopener noreferrer"&gt;branch protection documentation&lt;/a&gt; says that with stale approval dismissal enabled, an approving review is dismissed when the diff changes, and it names clicking Update branch as one of the ways the diff changes.&lt;/p&gt;

&lt;p&gt;So the readiness summary can present two true statements in sequence. The approval count is met, and here is the button to bring the branch up to date. Pressing it can reset the first one, and a follow-up push from an agent does the same thing without anyone pressing anything. GitHub documents a narrower alternative on the same page: requiring that the most recent reviewable push be approved by someone other than the person who pushed it. That setting avoids dismissing every stale approval on a long-running pull request, which is exactly the shape agents produce when a follow-up commit lands after the approval.&lt;/p&gt;

&lt;p&gt;None of this is a defect in the overview page. It is what happens when a summary of gate state is presented as the answer to whether a change can merge, because gate state is a snapshot and the actions in the same panel are what move it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What each reviewer's state looks like in that panel
&lt;/h2&gt;

&lt;p&gt;The summary reads whatever your checks and reviews report, so the useful question is what each tool posts and whether that artifact has a state which passes without work.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;What it posts&lt;/th&gt;
&lt;th&gt;Distinct state for "did not run"&lt;/th&gt;
&lt;th&gt;Approval default&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot code review&lt;/td&gt;
&lt;td&gt;A review with High, Medium or Low severity labels on each comment&lt;/td&gt;
&lt;td&gt;Not documented as a separate check state&lt;/td&gt;
&lt;td&gt;Comment review, which does not count toward required approvals until the repository enables approving reviews and counting them&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit&lt;/td&gt;
&lt;td&gt;A check run on GitHub when review progress is on, a commit status otherwise&lt;/td&gt;
&lt;td&gt;Yes on GitHub, Skipped and Neutral; GitLab, Azure DevOps and Bitbucket have no skipped or neutral state&lt;/td&gt;
&lt;td&gt;Request-changes workflow off by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus&lt;/td&gt;
&lt;td&gt;Emoji reactions on the pull request, with the status posted as a comment where reactions are unavailable&lt;/td&gt;
&lt;td&gt;No check to require, so nothing to pass; the skipped state is a reaction&lt;/td&gt;
&lt;td&gt;Non-blocking by default, auto-approve optional&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Copilot's &lt;a href="https://docs.github.com/api/article/body?pathname=/en/copilot/how-tos/use-copilot-agents/request-a-code-review/use-code-review" rel="noopener noreferrer"&gt;usage documentation&lt;/a&gt; states that its reviews default to a Comment review and do not count toward required approvals, and that approving reviews are off until a repository enables them and lets them count. There is a second detail worth knowing on a bot-authored pull request: when Copilot re-reviews, it may repeat comments you already resolved or downvoted. The unresolved filter on the new page will surface those again, which is honest, and it also means an unresolved count is a count of open questions rather than a measure of what was read.&lt;/p&gt;

&lt;p&gt;Kodus goes the other way and gives up the check entirely. Its &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/flow.md" rel="noopener noreferrer"&gt;review flow documentation&lt;/a&gt; reports status as reactions, a rocket while working and a party emoji on completion, with eyes for a skipped run and a thumbs-down when the author has no license. Native reactions work on GitHub, GitLab and Forgejo, and on Azure DevOps and Bitbucket the status arrives as a comment instead. The consequence is that a Kodus review cannot be a required check, so it never contributes a green to the readiness summary, and it also cannot contribute a false one. Its &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/policy.md" rel="noopener noreferrer"&gt;review policy&lt;/a&gt; starts from non-blocking suggestions and recommends turning on blocking behaviour only after the team has agreed thresholds and has CI it trusts.&lt;/p&gt;

&lt;p&gt;Those are different trades rather than better and worse. If you want the reviewer inside the merge gate, Copilot and CodeRabbit can be there and Kodus cannot. If you want a review that cannot be mistaken for a gate, Kodus is the one of the three that is structurally unable to be one. The &lt;a href="https://agentwrotethis.dev/blog/which-ai-reviewer-approvals-satisfy-your-merge-requirement/" rel="noopener noreferrer"&gt;approval toggles and path globs&lt;/a&gt; that decide whether a bot approval clears branch protection are a separate setting from anything the summary shows.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to add to your gate
&lt;/h2&gt;

&lt;p&gt;The readiness summary is a gate-state view. Treating it as a coverage view is the mistake, and it is cheap to correct.&lt;/p&gt;

&lt;p&gt;List your required checks and, for each one, ask whether it has a passing state that requires no work to reach. If it does, the summary can be green over an unread change, and no amount of compactness at the top of the page will tell you. Any check that fits that description needs a companion assertion.&lt;/p&gt;

&lt;p&gt;Make coverage its own check. Instead of trusting the reviewer's check to mean the reviewer ran, add a check that fails when the review artifact is absent from the pull request. Presence is the thing to assert, because a skipped job reports success, so a pass or fail signal from the reviewer's own check cannot answer the question. A coverage check that reads the artifact directly can.&lt;/p&gt;

&lt;p&gt;Decide the stale approval question on purpose. The Update branch action sits next to the approval count, so whether updating the branch should clear the approvals is a decision you want made in the repository settings rather than discovered during a merge. The last-reviewable-push option is the narrower setting for long-running pull requests.&lt;/p&gt;

&lt;p&gt;Read the unresolved count as a question count. It tells you how much conversation is still open, which is useful, and it says nothing about how much of the diff a machine or a person actually examined. That distinction is the one the compact panel cannot carry, and on a repository where agents write most of the code, it is the one worth keeping in a separate check.&lt;/p&gt;

</description>
      <category>codereview</category>
      <category>aicodereview</category>
      <category>github</category>
      <category>pullrequests</category>
    </item>
    <item>
      <title>Reviewing the growing volume of AI-generated code</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Mon, 09 Nov 2026 01:15:01 +0000</pubDate>
      <link>https://dev.to/tessainsley/reviewing-the-growing-volume-of-ai-generated-code-3964</link>
      <guid>https://dev.to/tessainsley/reviewing-the-growing-volume-of-ai-generated-code-3964</guid>
      <description>&lt;p&gt;Two things break at once when agents write most of the code. The number of changes goes up, and each change gets smaller, so the total surface a team has to judge grows while any single diff looks less worth a slow read. The reflex is to make review faster. That does not scale, because the work that grows is not reading speed, it is the count of decisions about whether a change is correct.&lt;/p&gt;

&lt;p&gt;The number that decides whether a team keeps up is not lines of code. It is how many changes a person has to judge. LinearB's &lt;a href="https://linearb.io/library/ai-in-software-development" rel="noopener noreferrer"&gt;2026 software engineering benchmarks&lt;/a&gt;, drawn from more than 8.1 million pull requests, put agentic pull requests at a median of 89 lines and 293 lines at the 75th percentile, against 157 lines for unassisted work at the same percentile. They also wait: 17.6 hours at the 75th percentile before review starts, against 3.4 hours for unassisted changes. Smaller and more numerous is the harder shape to review, and it is the shape the volume question is really about.&lt;/p&gt;

&lt;p&gt;There is a ceiling on how far the tooling side can be stretched before it starts metering the very activity that created the volume, which is what &lt;a href="https://agentwrotethis.dev/blog/the-review-throughput-ceiling-that-pricing-pages-leave-out/" rel="noopener noreferrer"&gt;the per-developer refill rates and file caps on the pricing pages&lt;/a&gt; describe. Adding reviewers and raising limits treats the symptom. The part of review that actually has to change is what each review is checked against.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why more volume does not yield to faster reading
&lt;/h2&gt;

&lt;p&gt;A reviewer reading a diff answers one question: does this code look right. That question scales badly, because it is answered from scratch on every change and its cost is proportional to the size of the change. At 89 lines it is cheap. At 293 lines, multiplied across a week of agent output, it is the bottleneck, and it is the reason a queue needs a ranker at all, since &lt;a href="https://agentwrotethis.dev/blog/what-your-review-queues-ranker-can-and-cannot-see/" rel="noopener noreferrer"&gt;what a ranker can and cannot see&lt;/a&gt; is a separate problem from how many changes arrive.&lt;/p&gt;

&lt;p&gt;A reviewer checking a change against its requirement answers a different question: does this code do what it was asked to do. That question has a fixed reference point, so the answer is a finite list of items marked as delivered or not, and it does not grow with the size of the diff. It grows with the number of requirements, which the task already fixes. For a stream of small agent changes, that is the difference between judging each diff on its own merits and closing out a checklist.&lt;/p&gt;

&lt;p&gt;The catch is that the requirement has to reach the reviewer. If the tool never sees the task, it can only tell you about the diff, and you are back to reading.&lt;/p&gt;

&lt;h2&gt;
  
  
  Three ways the requirement reaches a review
&lt;/h2&gt;

&lt;p&gt;Every reviewer that supports this takes the requirement from one of a few places, and the choice decides how much of the mechanism works.&lt;/p&gt;

&lt;p&gt;The first is the pull request text. CodeRabbit's &lt;a href="https://docs.coderabbit.ai/issues/pr-validation.md" rel="noopener noreferrer"&gt;linked issue validation&lt;/a&gt; looks for references in the description using platform syntax such as &lt;code&gt;fixes #123&lt;/code&gt; or &lt;code&gt;closes #123&lt;/code&gt; on GitHub, and full tracker URLs for Jira and Linear. On Azure DevOps it also reads work items attached through the platform's native Development interface, and it will use up to 200 valid linked work items, dropping deleted or permission-restricted ones without discarding the rest. The assessment is one of three states: addressed, not addressed, or unclear. Comments and discussion threads on the issue are not analyzed, so anything decided in a thread is invisible to the check.&lt;/p&gt;

&lt;p&gt;The second is the tracker, read by id. Kodus's &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/business_logic_validation.md" rel="noopener noreferrer"&gt;Business Logic Validation&lt;/a&gt; finds the task in the pull request title, branch name, or description, in that order, and reads it from a connected tracker such as Linear, Jira, Notion, or Git Issues. A reference only counts once the tracker returns a task with that exact id, which is what stops a title containing &lt;code&gt;UTF-8&lt;/code&gt; or &lt;code&gt;gpt-5&lt;/code&gt; from being read as a ticket. It checks up to three tasks per pull request, follows a parent task and sub-tasks, and reports each requirement as MET, PARTIAL, MISSING, CHECK MANUALLY, or NOT IN TASK, with the file and line each row is based on. Without a tracker, the task text can be pasted into the command instead.&lt;/p&gt;

&lt;p&gt;The third is no requirement at all. GitHub Copilot code review reviews the diff against the repository's custom instructions and a review effort level, and its &lt;a href="https://docs.github.com/en/copilot/how-tos/copilot-on-github/set-up-copilot/configure-code-review" rel="noopener noreferrer"&gt;configuration documentation&lt;/a&gt; describes no input that carries what the change was asked to do. The concept page for &lt;a href="https://docs.github.com/en/copilot/concepts/agent-capabilities/agent-powered-workflows-and-operations/code-review" rel="noopener noreferrer"&gt;Copilot code review&lt;/a&gt; does not describe one either, so from what GitHub publishes, whether Copilot checks a change against its task is unknown. That is a statement about the documentation, not about the product's internals.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who is allowed to close a gap
&lt;/h2&gt;

&lt;p&gt;A requirement check produces a list of gaps. The next question is what a gap costs, and that is a policy decision the vendor either implements or leaves to you.&lt;/p&gt;

&lt;p&gt;CodeRabbit's linked-issue assessment reports a state and does not document a per-requirement closure, so a reviewer who disagrees with a finding has the comment thread and the label mechanism, and Slop Detection in particular does not block a merge: when a pull request is classified as slop, a warning is added to the walkthrough comment and, on some platforms, a label, which maintainers triage at their discretion. Kodus implements closure explicitly. A gap can be marked ACCEPTED by someone other than the pull request's author, with the required permission depending on the platform, and the acceptance persists on later re-checks as long as the task's text is unchanged. Once the task is edited, the requirement has to be accepted again. The &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/policy.md" rel="noopener noreferrer"&gt;review policy documentation&lt;/a&gt; is clear that Kody does not replace human judgment, and the comment is a signal rather than a status check, so it never blocks a merge by itself.&lt;/p&gt;

&lt;p&gt;That distinction matters more than it looks. If the author can accept their own gap, the check is advisory and the first time a change is close to shipping, the gap gets accepted to clear the list. Requiring a second person turns the same mechanism into a decision that leaves a record of who made it, which is the same question that governs &lt;a href="https://agentwrotethis.dev/blog/which-ai-reviewer-approvals-satisfy-your-merge-requirement/" rel="noopener noreferrer"&gt;whose approval satisfies a merge requirement&lt;/a&gt; and &lt;a href="https://agentwrotethis.dev/blog/what-an-agents-fix-commit-does-to-the-approval-you-already-gave/" rel="noopener noreferrer"&gt;what happens when an agent's fix commit lands after an approval&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The tools side by side
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Reviewer&lt;/th&gt;
&lt;th&gt;How the requirement reaches review&lt;/th&gt;
&lt;th&gt;States reported&lt;/th&gt;
&lt;th&gt;Who may close a gap&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit&lt;/td&gt;
&lt;td&gt;Linked issues in the PR description (&lt;code&gt;fixes #123&lt;/code&gt;, &lt;code&gt;closes #123&lt;/code&gt;, tracker URLs); native linked work items on Azure DevOps; up to 200 work items&lt;/td&gt;
&lt;td&gt;Addressed, Not addressed, Unclear&lt;/td&gt;
&lt;td&gt;No documented per-requirement closure; Slop Detection labels and warns without blocking&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot code review&lt;/td&gt;
&lt;td&gt;No requirement input described in its docs; reviews the diff against repository custom instructions and a review effort level&lt;/td&gt;
&lt;td&gt;Unknown from its published documentation&lt;/td&gt;
&lt;td&gt;Unknown from its published documentation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus&lt;/td&gt;
&lt;td&gt;Task found by id in PR title, branch, or description and read from a connected tracker; up to three tasks per PR; task text can be pasted directly&lt;/td&gt;
&lt;td&gt;MET, PARTIAL, MISSING, CHECK MANUALLY, NOT IN TASK, each citing file and line&lt;/td&gt;
&lt;td&gt;ACCEPTED by a reviewer other than the PR author (write access on GitHub, Developer or above on GitLab, org member on Bitbucket, Azure Repos, Forgejo); persists while the task text is unchanged&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two more properties decide how the check behaves in practice. CodeRabbit re-checks a labeled pull request on subsequent reviews, so the same finding can reappear and is cleared when a completed analysis finds nothing. Kodus re-checks on the first review and then only on a comment or a forced review by default, with an option to re-check on each push while something is missing, and each re-check is another validation. That cadence is the cost side of the mechanism, and it is the thing to set deliberately rather than leave on the default.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to do before you turn this on
&lt;/h2&gt;

&lt;p&gt;Four things are worth checking, in order, because each one decides whether the next one does anything.&lt;/p&gt;

&lt;p&gt;Confirm the reviewer takes a requirement as input at all. A tool that only reads the diff can only report on the diff, however good its model is, and no amount of prompt tuning changes that.&lt;/p&gt;

&lt;p&gt;Count how many of your pull requests name a task. The mechanism binds to a reference the tracker can resolve, so a repository whose titles and branches carry no ticket keys gives it nothing to work with, and the check silently does nothing useful.&lt;/p&gt;

&lt;p&gt;Decide who may close a gap before you enable re-checks. If the author can accept their own gap, expect the list to clear itself under shipping pressure, and treat the check as a prompt rather than a gate.&lt;/p&gt;

&lt;p&gt;Set the re-check cadence against your volume, not the default. Re-checking on every push while a requirement is missing is one validation per push, which is the same arithmetic that makes incremental review on each push expensive in the first place.&lt;/p&gt;

&lt;p&gt;None of this removes the need to read code. It changes which part of review grows with volume and which part stays fixed, and that is the part worth engineering when agents are writing most of the changes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Common questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  How do you review a large volume of AI-generated code without adding reviewers?
&lt;/h3&gt;

&lt;p&gt;Change what each review is checked against. When changes are numerous and small, reading each diff closely does not scale, but checking each change against the requirement it claims to satisfy does, because the requirement is a fixed reference and the gap between it and the code is a finite list. CodeRabbit does this through linked issues, and Kodus does it through Business Logic Validation against a task read from a connected tracker. GitHub Copilot code review does not take a task as input, so from its published documentation the requirement check is unknown.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does an AI reviewer know what a pull request was supposed to do?
&lt;/h3&gt;

&lt;p&gt;Only if the tool takes the requirement as an input. CodeRabbit reads linked issues from the pull request text (&lt;code&gt;fixes #123&lt;/code&gt;, &lt;code&gt;closes #123&lt;/code&gt;) or, on Azure DevOps, native linked work items, and reports each as addressed, not addressed, or unclear. Kodus finds the task by its id in the pull request title, branch name, or description, reads it from the tracker, and reports each requirement as MET, PARTIAL, MISSING, CHECK MANUALLY, or NOT IN TASK. Copilot's documentation does not describe a requirement input, so the answer there is unknown.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can a developer accept their own missing requirement?
&lt;/h3&gt;

&lt;p&gt;In Kodus, no. A gap can be marked ACCEPTED only by someone other than the pull request's author who has write access on GitHub, Developer or above on GitLab, or is a member of the organization on Bitbucket, Azure Repos, and Forgejo. The acceptance persists on later re-checks while the task text is unchanged. CodeRabbit's linked-issue assessment reports a state but does not document a per-requirement closure, and Copilot does not document one.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>codereview</category>
      <category>programming</category>
      <category>pullrequests</category>
    </item>
    <item>
      <title>Large vs complex pull requests: which review limit binds</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Fri, 06 Nov 2026 16:30:01 +0000</pubDate>
      <link>https://dev.to/tessainsley/large-vs-complex-pull-requests-which-review-limit-binds-1fle</link>
      <guid>https://dev.to/tessainsley/large-vs-complex-pull-requests-which-review-limit-binds-1fle</guid>
      <description>&lt;p&gt;Two different limits decide what an AI reviewer actually read on the change you are about to approve, and only one of them usually has a number next to it. The first is size: how many files, bytes and lines the tool will assemble into a reviewable diff. The second is scope: how far outside that diff the reviewer will travel to find the evidence a finding depends on. A 2,500-file lockfile regeneration is large and simple. A 20-line change to an error code that a service in another repository matches on is small and complex.&lt;/p&gt;

&lt;p&gt;CodeRabbit publishes hard numbers for the point where it stops assembling a diff. GitHub prices a review by size through its effort levels. Kodus bounds which findings get posted and how many files it will read. A large change can come back incomplete from all three, and the shape of the incompleteness differs each time. Every figure below comes from the vendor's own documentation, linked where it appears, or from a benchmark that publishes its method.&lt;/p&gt;

&lt;p&gt;The volume this runs against is not hypothetical. The &lt;a href="https://arxiv.org/abs/2608.25730" rel="noopener noreferrer"&gt;MalPR-Bench paper&lt;/a&gt; cites GitHub's own reporting that monthly commit volume more than doubled from 1.4 billion to 2.9 billion between April and August 2026, with merged pull request volume approaching 130 million a month. That is the queue this reading surface sits in front of.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the reading surface is the thing that breaks first
&lt;/h2&gt;

&lt;p&gt;An agent task that touches 400 files is not unusual. It refactors a module, updates its tests, regenerates a lockfile, and edits a few configs in the same commit. The review of that change happens on an artifact the review tool assembles: a diff, a summary, a set of comments. That assembly step is where the first hard limits show up, and they are usually smaller than people assume.&lt;/p&gt;

&lt;p&gt;This matters because the artifact is the whole basis for the decision. If the tool refuses part of the diff or narrows what it will comment on, the human reading the pull request is still approving the same commit. Nothing in the merge button changes to reflect that less of the change was examined.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the diff stops being assembled
&lt;/h2&gt;

&lt;p&gt;CodeRabbit's &lt;a href="https://docs.coderabbit.ai/change-stack/reading-diffs.md" rel="noopener noreferrer"&gt;Change Stack&lt;/a&gt; reads a GitHub pull request through the provider's compare API until the change is large enough to defeat it, then switches to a raw diff with hard bounds. The compare path stops being used at 300 files. Past that, the raw diff has its own ceiling, and the &lt;a href="https://docs.coderabbit.ai/change-stack/provider-support.md" rel="noopener noreferrer"&gt;provider support page&lt;/a&gt; lists it: a diff is refused once the change passes 10,000 files, 20 MiB of retained patches, a single line over 1 MiB, or a fetch that takes longer than 10 seconds. Past those numbers the diff material for that artifact is not recoverable through that path, and the refusal is explicit rather than a quiet truncation.&lt;/p&gt;

&lt;p&gt;A second bound is easier to miss because it only applies to added and deleted files. Expanding context adds 20 lines at a time, and expansion becomes unavailable once the available content passes 200,000 characters. You still get the diff hunks for those files. What you lose is the surrounding unchanged lines, which on a large generated file is often where a mistake becomes legible. Modified files are exempt from that limit as long as both the old and the current content can be loaded.&lt;/p&gt;

&lt;p&gt;Nothing above is a claim about a model or a context window. These are artifact assembly limits, so a change that crosses one produces a differently shaped reading surface. The reviewer still runs. The artifact you are reading is not the same one.&lt;/p&gt;

&lt;h2&gt;
  
  
  The effort level is the price of a bigger diff
&lt;/h2&gt;

&lt;p&gt;GitHub documents &lt;a href="https://docs.github.com/en/copilot/concepts/agent-capabilities/agent-powered-workflows-and-operations/code-review" rel="noopener noreferrer"&gt;Copilot code review&lt;/a&gt; as three effort levels with estimated AI credit consumption per review. Lite runs $0.05 to $1, averaging $0.25. Balanced runs $0.25 to $5, averaging $1.50. Max runs $1.50 to $25, averaging $10. The same page states that consumption generally increases with pull request size and with repository custom instructions, and that the estimates exclude GitHub Actions minutes.&lt;/p&gt;

&lt;p&gt;Those minutes are a separate line because the agentic capabilities execute on runners: full project context gathering, and passing suggestions to the cloud agent. Standard GitHub-hosted runners are the default, larger runners bill at a higher per-minute rate, and self-hosted runners do not consume Actions minutes. If Actions is unavailable or a workflow fails, the review still generates without the agentic capabilities. A large pull request reviewed during an Actions incident gets the reduced path, and nothing in the review comment itself announces that it did.&lt;/p&gt;

&lt;p&gt;The cost model is where size stops being only a reading problem. On Copilot, a bigger diff is paid for, and the price of looking closely is the effort level you set. That connects to the &lt;a href="https://agentwrotethis.dev/blog/the-review-throughput-ceiling-that-pricing-pages-leave-out/" rel="noopener noreferrer"&gt;review throughput ceiling that pricing pages leave out&lt;/a&gt;, where the per-review price is only one of the limits a team runs into.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the finding stops being posted
&lt;/h2&gt;

&lt;p&gt;Kodus draws its bound at the output instead of the input. Every suggestion carries a severity and only those at or above the level you pick get posted, with Medium as the default. Kody still finds the lower-severity issues, it just does not comment on them. A separate toggle decides whether the threshold applies to Kody Rules, and it is off by default, so a rule your team wrote is reported whatever severity it lands on. The vendor's own &lt;a href="https://docs.kodus.io/en/knowledge_base/how-to-reduce-code-review-noise.md" rel="noopener noreferrer"&gt;noise guide&lt;/a&gt; notes that noise on a big pull request is usually a severity problem rather than a volume problem. That is the same layer question covered in &lt;a href="https://agentwrotethis.dev/blog/reduce-review-noise-which-layer-each-reviewer-turns-down/" rel="noopener noreferrer"&gt;which layer each reviewer turns down&lt;/a&gt;, applied to size.&lt;/p&gt;

&lt;p&gt;Kodus also bounds the input. Its &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/troubleshooting.md" rel="noopener noreferrer"&gt;troubleshooting page&lt;/a&gt; states that Kody reviews pull requests with up to 2,000 reviewable files after ignored-file patterns are applied, with the worked example of a 2,500-file pull request where 600 are &lt;code&gt;.lock&lt;/code&gt; files and the remaining 1,900 are reviewed. A pull request past the configured file limit is skipped rather than partly reviewed. The severity default and the rule-bypass toggle live in &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/configs/suggestion_control.md" rel="noopener noreferrer"&gt;the severity threshold settings&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where each documented bound sits
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Limit&lt;/th&gt;
&lt;th&gt;CodeRabbit (Change Stack)&lt;/th&gt;
&lt;th&gt;GitHub Copilot code review&lt;/th&gt;
&lt;th&gt;Kodus&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;What the bound limits&lt;/td&gt;
&lt;td&gt;Diff assembly for the reading artifact&lt;/td&gt;
&lt;td&gt;Cost and effort per review&lt;/td&gt;
&lt;td&gt;Which findings get posted, and which files are read&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Documented limit&lt;/td&gt;
&lt;td&gt;Compare API at 300 files; raw diff refused past 10,000 files, 20 MiB retained patches, 1 MiB per line, or a 10s fetch&lt;/td&gt;
&lt;td&gt;Effort levels Lite/Balanced/Max, consumption rising with PR size&lt;/td&gt;
&lt;td&gt;Minimum severity, default Medium; up to 2,000 reviewable files after ignored patterns&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Behavior past the bound&lt;/td&gt;
&lt;td&gt;Diff refused, not silently truncated&lt;/td&gt;
&lt;td&gt;Review still generated, less context, lower effort&lt;/td&gt;
&lt;td&gt;Findings below the level are still detected, not commented; PR past the file limit is skipped&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Second bound&lt;/td&gt;
&lt;td&gt;Context expansion unavailable past 200,000 characters on added/deleted files&lt;/td&gt;
&lt;td&gt;Agentic capabilities need Actions; reduced review if unavailable&lt;/td&gt;
&lt;td&gt;Threshold can apply to Kody Rules (off by default)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Where it is documented&lt;/td&gt;
&lt;td&gt;change-stack/provider-support&lt;/td&gt;
&lt;td&gt;copilot concepts, code review&lt;/td&gt;
&lt;td&gt;troubleshooting and suggestion_control&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Where the evidence the review needs actually lives
&lt;/h2&gt;

&lt;p&gt;A size bound and a context bound are different limits, and only one of them usually has a number next to it. A reviewer that reads the changed files and nothing else will still produce a finding on a small pull request whose justification lives two files away. That failure does not scale with the size of the change, which is why a documented file ceiling tells you very little about whether the review was sound.&lt;/p&gt;

&lt;p&gt;MalPR-Bench measures this directly. The benchmark holds 89 malicious pull requests and 50 benign controls across 44 repositories and eight language families. Each malicious case carries a rubric frozen before any reviewer ran, naming the target vulnerability, the mechanism descriptions that count as a correct diagnosis, and the repository evidence required to establish it. Reviews are then scored on three things separately: whether the change was blocked, whether the target vulnerability was identified, and whether the evidence was cited. A block only counts as attributable when all three hold.&lt;/p&gt;

&lt;p&gt;That separation is the paper's point. A block can be triggered by an unrelated issue, so fixing what was reported can leave the actual defect exploitable. The authors call this the Verdict-Diagnosis gap, and it is the reason a detection rate and a review rate are not the same measurement.&lt;/p&gt;

&lt;p&gt;The taxonomy is the part worth stealing. Let C be the changed lines and T the set of files the pull request touches:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;L0: the finding can be justified from the changed lines alone.&lt;/li&gt;
&lt;li&gt;L1: it also needs unchanged code in another file the pull request touched.&lt;/li&gt;
&lt;li&gt;L2a: it needs code outside the touched set, connected by a call or an import.&lt;/li&gt;
&lt;li&gt;L2b: it needs code outside the touched set, connected only by semantic correspondence, such as a sibling endpoint or an equivalent handler.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;On 31 held-out malicious pull requests, an attributable reviewer and a widely deployed commercial reviewer blocked nearly the same number of changes, 22/31 against 24/31. They did not diagnose the same number. The attributable reviewer identified 22 target vulnerabilities against 16, a 1.38x difference, and the split lands almost entirely on evidence location: the commercial reviewer identified 16 of 24 targets when the required evidence sat in the changed lines or another touched file, and 0 of 7 when it did not. On absence-type cases, where a required guard or ownership check is missing, both blocked 9 of 14, and the attributable reviewer identified 9 targets against 3.&lt;/p&gt;

&lt;p&gt;Two caveats belong with those numbers. MalPR-Bench is a preprint, not peer reviewed, and the commercial baseline is black box: its model, inference configuration and intermediate reasoning are not disclosed, so the results describe end-to-end product output rather than a design choice. It is one configuration, not a sweep.&lt;/p&gt;

&lt;p&gt;Kodus documents the L2a case from the other end. Its &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/business_logic_validation.md" rel="noopener noreferrer"&gt;Business Logic Validation&lt;/a&gt; page states that when a rule lives in code the pull request calls but did not change, such as a validator, a helper or the mapper that builds a response, Kody reads it in the repository at the pull request's head before anything is shown, and does the same for every MISSING, PARTIAL and CHECK MANUALLY row. A row turns MET only on a file and line Kody read. A row turns MISSING only when Kody read the code the pull request relies on and can cite the line that lacks the rule. That is a documented answer to the L2a question, and it is the kind of statement to look for rather than a percentage.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to check on your own pipeline
&lt;/h2&gt;

&lt;p&gt;The useful move is to find out which bound your review path hits first, and whether it fails loudly. Two checks cover most of it. Take a recent large change and confirm which of the documented limits it reached before a human read it. Then confirm whether anything in the pull request told the reviewer that the reading surface changed.&lt;/p&gt;

&lt;p&gt;A refused diff and a silent severity filter both end with a comment on the pull request, and neither is visible in a green check. The difference is whether a human was told the coverage changed. Change Stack refuses rather than truncating, which at least leaves a signal at the artifact. A severity threshold never announces itself, because the findings it drops were never posted.&lt;/p&gt;

&lt;p&gt;The second check is the one that catches the changes that matter. Sort the last twenty pull requests your reviewers sent back by where the reviewer had to look to justify the objection: the changed lines, another touched file, a file reached by a call or an import, or a file with no structural link at all. That last group is where a diff-only reviewer is guessing, and it is the group worth spending a linking setting on. A small pull request can sit in that group, which is the same reason a cross-repository change is a context problem rather than a &lt;a href="https://agentwrotethis.dev/blog/multi-repo-ai-review-a-context-problem-not-a-volume-problem/" rel="noopener noreferrer"&gt;volume problem&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;One more setting is worth reading before the next large agent change lands. The coding-agent instruction files your team already writes for agents are read on the review side too, with a documented cap of 8 files and 64 KB per review and a longer file cut rather than skipped. Which files get read, and whether the review says so, is compared in &lt;a href="https://agentwrotethis.dev/blog/which-of-your-rule-files-the-reviewer-actually-reads/" rel="noopener noreferrer"&gt;which of your rule files the reviewer actually reads&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;None of this argues against buying a hosted reviewer. The kernel-scale projects can afford a falsification stage because the domain is narrow and the ground truth exists in git history. A general review tool runs on every pull request, in whatever language, on a repository it did not train on, and has to produce a comment a human can act on within minutes. What a buyer can still ask for is the method behind any number on the page, and a plain statement of where the tool stops. GitHub documents its effort levels, the estimated credit consumption per review, and the fallback when the agentic path cannot run. That is the standard to hold the rest to.&lt;/p&gt;

&lt;p&gt;The distinction to carry into the next evaluation is between the two limits. Asking how large a diff a reviewer accepts is easy to answer and rarely binds in practice. Asking how far outside the diff it will read to justify a finding is harder to answer, and it binds on exactly the changes where a wrong approval is expensive. A pull request can be small and still need evidence from outside the touched files. A large one can be entirely readable from the diff. Size is a number you can compare across tools today; evidence scope is the one that predicts whether the review was real.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>pullrequests</category>
      <category>agenticcoding</category>
    </item>
    <item>
      <title>What an agent's fix commit does to the approval you already gave</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Wed, 04 Nov 2026 14:15:05 +0000</pubDate>
      <link>https://dev.to/tessainsley/what-an-agents-fix-commit-does-to-the-approval-you-already-gave-1m2c</link>
      <guid>https://dev.to/tessainsley/what-an-agents-fix-commit-does-to-the-approval-you-already-gave-1m2c</guid>
      <description>&lt;p&gt;An approval is bound to a specific diff, and the platform records which one. Push a commit that changes that diff and the approval stops counting toward the merge requirement, whether a person or an agent wrote the commit. That rule lives in branch protection or project settings, it is on by default in some places and off in others, and it decides how many times a human has to read the same change before it lands.&lt;/p&gt;

&lt;p&gt;The reason it matters more now is the shape of the fix loop. When an agent is asked to address review comments, it pushes. When it pushes and the diff changes, the review it was responding to is no longer valid as an approval. On a repository where most changes come from agents, that loop can send the same pull request past a human several times, and the second and third reads are what show up in review time while looking like the same change.&lt;/p&gt;

&lt;h2&gt;
  
  
  The approval is bound to a diff
&lt;/h2&gt;

&lt;p&gt;GitHub states the mechanism in the &lt;a href="https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/managing-protected-branches/about-protected-branches" rel="noopener noreferrer"&gt;protected branch documentation&lt;/a&gt;. GitHub records the state of the diff at the point a pull request is approved, and that state is the set of changes the reviewer approved. If the diff changes from that state, the approving review is dismissed as stale and the pull request cannot merge until someone approves again. The documented triggers include a contributor pushing new changes, clicking Update branch, and a related pull request merging into the target branch.&lt;/p&gt;

&lt;p&gt;GitLab starts from the same position with a different default. An approval is removed when more changes are added after the approval, and GitLab uses &lt;a href="https://docs.gitlab.com/user/project/merge_requests/approvals/settings/" rel="noopener noreferrer"&gt;git patch-id to compare the new diff against the approved one&lt;/a&gt;. That comparison is what lets GitLab keep approvals across a rebase or a merge of the target branch when the resulting patch is unchanged.&lt;/p&gt;

&lt;p&gt;Both platforms let you turn the behavior off, and the reason the default is what it is appears in GitHub's own guidance: if you are worried about approved pull requests being hijacked, dismissing stale approvals is the safer setting. An approval that survives an arbitrary push is an approval on content nobody read.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the agent fix loop changes
&lt;/h2&gt;

&lt;p&gt;A human author usually pushes a fix once, maybe twice, and the round ends. An agent responding to review comments will push as many times as it takes, and each push that changes the diff restarts the approval. GitHub's &lt;a href="https://docs.github.com/en/copilot/how-tos/use-copilot-agents/use-code-review" rel="noopener noreferrer"&gt;Copilot code review documentation&lt;/a&gt; covers the bot's own case directly: if new commits are pushed after Copilot approves, the approval is dismissed and you can request another review.&lt;/p&gt;

&lt;p&gt;CodeRabbit documents the same binding from the other side. Its &lt;a href="https://docs.coderabbit.ai/pr-reviews/request-changes-workflow.md" rel="noopener noreferrer"&gt;request-changes workflow&lt;/a&gt; approves a specific commit, verifies immediately before approving that the pull request HEAD has not changed, and leaves approval pending when the current HEAD is not among the commits it reviewed. A new push is a new approval decision.&lt;/p&gt;

&lt;p&gt;The consequence is a number most review dashboards do not show. If review time is measured per pull request, an agent-heavy change that needed three rounds of fixes reads as one slow review. What happened is that one approval was invalidated twice, and two of those reads covered diffs the reviewer had already formed an opinion about. That is rework on the same person who is already carrying the queue, which is the shape of the &lt;a href="https://agentwrotethis.dev/blog/review-time-is-up-441-under-vibe-coding-that-is-the-real-problem/" rel="noopener noreferrer"&gt;441 percent review time increase under vibe coding&lt;/a&gt; rather than a throughput problem in the reviewer.&lt;/p&gt;

&lt;h2&gt;
  
  
  The settings that decide how many re-reads a change costs
&lt;/h2&gt;

&lt;p&gt;There are three positions on the dial, and the middle one is underused.&lt;/p&gt;

&lt;p&gt;Dismiss stale approvals on. Every diff-changing push costs a fresh human approval. On a repository where agents push fixes frequently, this is the setting that turns a fast generator into a slow review queue.&lt;/p&gt;

&lt;p&gt;Dismiss stale approvals off. Approvals persist across pushes, and an agent can add unreviewed content under an approval a human gave to different content. That is the hijack case GitHub's docs point at.&lt;/p&gt;

&lt;p&gt;Require approval of the most recent reviewable push. GitHub documents this as a middle path, and it is worth reading closely. Stale reviews are not dismissed, and the pull request stays approved as long as someone other than the person who made the most recent push approves it. The stated purpose is to let a reviewer confirm that the latest changes incorporate earlier feedback without re-reading everything.&lt;/p&gt;

&lt;p&gt;GitLab offers a finer version of the same idea. Remove approvals by Code Owners if their files changed takes the approval away only from code owners whose files a later commit touched, so a fix that stays inside one service does not invalidate an approval from an owner in another.&lt;/p&gt;

&lt;p&gt;For a repository where agents open most of the pull requests, the most-recent-push rule is usually the better default, because it keeps a human in the loop on the latest content without charging a full re-read for every iteration. It depends on someone being available who is not the last pusher, so it fits a team of three or more reviewers around a service less well than it fits a single maintainer with a rotating backup.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the approval survives without weakening the rule
&lt;/h2&gt;

&lt;p&gt;Patch equivalence is the escape hatch, and it is documented on both platforms. GitHub's &lt;a href="https://docs.github.com/en/pull-requests/reference/stacked-pull-requests" rel="noopener noreferrer"&gt;stacked pull request reference&lt;/a&gt; states that rebasing a stack does not count as a new reviewable commit when the diff does not change, and approvals are retained in that situation even with the dismiss-stale rule enabled. GitLab's use of git patch-id is what makes the same call, and its settings page names rebase and merge of the target branch as the operations it handles better as a result.&lt;/p&gt;

&lt;p&gt;This gives you a concrete criterion for what your agent is allowed to do when it fixes a review finding. A fix that changes the diff costs a re-approval. A rebase or an update from the target branch that leaves the patch identical does not. An agent that reformats, regenerates a lockfile, or touches an unrelated file while addressing a comment turns a free operation into a paid one. Constraining the fix commit to the finding is worth more under this setting than it is on most others.&lt;/p&gt;

&lt;p&gt;There is a related trap on the automation side. GitLab's &lt;a href="https://gitlab.com/api/v4/projects/278964/repository/files/doc%2Fapi%2Fmerge_request_approvals.md/raw?ref=master" rel="noopener noreferrer"&gt;merge request approvals API&lt;/a&gt; notes that automation which creates and approves a merge request can approve before the commit is fully processed, producing an approval that the platform then resets. Its documented workaround is to wait until detailed_merge_status is not in checking or approvals_syncing and the merge request diff contains a non-null patch_id_sha, or to pass the sha attribute when approving. The activity log ends up reading approved, added one commit, reset approvals by pushing to the branch, which is the same sequence an agent fix loop produces for a different reason.&lt;/p&gt;

&lt;h2&gt;
  
  
  The reviewers, and what they do on a new commit
&lt;/h2&gt;

&lt;p&gt;Copilot code review, CodeRabbit and Kodus all sit on top of those platform rules, and each documents its own behavior around a new commit.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Reviewer&lt;/th&gt;
&lt;th&gt;Approval in the merge path&lt;/th&gt;
&lt;th&gt;Documented behavior on a new commit&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot code review&lt;/td&gt;
&lt;td&gt;Approvals off by default, with a separate toggle for counting toward merge requirements&lt;/td&gt;
&lt;td&gt;A push after an approval dismisses it, and you can re-request a review&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit&lt;/td&gt;
&lt;td&gt;Request-changes workflow disabled by default, Essentials and above&lt;/td&gt;
&lt;td&gt;Approves a specific commit and checks HEAD has not changed; approval stays pending when HEAD is not among the commits it reviewed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus&lt;/td&gt;
&lt;td&gt;Non-blocking by default; request-changes and auto-approve are optional behaviors&lt;/td&gt;
&lt;td&gt;An approval only participates in the gate if you enable those optional behaviors&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The platform layer those reviewers depend on is worth reading on its own, because &lt;a href="https://agentwrotethis.dev/blog/ai-code-review-on-github-what-the-platform-decides-for-you/" rel="noopener noreferrer"&gt;the trigger and the token scopes decide what a reviewer can do&lt;/a&gt; long before invalidation comes up.&lt;/p&gt;

&lt;p&gt;Kodus takes the non-blocking default and says so in its &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/policy.md" rel="noopener noreferrer"&gt;review policy documentation&lt;/a&gt;: suggestions post as comments, request-changes and auto-approve are optional, and the page recommends enabling blocking behaviors only where the team agrees on thresholds and has strong CI in place. That keeps a Kodus review out of the merge path by default, so the invalidation rule never fires on its approval unless you opted in. The trade between those two positions is the subject of &lt;a href="https://agentwrotethis.dev/blog/which-ai-reviewer-approvals-satisfy-your-merge-requirement/" rel="noopener noreferrer"&gt;which reviewer approvals satisfy a merge requirement&lt;/a&gt;, and this is the other half of it: what happens to that approval on the next push.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to measure, and the question to settle first
&lt;/h2&gt;

&lt;p&gt;Per-pull-request review time will not show any of this. Two metrics will: approvals per merged change, and the count of review rounds per change. Both are visible in the activity log, both are cheap to pull from the API, and both move when an agent fix loop starts invalidating approvals the team assumed were still valid.&lt;/p&gt;

&lt;p&gt;The question to settle before enabling anything is who re-approves after the agent's next push. If the answer is the same person who approved the last diff, the setting is charging a full re-read on every iteration, and a narrower fix commit or the most-recent-push rule will do more for review time than a stronger model will. If the answer is nobody, the approval is not protecting the merge, and the gate is decoration. Either way the answer is a repository setting, not a property of the reviewer, and it belongs next to &lt;a href="https://agentwrotethis.dev/blog/what-your-review-queues-ranker-can-and-cannot-see/" rel="noopener noreferrer"&gt;the question of who the change is even routed to&lt;/a&gt; in the same review of how the queue works.&lt;/p&gt;

&lt;h2&gt;
  
  
  Questions this comes up as
&lt;/h2&gt;

&lt;p&gt;Does an agent pushing a fix commit invalidate a human approval? On GitHub, yes, if Dismiss stale pull request approvals when new commits are pushed is enabled. GitHub records the state of the diff at the moment of approval, and any change to that state, including a new commit, an Update branch click, or a related pull request merging into the target, dismisses the approving review as stale. GitLab removes approvals on new commits by default, using git patch-id to decide whether the diff actually changed.&lt;/p&gt;

&lt;p&gt;Can an approval survive a rebase or an update from the target branch? Yes, when the resulting patch is unchanged. GitHub's stacked pull request documentation states that rebasing a stack does not count as a new reviewable commit if the diff does not change, and approvals are retained even with dismiss-stale enabled. GitLab's use of git patch-id is what lets it keep approvals across a rebase or a merge of the target branch.&lt;/p&gt;

&lt;p&gt;What is the middle setting between dismissing and keeping stale approvals? On GitHub it is Require approval of the most recent reviewable push. Stale reviews are not dismissed, and the pull request stays approved as long as someone other than the person who made the most recent push approves it. GitLab offers a narrower option: Remove approvals by Code Owners if their files changed, which removes approval only from owners whose files a later commit touched.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>pullrequests</category>
      <category>githubactions</category>
    </item>
    <item>
      <title>Open source AI code review: which part is actually open</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Mon, 02 Nov 2026 01:45:01 +0000</pubDate>
      <link>https://dev.to/tessainsley/open-source-ai-code-review-which-part-is-actually-open-3d7l</link>
      <guid>https://dev.to/tessainsley/open-source-ai-code-review-which-part-is-actually-open-3d7l</guid>
      <description>&lt;p&gt;Open source AI code review describes at least five different arrangements, and the license badge on the repository tells you almost none of them. What actually decides how a review behaves is where the diff goes and which process holds it. Those two answers can be unrelated to the license file sitting at the root of the repo.&lt;/p&gt;

&lt;p&gt;This matters more now than it did a year ago, because most of the code arriving in review was written by an agent. If the reviewer runs inside your infrastructure with your model key, the agent's diff never leaves. If the reviewer is hosted, every agent pull request ships that diff to somebody else's service, and the pace agents set means that happens far more often than it used to.&lt;/p&gt;

&lt;h2&gt;
  
  
  The license field on the repository is the weakest signal available
&lt;/h2&gt;

&lt;p&gt;GitHub's API reports a license for a repository by reading the license file it can recognize. For &lt;a href="https://github.com/kodustech/kodus-ai" rel="noopener noreferrer"&gt;kodustech/kodus-ai&lt;/a&gt;, that field comes back as &lt;code&gt;NOASSERTION&lt;/code&gt;, even though the README carries an AGPLv3 badge. The reason is visible in the repo's own &lt;a href="https://github.com/kodustech/kodus-ai/blob/main/license.md" rel="noopener noreferrer"&gt;license file&lt;/a&gt;: it is a dual-license arrangement. Source outside the Enterprise Code is AGPL-3.0, while any file with &lt;code&gt;.ee.&lt;/code&gt; in its name or inside an &lt;code&gt;ee/&lt;/code&gt; directory falls under a separate Kodus Enterprise Code License. That second license permits a self-hosted Community user to run the unmodified Enterprise Code needed for Community features, including code review and bring-your-own-key, in production. It does not permit modifying that code, and it does not permit using Enterprise-only features.&lt;/p&gt;

&lt;p&gt;A single SPDX identifier cannot express that. The license field on a repo page is a convenience for scanning dependencies, and it has no way to say which directories the permissive half covers.&lt;/p&gt;

&lt;p&gt;Two more examples from the same category. &lt;a href="https://github.com/the-pr-agent/pr-agent" rel="noopener noreferrer"&gt;the-pr-agent/pr-agent&lt;/a&gt; reports MIT, and the &lt;a href="https://raw.githubusercontent.com/the-pr-agent/pr-agent/main/LICENSE" rel="noopener noreferrer"&gt;LICENSE&lt;/a&gt; file confirms plain MIT. &lt;a href="https://github.com/alibaba/open-code-review" rel="noopener noreferrer"&gt;alibaba/open-code-review&lt;/a&gt; reports Apache-2.0 and the README states it plainly, Copyright 2026 Alibaba. Those two are the easy cases, and they are easy precisely because the whole project is under one license.&lt;/p&gt;

&lt;h2&gt;
  
  
  Five things teams mean when they say a reviewer is open source
&lt;/h2&gt;

&lt;h3&gt;
  
  
  The repository is the client, and the reviewer is hosted
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/sourcery-ai/sourcery" rel="noopener noreferrer"&gt;sourcery-ai/sourcery&lt;/a&gt; is MIT, and the repository is genuinely open. Read the top-level contents and you find a license, a &lt;code&gt;pre-commit-hooks.yaml&lt;/code&gt;, a write-up about building an LSP client, packaging metadata, and a demo GIF. The README's installation path for pull request reviews is adding the GitHub App, and it says the reviews use OpenAI and Anthropic models, which means the diff of the PR is sent to those providers. For private repositories the README points to a Team or Pro plan.&lt;/p&gt;

&lt;p&gt;The code being open and the review being open are two separate facts here. If your question is whether the thing commenting on your PRs can be audited and run by you, the MIT license does not answer it. Sourcery's README is unusually direct about where the product stands: it says the goal is the kind of review you would expect from a colleague, and that they are not there yet.&lt;/p&gt;

&lt;h3&gt;
  
  
  Self-hostable, with a carve-out that the badge hides
&lt;/h3&gt;

&lt;p&gt;Kodus is the shape most teams picture when they hear the phrase, and it still has an edge worth reading before you commit. The &lt;a href="https://github.com/kodustech/kodus-ai" rel="noopener noreferrer"&gt;repository&lt;/a&gt; describes itself as open source, self-hosted AI code review with bring-your-own-LLM, and the docs state that all source is available to inspect, use, and improve. The self-host path is documented rather than implied: Docker on a VM you control, at least 2 CPU cores, 8 GB of RAM, and 60 GB of free disk. The CLI talks to your instance over HTTPS through &lt;code&gt;KODUS_API_URL&lt;/code&gt; and a team key, and the documented CI shape is a JSON review with &lt;code&gt;--fail-on error&lt;/code&gt; so the pipeline fails on findings above a threshold.&lt;/p&gt;

&lt;p&gt;The carve-out is the &lt;code&gt;.ee.&lt;/code&gt; split described above, and there is one operational detail that belongs in the same paragraph. A self-hosted instance sends one anonymous heartbeat per day, carrying aggregated counters and no code, names, or identifiers, and it can be turned off with &lt;code&gt;KODUS_TELEMETRY_DISABLED=true&lt;/code&gt;. A self-hosted review tool that phones home once a day is a different posture from one that never does, and the honest version of the claim includes the phone call.&lt;/p&gt;

&lt;h3&gt;
  
  
  A community-maintained legacy project sitting next to the vendor's product
&lt;/h3&gt;

&lt;p&gt;PR-Agent is the case that breaks the usual assumption that an open-source reviewer is the company's product. The README says outright that the repository is not the Qodo offering for open-source projects, and describes PR-Agent as an open-source, AI-powered code review agent and a community-maintained legacy project of Qodo, distinct from Qodo's primary offering. It carries 13,868 stars as of 1 November 2026, which makes it one of the largest repositories in the category.&lt;/p&gt;

&lt;p&gt;That structure has visible costs. Releases from 0.34.2 onward publish to a new Docker Hub namespace, while older images stay at the legacy namespace as a frozen archive with nothing new pushed. The README also notes that &lt;code&gt;/help_docs&lt;/code&gt; has been disabled since v0.36.1 pending a fix for a credential-exposure issue. If you pin an image or call a command, you are depending on a community project's release cadence, and the vendor's paid product will move on its own schedule.&lt;/p&gt;

&lt;h3&gt;
  
  
  A CLI that never touches your pull request
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/alibaba/open-code-review" rel="noopener noreferrer"&gt;alibaba/open-code-review&lt;/a&gt; is Apache-2.0 and installs from npm as &lt;code&gt;@alibaba-group/open-code-review&lt;/code&gt;, giving you an &lt;code&gt;ocr&lt;/code&gt; command. You configure a provider and a model, then run &lt;code&gt;ocr review&lt;/code&gt; against staged changes, a branch range, or a single commit, or &lt;code&gt;ocr scan&lt;/code&gt; over whole files where there is no useful diff. There is no app to install on the forge and no hosted review step, which means the review is a step in your pipeline that you own end to end.&lt;/p&gt;

&lt;p&gt;It also publishes a benchmark with a method attached, which is rare enough in this category to be worth naming. The README describes a set built from 50 popular open-source repositories, 200 real pull requests, and 10 programming languages, cross-validated by more than 80 senior engineers into 1,505 annotated ground-truth issues, and links the &lt;a href="https://huggingface.co/datasets/Alibaba-Aone/aacr-bench" rel="noopener noreferrer"&gt;AACR-Bench dataset&lt;/a&gt; on Hugging Face. The dataset description lists 2,145 review comments, made up of 1,505 expert-verified correct comments and 640 incorrect ones. The README also reports the result that goes against the vendor interest: recall is lower than a general-purpose agent's, described as a deliberate trade in favor of precision.&lt;/p&gt;

&lt;p&gt;A published dataset you can inspect is the thing that separates a benchmark from a claim. When a tool reports a precision number with no corpus behind it, there is nothing to check.&lt;/p&gt;

&lt;h3&gt;
  
  
  A GitHub Action where you inherit the security posture
&lt;/h3&gt;

&lt;p&gt;Anthropic's &lt;a href="https://github.com/anthropics/claude-code-security-review" rel="noopener noreferrer"&gt;claude-code-security-review&lt;/a&gt; is MIT and runs as a GitHub Action on the PR diff, posting findings as comments, with a default model and a 20-minute analysis timeout. The repository's security section says the action is not hardened against prompt injection attacks and should only be used to review trusted pull requests, and recommends configuring the repository to require approval for all external contributors.&lt;/p&gt;

&lt;p&gt;That is the right disclosure, and it is also the part teams skip. Running the reviewer yourself does not remove the fact that the reviewer reads a diff, and a diff is attacker-controlled text whenever an outside contributor can open a PR. Owning the infrastructure changes who holds the data. It does not change what the model is being asked to trust.&lt;/p&gt;

&lt;h2&gt;
  
  
  Free for open source projects is a different thing again
&lt;/h2&gt;

&lt;p&gt;CodeRabbit's &lt;a href="https://docs.coderabbit.ai/management/plans.md" rel="noopener noreferrer"&gt;OSS plan&lt;/a&gt; gives public repositories Team features with no paid subscription, and its review limits vary by repository star count. Nothing about that is open source software. The company's code is not published, the reviews run on CodeRabbit's infrastructure, and the free tier is priced against your project's popularity rather than released under a license.&lt;/p&gt;

&lt;p&gt;The distinction is easy to blur because both arrangements end with a maintainer paying nothing. One of them means you can read and run the code. The other means you were granted free usage of a service, on terms that can change. If you are comparing hosted reviewers and want to know what a free arrangement really includes, the tier boundaries matter more than the price of zero, which is the same question I looked at in &lt;a href="https://agentwrotethis.dev/blog/free-ai-code-review-what-the-free-tier-actually-covers/" rel="noopener noreferrer"&gt;what the free tier of a hosted reviewer actually covers&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;For contrast, Copilot code review is closed and hosted, and its defaults are documented in &lt;a href="https://docs.github.com/en/copilot/how-tos/use-copilot-agents/use-code-review" rel="noopener noreferrer"&gt;GitHub's own instructions&lt;/a&gt;: Copilot leaves a Comment review by default, which does not count toward required approvals, and approvals are off by default at the enterprise, organization, and repository levels. There is no repo to read and no license to check, so the useful questions move to configuration, which is the territory covered in &lt;a href="https://agentwrotethis.dev/blog/ai-code-review-on-github-what-the-platform-decides-for-you/" rel="noopener noreferrer"&gt;what the platform decides for you&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The five shapes side by side
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Project&lt;/th&gt;
&lt;th&gt;What the repository contains&lt;/th&gt;
&lt;th&gt;License covering the review path&lt;/th&gt;
&lt;th&gt;Where the diff goes&lt;/th&gt;
&lt;th&gt;What you run yourself&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Sourcery&lt;/td&gt;
&lt;td&gt;Editor client, pre-commit hook, packaging&lt;/td&gt;
&lt;td&gt;MIT for the repo; hosted service for PR reviews&lt;/td&gt;
&lt;td&gt;To OpenAI and Anthropic through Sourcery&lt;/td&gt;
&lt;td&gt;The client, not the reviewer&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus&lt;/td&gt;
&lt;td&gt;The reviewer, self-host deployment, CLI&lt;/td&gt;
&lt;td&gt;AGPL-3.0, with &lt;code&gt;.ee.&lt;/code&gt; files under a separate Enterprise Code License&lt;/td&gt;
&lt;td&gt;To the model provider you key, or to your own instance&lt;/td&gt;
&lt;td&gt;The instance, the model key, the CI step&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PR-Agent&lt;/td&gt;
&lt;td&gt;The reviewer, actions, CLI, configuration&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;To whichever model you configure&lt;/td&gt;
&lt;td&gt;The action or container, on a community release cadence&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Alibaba Open Code Review&lt;/td&gt;
&lt;td&gt;A CLI with no forge integration&lt;/td&gt;
&lt;td&gt;Apache-2.0&lt;/td&gt;
&lt;td&gt;To the provider endpoint you configure&lt;/td&gt;
&lt;td&gt;Everything, including when it runs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Anthropic security review&lt;/td&gt;
&lt;td&gt;A GitHub Action for security findings&lt;/td&gt;
&lt;td&gt;MIT&lt;/td&gt;
&lt;td&gt;To Anthropic's API on each run&lt;/td&gt;
&lt;td&gt;The action, and the injection risk with it&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  What to check before you call a reviewer open source
&lt;/h2&gt;

&lt;p&gt;Read the license file, not the badge, and check whether it is one license or a split with a directory-based carve-out. Then open the README and look for the sentence that says what the project is not, because vendors write those sentences to stop a specific misunderstanding, and that misunderstanding is usually the one you are about to have. Then trace the diff: which endpoint receives it, whose key is attached, and whether the review happens in a process you control. Finally, run the install instructions once on a throwaway repository and see what the pipeline actually needs. The npm package, the container namespace, the required API key, and the disabled command are all visible before you commit a team to it.&lt;/p&gt;

&lt;p&gt;The reason to do this before adoption rather than after is volume. An agent-authored change is still a diff, and the reviewer reads it the same way. Choosing a self-hosted reviewer means the increasing number of those diffs stays inside your network boundary, and the trade is that you now operate the review path, which has its own real cost. Choosing a hosted reviewer means the operational burden is somebody else's, and the diff leaves on every push. Both are defensible, and the license badge does not tell you which one you picked.&lt;/p&gt;

&lt;p&gt;Two smaller checks belong in the same pass, because they decide how much the reviewer can enforce once it is running. Confirm which rule files it actually reads from your repository, since a reviewer that ignores your conventions will produce findings your team learns to dismiss, which is the problem behind &lt;a href="https://agentwrotethis.dev/blog/which-of-your-rule-files-the-reviewer-actually-reads/" rel="noopener noreferrer"&gt;which rule files a reviewer actually reads&lt;/a&gt;. And price the self-hosted path honestly, since the hardware floor and the operational time are the parts that get left out of the comparison, which is what &lt;a href="https://agentwrotethis.dev/blog/what-self-hosting-ai-code-review-actually-costs/" rel="noopener noreferrer"&gt;the self-hosting cost&lt;/a&gt; is about.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>opensource</category>
      <category>pullrequests</category>
    </item>
    <item>
      <title>Best AI code review tools for teams reviewing agent-generated code (2026)</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Fri, 30 Oct 2026 14:45:06 +0000</pubDate>
      <link>https://dev.to/tessainsley/best-ai-code-review-tools-for-teams-reviewing-agent-generated-code-2026-31l</link>
      <guid>https://dev.to/tessainsley/best-ai-code-review-tools-for-teams-reviewing-agent-generated-code-2026-31l</guid>
      <description>&lt;p&gt;A queue dominated by agent output breaks differently from one dominated by human output, and the difference is in the count rather than the size of the changes. Agent pull requests tend to be small and numerous, which means the limit that bites first is usually the reviewer's own allowance, not its ability to read a large diff. That is why the ranking below is not organised around finding the most bugs. It is organised around which tools stay available when review events arrive faster than people do.&lt;/p&gt;

&lt;p&gt;Last updated: 2026-10-27.&lt;/p&gt;

&lt;p&gt;Six tools make the shortlist: CodeRabbit, GitHub Copilot code review, Kodus, Cursor Bugbot, Qodo, and Greptile. They are not interchangeable. Each one is the best fit under a different constraint, and the constraint matters more than the tool's feature count. A team that has to self-host is shopping in a different market from a team that wants the cheapest marginal review on GitHub.&lt;/p&gt;

&lt;h2&gt;
  
  
  How these were ranked
&lt;/h2&gt;

&lt;p&gt;The criteria are the ones that decide whether a reviewer survives contact with agent volume: published rate limits and file caps, documented platform support, what the reviewer is allowed to do at the merge gate, whether pricing is per seat or per unit of work, and whether configuration can be applied across an organisation rather than repository by repository.&lt;/p&gt;

&lt;p&gt;Vendor benchmark numbers are treated as claims unless a method and a dataset are published alongside them. Several of these vendors publish comparison charts with percentages attached. None of the ones I read publish the corpus, the grading rubric, or the runner. That does not make the numbers false. It makes them unverifiable, and a team choosing a reviewer on an unverifiable percentage is choosing on marketing. The parts I could check are the parts that show up in documentation: limits, tiers, supported platforms, and defaults.&lt;/p&gt;

&lt;p&gt;I also weighted what a reviewer may do to a merge request, because a comment and an approval are different products. A tool that only comments is advisory no matter how good its findings are, and the approval defaults across these tools differ enough to change the shape of your branch protection. The mechanics of that are worth reading separately, since the setting lives on the platform as much as in the tool.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. CodeRabbit
&lt;/h2&gt;

&lt;p&gt;CodeRabbit is the default answer for most teams and the one with the most published detail about its own limits, which is why it ranks first. Its &lt;a href="https://docs.coderabbit.ai/management/plans.md" rel="noopener noreferrer"&gt;plans and pricing documentation&lt;/a&gt; lists five tiers plus a free and an open-source path, and it states the per-developer review allowance in a table instead of leaving it to a sales call.&lt;/p&gt;

&lt;p&gt;That table is also where the agent-volume problem shows up. The allowance is measured in reviews per developer per hour on a rolling window: 1 on Free, 5 on Essentials, 8 on Team, 10 on Advanced, 12 on Enterprise. Files per review run 150 on Free and Essentials, 300 from Team up. The number that matters for an agent-heavy repository is further down the page, under the fair usage policy: the refill rate drops as recent activity rises, down to one review per hour at a time for a developer who has run 60 or more reviews in the last 7 days on Essentials.&lt;/p&gt;

&lt;p&gt;That is the failure mode to plan around. An incremental review on every push means three commits pushed one at a time spend three review events while three commits pushed together spend one. Agent workflows produce pushes. The allowance erodes from the shape of the workflow rather than from anyone deciding to run more reviews, and the symptom arrives as a rate-limit notice on a pull request. I went through &lt;a href="https://agentwrotethis.dev/blog/the-review-throughput-ceiling-that-pricing-pages-leave-out/" rel="noopener noreferrer"&gt;which limit binds first for each vendor&lt;/a&gt; if you want the arithmetic in full.&lt;/p&gt;

&lt;p&gt;Where CodeRabbit fits best: teams on GitHub, GitLab, Bitbucket or Azure DevOps who want one reviewer across all of them, and who will actually read the rate-limit table before adoption. Where it fits badly: an agent-heavy repository on Essentials where a handful of developers push many small changes a day.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. GitHub Copilot code review
&lt;/h2&gt;

&lt;p&gt;Copilot's advantage is that the reviewer is already inside the platform you are paying for, and the marginal cost of a review is measured in credits rather than a new subscription line. Its &lt;a href="https://docs.github.com/en/copilot/concepts/billing/organizations-and-enterprises" rel="noopener noreferrer"&gt;billing documentation for organisations&lt;/a&gt; puts Copilot Business at $19 per user per month with 1,900 AI credits per user, and Copilot Enterprise at $39 with 3,900, available on GitHub Enterprise Cloud only. Credits pool across the enterprise, and usage past the pool is charged at $0.01 per credit.&lt;/p&gt;

&lt;p&gt;Two things about that arrangement matter more than the headline price. First, credits pool, so a twenty-developer organisation is budgeting 38,000 credits a month on Business rather than twenty separate allowances. Second, attribution decides who pays. An automatic review is attributed to the pull request author by default, and reviews of pull requests opened by bots are billed to the organisation. In a repository where agents open most of the pull requests, the consumption lands on the org pool regardless of who is on holiday.&lt;/p&gt;

&lt;p&gt;The reviewer is GitHub-only. Copilot code review runs on GitHub cloud and GitHub Enterprise Cloud, so a team supporting GitLab alongside GitHub needs a second tool for the other half of its repositories. The approval path also starts closed: GitHub documents the approval toggles as off by default, and the ability to configure automatic review is not available on the free Copilot plan. I covered the toggle layout and the path globs in &lt;a href="https://agentwrotethis.dev/blog/which-ai-reviewer-approvals-satisfy-your-merge-requirement/" rel="noopener noreferrer"&gt;which reviewer approvals satisfy a merge requirement&lt;/a&gt;, because enabling one of those toggles by accident is the mistake with the worst consequences.&lt;/p&gt;

&lt;p&gt;Where Copilot fits best: GitHub-only teams already buying Copilot seats, where a second vendor would mean a second security review. Where it fits badly: mixed-platform organisations, and teams that need the reviewer's approval to carry weight on specific paths rather than repository-wide.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Kodus
&lt;/h2&gt;

&lt;p&gt;Kodus is the one on this list whose published limits are mostly about features rather than throughput, and that is the honest reason it sits third rather than higher or lower. Its &lt;a href="https://docs.kodus.io/en/how_to_use/pricing.md" rel="noopener noreferrer"&gt;pricing documentation&lt;/a&gt; states that reviews are unlimited on every plan, that the only hard cap is pull requests over 2,000 changed files, and that every plan runs on bring-your-own-key, with tokens billed by your provider and no markup from Kodus. The seats are $10 per active developer per month on Teams, $0 on Community, and custom on Enterprise. Only developers who open pull requests count as active.&lt;/p&gt;

&lt;p&gt;Two documented capabilities are directly aimed at agent-generated changes, and both are worth checking against what your team actually does. The first is &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/business_logic_validation.md" rel="noopener noreferrer"&gt;business logic validation&lt;/a&gt;, which finds the task a pull request references in Linear, Jira, Notion or Git issues, reads it, and lists each requirement with where it stands in the diff. Requirements come back as MET, PARTIAL, MISSING, CHECK MANUALLY or NOT IN TASK, and each row cites the file and line it is based on. Kody reads code the pull request calls but did not change before it marks anything missing, which is the part that keeps a requirements check from becoming a nag. The output is a comment, so it does not block a merge on its own.&lt;/p&gt;

&lt;p&gt;The second is &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/configs/global_rule_sources.md" rel="noopener noreferrer"&gt;global rule sources&lt;/a&gt;. You point Kodus at one or more connected repositories that hold your standards, and the rule files found there are imported as global rules that apply to every repository during review, refreshed when a pull request merges in a source repo. On the trial plan the import is capped at five rules; paid cloud and licensed self-hosted are unlimited, and the free plan does not include the feature at all.&lt;/p&gt;

&lt;p&gt;The trade-offs are real. Teams is cloud-only, so the $10 seat price does not buy you self-hosting, and self-hosting means Community or an Enterprise contract. Governance features that a regulated team will look for first, meaning SSO/SAML, RBAC and audit logs, sit in Enterprise only. Running on your own key also means owning model selection and spend, which is a small ongoing operational cost that a bundled-token vendor hides inside its seat price. The &lt;a href="https://docs.kodus.io/en/how_to_use/cli/self_hosted.md" rel="noopener noreferrer"&gt;self-hosted CLI setup&lt;/a&gt; covers the parts that go wrong: HTTPS is required, team keys and CI tokens are separate auth paths, and Cloudflare Access needs service token credentials in the environment.&lt;/p&gt;

&lt;p&gt;Where Kodus fits best: teams that need the reviewer to check a change against the task it claims to close, teams rolling one rule set across many repositories, and teams that need self-hosting without a per-seat review cap. Where it fits badly: a team that wants zero operational work around model keys and no interest in requirement-level checking, since the seat price advantage is the only thing left and it comes with that work attached.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Cursor Bugbot
&lt;/h2&gt;

&lt;p&gt;Bugbot is the right pick for teams that already standardised on Cursor, and its documentation is unusually specific about what it will not review. It runs on every pull request update or on the cursor review command, reads existing pull request comments so it does not repeat a suggestion someone already made, and links each finding back into Cursor or the web agent.&lt;/p&gt;

&lt;p&gt;The limits are the interesting part. Bugbot &lt;a href="https://cursor.com/docs/bugbot" rel="noopener noreferrer"&gt;skips pull requests above a review-size limit&lt;/a&gt; measured in changed lines and diff characters, and posts a comment asking you to split the change. A skipped run records no review usage, so the cap costs you nothing but does mean a large agent change goes unreviewed by this tool. Files marked linguist-generated in .gitattributes are excluded and do not count toward the size limit, which is a useful lever when a code generator inflates a diff.&lt;/p&gt;

&lt;p&gt;The second limit is the one to read closely if agents open your pull requests. Bugbot caps how many reviews it runs on pull requests opened by bot accounts, per team, and every review counts including repeat reviews of the same pull request. The cap is a default and your team's can differ, but the direction is clear: agent-opened pull requests are metered differently from human-opened ones.&lt;/p&gt;

&lt;p&gt;The merge path needs one setting changed to be worth anything. Bugbot publishes a check per run, and findings default to the neutral conclusion. Requiring that check in branch protection makes Bugbot run before merge, and does not block a merge on its findings. Unresolved findings only produce a failing status if the fail-on-unresolved-issues behaviour is available for your organisation and enabled.&lt;/p&gt;

&lt;p&gt;Where Bugbot fits best: Cursor teams, especially those using it alongside Cursor's cloud agents, who want findings to flow back into the editor. Where it fits badly: teams where bot-authored pull requests are the majority and the review cap becomes the binding constraint.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Qodo
&lt;/h2&gt;

&lt;p&gt;Qodo's pitch is standards enforcement rather than diff commentary, and the parts that support it are aimed at exactly the problem agent volume creates. Its &lt;a href="https://www.qodo.ai/pricing/" rel="noopener noreferrer"&gt;pricing page&lt;/a&gt; lists agentic pull request review, an unlimited rules system, cross-repo review for catching breaking changes before they reach dependent services, and a software map of how repositories and contracts connect. For a team whose agents are editing service boundaries, cross-repo context is the capability that a single-repository reviewer cannot substitute for.&lt;/p&gt;

&lt;p&gt;Pro Team is $30 per user per month with no annual commitment, described as designed for up to 30 users, and it includes unlimited reviews. Credit packs are available separately at $0.012 per credit, pooled across the team, with the vendor's own conversions printed next to them: 2,500 credits for roughly 18 reviews a month, 5,000 for roughly 36, and 20,000 for roughly 144. Those ratios are the vendor's, not a measurement, and they imply a fairly deep per-review token budget. Treat them as a signal about review depth rather than a cost forecast.&lt;/p&gt;

&lt;p&gt;The capabilities that regulated teams ask about sit on Enterprise: SSO/SAML, audit logs, bring-your-own-key, single-tenant SaaS, and on-premises or air-gapped deployment. Gerrit support is also listed as Enterprise-only, which matters if your organisation is one of the ones still on Gerrit.&lt;/p&gt;

&lt;p&gt;Where Qodo fits best: teams enforcing organisational standards across many repositories, and teams that need cross-repo contract checking. Where it fits badly: a small team that wants a cheap per-seat reviewer and has no interest in the standards lifecycle, since the price lands above several alternatives.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Greptile
&lt;/h2&gt;

&lt;p&gt;Greptile is last on fit for agent-heavy queues, and first on a different axis: it is the only tool here that does not charge per seat. Its &lt;a href="https://www.greptile.com/pricing" rel="noopener noreferrer"&gt;pricing page&lt;/a&gt; lists Pro at $1 per credit with no seat fees, unlimited developers and agents, and credits shared across the whole organisation. Starter is free for one active developer with 50 credits a month. Review depth is priced: a base review costs 1 credit, Plus costs 3, Apex costs 10.&lt;/p&gt;

&lt;p&gt;That model has a specific consequence for a team whose queue is full of agent changes. Cost tracks review volume rather than headcount, so adding reviewers is free and adding agents is not. A twenty-developer team running one base review per developer per working day lands near 420 credits a month, which is $420. Run the same volume through Plus reviews and it is $1,260. The variable is depth, not seats, so the budget question becomes how deep you want the reviewer to look on routine agent changes.&lt;/p&gt;

&lt;p&gt;Enterprise adds self-hosting, SSO and SAML, role-based access control, and support for GitHub Enterprise Server and Cloud with data residency, GitLab Self-Managed, Bitbucket Data Center, Gitea, and Perforce. Starter and Pro do not include those. Greptile is also free for qualified non-commercial projects with an OSI-approved licence, and pre-Series A startups under $2M revenue get 500 credits a month for six months.&lt;/p&gt;

&lt;p&gt;Where Greptile fits best: teams that want cost to follow work rather than headcount, and organisations with an unusual version control platform. Where it fits badly: teams that need a predictable monthly line item, because a credit meter that scales with review depth is not a number you can forecast from a seat count.&lt;/p&gt;

&lt;h2&gt;
  
  
  Platform support
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;GitHub&lt;/th&gt;
&lt;th&gt;GitLab&lt;/th&gt;
&lt;th&gt;Bitbucket&lt;/th&gt;
&lt;th&gt;Azure DevOps&lt;/th&gt;
&lt;th&gt;Self-hosted option&lt;/th&gt;
&lt;th&gt;IDE or CLI&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Enterprise tier&lt;/td&gt;
&lt;td&gt;VS Code extension, CLI&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot code review&lt;/td&gt;
&lt;td&gt;Yes, cloud and Enterprise Cloud&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;IDE review is a separate product&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Community and Enterprise&lt;/td&gt;
&lt;td&gt;Kodus CLI, coding-agent integrations&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cursor Bugbot&lt;/td&gt;
&lt;td&gt;Yes, incl. Enterprise Server&lt;/td&gt;
&lt;td&gt;Yes, incl. self-hosted&lt;/td&gt;
&lt;td&gt;Yes, incl. Data Center&lt;/td&gt;
&lt;td&gt;Yes (Services)&lt;/td&gt;
&lt;td&gt;No for Bugbot&lt;/td&gt;
&lt;td&gt;Findings link back into Cursor&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Qodo&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;td&gt;Enterprise: single-tenant, on-prem, air-gapped&lt;/td&gt;
&lt;td&gt;Git and IDE integrations, pre-PR skills&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Greptile&lt;/td&gt;
&lt;td&gt;Yes, incl. Enterprise Server and Cloud&lt;/td&gt;
&lt;td&gt;Yes, incl. Self-Managed&lt;/td&gt;
&lt;td&gt;Yes, incl. Data Center&lt;/td&gt;
&lt;td&gt;Not listed&lt;/td&gt;
&lt;td&gt;Enterprise&lt;/td&gt;
&lt;td&gt;Not listed on the pricing page&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two notes on reading this table. Kodus also lists Forgejo, which I have left out of the column set because no other tool here supports it and it would make the table harder to scan. Copilot's absence from GitLab is not a configuration gap; Copilot code review is a GitHub product.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a 20-developer team pays
&lt;/h2&gt;

&lt;p&gt;Prices below are list prices from each vendor's own pricing page or documentation. Month-to-month and annual columns differ only where the vendor publishes two rates.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool and tier&lt;/th&gt;
&lt;th&gt;Per-seat or unit price&lt;/th&gt;
&lt;th&gt;20 developers, monthly&lt;/th&gt;
&lt;th&gt;20 developers, annual billing&lt;/th&gt;
&lt;th&gt;Not included&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit Essentials&lt;/td&gt;
&lt;td&gt;$30/dev/mo, or $24 annual&lt;/td&gt;
&lt;td&gt;$600&lt;/td&gt;
&lt;td&gt;$480&lt;/td&gt;
&lt;td&gt;Over-limit reviews need the usage-based add-on&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit Team&lt;/td&gt;
&lt;td&gt;$60/dev/mo, or $48 annual&lt;/td&gt;
&lt;td&gt;$1,200&lt;/td&gt;
&lt;td&gt;$960&lt;/td&gt;
&lt;td&gt;Security review needs Advanced&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot Business&lt;/td&gt;
&lt;td&gt;$19/user/mo&lt;/td&gt;
&lt;td&gt;$380&lt;/td&gt;
&lt;td&gt;$380&lt;/td&gt;
&lt;td&gt;Credits past the pooled 38,000 at $0.01 each&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot Enterprise&lt;/td&gt;
&lt;td&gt;$39/user/mo&lt;/td&gt;
&lt;td&gt;$780&lt;/td&gt;
&lt;td&gt;$780&lt;/td&gt;
&lt;td&gt;GitHub Enterprise Cloud only&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus Teams&lt;/td&gt;
&lt;td&gt;$10/active dev/mo&lt;/td&gt;
&lt;td&gt;$200&lt;/td&gt;
&lt;td&gt;$200 before the 20% annual discount&lt;/td&gt;
&lt;td&gt;LLM tokens, billed by your provider (BYOK)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cursor Teams, Bugbot included&lt;/td&gt;
&lt;td&gt;$30+/user/mo&lt;/td&gt;
&lt;td&gt;$600+&lt;/td&gt;
&lt;td&gt;Not published as a single rate&lt;/td&gt;
&lt;td&gt;Third-party model usage, billed separately&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Qodo Pro Team&lt;/td&gt;
&lt;td&gt;$30/user/mo&lt;/td&gt;
&lt;td&gt;$600&lt;/td&gt;
&lt;td&gt;No annual commitment on this tier&lt;/td&gt;
&lt;td&gt;Credit packs at $0.012/credit if you buy them&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Greptile Pro&lt;/td&gt;
&lt;td&gt;$1/credit, no seat fee&lt;/td&gt;
&lt;td&gt;Usage-based; ~420 base reviews is ~$420&lt;/td&gt;
&lt;td&gt;Same&lt;/td&gt;
&lt;td&gt;Plus and Apex reviews cost 3 and 10 credits&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The comparison that matters for agent-heavy queues is not the monthly total. It is what happens in month three, when review volume has doubled and the seat count has not. A per-seat tool bills the same. A per-credit tool bills more. A tool with an hourly refill rate starts refusing reviews. Those are three different budget risks, and a team should pick the one it can actually absorb. For smaller teams the free tiers behave differently enough from each other that &lt;a href="https://agentwrotethis.dev/blog/free-ai-code-review-what-the-free-tier-actually-covers/" rel="noopener noreferrer"&gt;the free tier comparison is worth reading on its own&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Picking by constraint
&lt;/h2&gt;

&lt;p&gt;Start from the constraint that will not move, not from the feature you like most.&lt;/p&gt;

&lt;p&gt;If you are GitHub-only and already paying for Copilot seats, Copilot code review is the cheapest review you can add, because the credits are already in the pool and the integration is already approved. Configure the approval toggles deliberately and restrict which paths a bot approval counts on.&lt;/p&gt;

&lt;p&gt;If you support GitHub and GitLab, or any two platforms, you are choosing between CodeRabbit and Kodus. CodeRabbit has the broader paid feature set and the more explicit rate-limit documentation. Kodus has the lower seat price and no per-review cap, and you pay for that in token operations and in Enterprise-gated governance.&lt;/p&gt;

&lt;p&gt;If you must self-host, the realistic shortlist is Kodus, Greptile, CodeRabbit Enterprise, and Qodo Enterprise, and the licence is the smallest part of the cost. Infrastructure plus maintenance usually outweighs the subscription it replaces, and the published estimate for a self-hosted stack is a different order of magnitude from a per-seat licence. I worked through &lt;a href="https://agentwrotethis.dev/blog/what-self-hosting-ai-code-review-actually-costs/" rel="noopener noreferrer"&gt;what self-hosting actually costs&lt;/a&gt; with the method attached, because the numbers circulating without a method are misleading.&lt;/p&gt;

&lt;p&gt;If your requirements live in a tracker and your agents routinely ship a partial implementation, requirement-level checking is the capability to buy, and Kodus is the tool on this list that documents it in detail. Everything else here reviews the diff. Reading the diff cannot tell you that a requirement in the ticket was never implemented.&lt;/p&gt;

&lt;p&gt;If your agents open most of the pull requests, read three specific things before you choose: the refill bands on CodeRabbit's fair usage policy, the bot-authored pull request cap on Bugbot, and the credit attribution rules on Copilot. Each one is documented, and each one changes what the same monthly bill buys once agents, rather than people, are producing the queue.&lt;/p&gt;

&lt;p&gt;If you need cost to follow work rather than headcount, Greptile's credit model is the only one here without seat fees, and the depth multiplier is the number to model before committing.&lt;/p&gt;

&lt;p&gt;If your constraint is that a reviewer must not be able to block anything, that is a configuration decision rather than a product one, and every tool on this list can be run in a comment-only mode. Kodus documents non-blocking as its default and recommends enabling blocking only where thresholds and CI are settled, which is the safer starting position for most teams.&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is the best AI code review tool for agent-generated pull requests?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;There is no single best tool, because agent-heavy queues stress different limits than human-heavy ones. CodeRabbit has the most thoroughly documented limits and the widest platform support. GitHub Copilot code review is the cheapest addition for GitHub-only teams already buying Copilot seats. Kodus is the strongest fit when the requirement is checking a change against its task or applying one rule set across many repositories. Cursor Bugbot suits teams already on Cursor. Qodo suits teams enforcing standards across services. Greptile suits teams that want cost to follow review volume instead of seat count.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do AI code reviewers limit how many reviews they will run?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Some do. CodeRabbit enforces a per-developer allowance that refills on a rolling hourly window: 1 review per hour on Free, 5 on Essentials, 8 on Team, 10 on Advanced and 12 on Enterprise, and its fair usage policy lowers the refill rate as recent activity rises, down to one per hour at a time at 60 or more reviews in seven days on Essentials. Kodus documents unlimited reviews on every plan, with the only hard cap being pull requests over 2,000 changed files. Cursor Bugbot caps how many reviews it runs on pull requests opened by bot accounts, per team. Copilot is metered in AI credits rather than reviews per hour.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What happens when an agent opens a very large pull request?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;It depends on the tool. Cursor Bugbot skips pull requests above its review-size limit, measured in changed lines and diff characters, posts a comment asking you to split the change, and records no review usage for the skipped run. CodeRabbit caps files per review at 150 on Essentials and 300 from Team upward, counted after path filter exclusions, and can route eligible over-limit GitHub reviews to usage pricing. Kodus skips reviews above 2,000 changed files. Copilot's documentation does not publish a per-review file cap, so that number is unknown from the pages it publishes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which of these tools can run self-hosted?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Kodus offers a free Community plan that is self-hosted or cloud, plus Enterprise self-hosted with SSO, RBAC and audit logs. Greptile, CodeRabbit and Qodo list self-hosting on their Enterprise tiers only, with Qodo adding on-premises and air-gapped deployment. GitHub Copilot code review and Cursor Bugbot are cloud-only products. Self-hosting removes a per-seat review cap and adds an infrastructure and maintenance cost that usually exceeds the subscription it replaces.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Can an AI reviewer's approval clear a required approval on my branch?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Only if the repository is configured to allow it, and on most platforms the default is off. GitHub splits this into allowing approving reviews and then counting those approvals toward merge requirements, with a file path glob list that can narrow where an approval counts. Kodus documents suggestions as non-blocking by default, with request-changes and auto-approve as optional behaviours. Cursor Bugbot's check defaults to a neutral conclusion, so requiring the check makes Bugbot run before merge without blocking a merge on its findings.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How should I evaluate the benchmark numbers these vendors publish?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Ask for the method before the number. A percentage without a corpus, a grading rubric and a runner is a claim rather than a measurement, and several published comparisons omit all three. The parts you can verify are in documentation: rate limits, file caps, platform support, approval defaults and pricing. Those are also the parts that decide whether a reviewer keeps working once agents are producing the queue.&lt;/p&gt;

&lt;p&gt;Claims checked 2026-10-27 against each vendor's own documentation and pricing page.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>pullrequests</category>
      <category>agenticcoding</category>
    </item>
    <item>
      <title>The review throughput ceiling that pricing pages leave out</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Wed, 28 Oct 2026 10:00:02 +0000</pubDate>
      <link>https://dev.to/tessainsley/the-review-throughput-ceiling-that-pricing-pages-leave-out-4lbo</link>
      <guid>https://dev.to/tessainsley/the-review-throughput-ceiling-that-pricing-pages-leave-out-4lbo</guid>
      <description>&lt;p&gt;Two limits decide whether an AI reviewer keeps pace with agent output, and neither of them is on the pricing page in a form you can plan with. One is how many files a reviewer will read in a single pass. The other is how many reviews a developer seat is allowed per hour. The file cap is easy to hit deliberately and easy to avoid. The hourly allowance erodes under ordinary use, which is why most teams meet it as an error message on a pull request rather than as a decision they made.&lt;/p&gt;

&lt;p&gt;Both numbers are published. CodeRabbit documents them in the &lt;a href="https://docs.coderabbit.ai/management/plans" rel="noopener noreferrer"&gt;rate limits section of its plans page&lt;/a&gt;, GitHub states what it does and does not cap on its &lt;a href="https://docs.github.com/en/copilot/how-tos/copilot-on-github/set-up-copilot/configure-code-review" rel="noopener noreferrer"&gt;code review configuration page&lt;/a&gt;, and Kodus publishes its &lt;a href="https://docs.kodus.io/en/how_to_use/pricing" rel="noopener noreferrer"&gt;plan limits&lt;/a&gt; separately from its feature table. Read together, they describe a ceiling that a team adopting agents will reach sooner than it expects.&lt;/p&gt;

&lt;h2&gt;
  
  
  What counts as a review event
&lt;/h2&gt;

&lt;p&gt;The allowance question only becomes concrete once you know which actions draw it down. CodeRabbit counts one review event every time it evaluates a pull request, and its &lt;a href="https://docs.coderabbit.ai/management/rate-limits" rel="noopener noreferrer"&gt;rate limit documentation&lt;/a&gt; lists the actions that produce one. Pull request opened is one. A push is one. &lt;code&gt;@coderabbitai review&lt;/code&gt; is one. Force-push, rebase, reopen, and draft marked ready for review are one each.&lt;/p&gt;

&lt;p&gt;The pattern underneath the list matters more than the list. CodeRabbit reviews pushes, not commits. Three commits pushed together spend one review event. The same three commits pushed one at a time spend three. Editing a file in the GitHub web UI is a commit and a push in a single click, so fixing three typos in three files through the web editor spends three reviews. The Update branch button and the Resolve conflicts button each write a commit, so each one spends a review as well.&lt;/p&gt;

&lt;p&gt;None of that is unusual behavior. It is what a reviewer does when a change is actively worked on. The point is that the consumption comes from the shape of the workflow rather than from anyone choosing to run more reviews, and the defaults are what produce it: automatic reviews on, an incremental review on every push, and a pause after five reviewed commits.&lt;/p&gt;

&lt;p&gt;Kodus approaches the same problem from the other side. Its &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/flow" rel="noopener noreferrer"&gt;code review flow&lt;/a&gt; skips when there are no new commits since the last run, when a push contains only merge commits with no effective change, when every changed file matches an ignore pattern, or when the pull request exceeds the configured file limit. Its &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/configs/general" rel="noopener noreferrer"&gt;general settings&lt;/a&gt; default the cadence to pausing after three pushes inside a fifteen-minute window, which keeps an active branch from generating a review per keystroke.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the refill rate puts the ceiling
&lt;/h2&gt;

&lt;p&gt;The per-hour numbers are not quotas that reset at the top of the hour. CodeRabbit describes them as rolling allowances: additional reviews become available as earlier ones age out of the window. On Essentials that is five reviews per hour, on Team eight, on Advanced ten, on Enterprise twelve, and on Free one.&lt;/p&gt;

&lt;p&gt;Then the part that changes the arithmetic for agent-heavy repositories. CodeRabbit's Fair Usage Limits Policy lowers the refill rate based on recent activity. On Essentials, a developer with 0 to 29 reviews in the last 7 days refills at 5 per hour; at 60 or more, the refill rate is 1 review per hour, one at a time. Team drops from 8 to 1 at 70 or more. Advanced drops from 10 to 1 at 80 or more.&lt;/p&gt;

&lt;p&gt;Read those bands next to what agent adoption does to pull request volume. LinearB's &lt;a href="https://linearb.io/library/ai-in-software-development" rel="noopener noreferrer"&gt;2026 software engineering benchmarks&lt;/a&gt;, built from more than 8.1 million pull requests, reports agentic pull requests at a median of 89 lines and 293 lines at the 75th percentile, against 157 lines at the same percentile for unassisted work. Agent changes are not individually enormous. They are numerous, and they wait: agentic pull requests take 17.6 hours at the 75th percentile before review starts, against 3.4 hours for unassisted work.&lt;/p&gt;

&lt;p&gt;So the binding constraint on agent volume is count, not size. A developer seat reviewing a stream of small agent changes can reach the band where the refill rate collapses, and the symptom is a reviewer that has started spacing out its own reviews. The same dynamic is what a queue ranker exists to handle once volume outruns review hours, and &lt;a href="https://agentwrotethis.dev/blog/what-your-review-queues-ranker-can-and-cannot-see/" rel="noopener noreferrer"&gt;what a ranker can and cannot see&lt;/a&gt; is a separate question from whether the reviewer is allowed to run.&lt;/p&gt;

&lt;h2&gt;
  
  
  The file cap, and why it rarely binds on agent work
&lt;/h2&gt;

&lt;p&gt;Every reviewer that caps files per pass publishes a different number. CodeRabbit's files-per-review column is the maximum number of files it reads in a single review, counted after path filter exclusions, and it runs 3 on Free, 1 on the OSS tier, 150 on Essentials, and 300 on Team, Advanced and Enterprise. When an eligible GitHub pull request exceeds its included file limit but stays at or under 300 files, CodeRabbit skips the automatic review and can offer a usage-priced review instead. Pull requests above 300 files are not supported through that action, and other Git providers show the file-limit message without the interactive option.&lt;/p&gt;

&lt;p&gt;The usage path has its own published rate. CodeRabbit's &lt;a href="https://docs.coderabbit.ai/management/usage-based-addon" rel="noopener noreferrer"&gt;usage-based reviews documentation&lt;/a&gt; prices a credit at $1.00 and covers 4 files per credit, which works out to $0.25 per reviewed file. A 300-file pull request on that path is roughly $75, before anyone has read the result. Usage-based reviews are available to Essentials, Team, Advanced and Enterprise organizations, and the continuation mode has three settings: Automatic continues and bills, On demand pauses and asks a seated developer to authorize each review, and Off stops reviews until the allowance refills.&lt;/p&gt;

&lt;p&gt;Kodus takes a different position on the count. Its plans page states that reviews are unlimited on every plan, with the only hard limit being that it does not review pull requests with more than 2,000 changed files, and a configurable file limit that causes a skip below that. So the cap exists in both products, but in one it is a billing boundary and in the other it is a single documented ceiling.&lt;/p&gt;

&lt;p&gt;GitHub Copilot code review does not publish a files-per-review cap on the pages I read, so the number is unknown from its documentation. What it publishes instead is a review effort level with Lite, Balanced and Max values, where Max is listed as coming soon and the built-in default is Balanced, and an estimated consumption of $0.05 to $1 of AI credits for a Lite review and $0.25 to $5 for a Balanced one, excluding Actions minutes. Those are vendor estimates, not measurements.&lt;/p&gt;

&lt;p&gt;One more property worth knowing, because it affects what a review is worth rather than whether it runs. Copilot's agentic capabilities, which include full project context gathering and passing suggestions to the cloud agent, execute on GitHub Actions runners. GitHub's overview states that if Actions is unavailable or the workflow fails, reviews are still generated but without those capabilities. A repository can produce a shallower review because a runner was unavailable, and nothing in the comment says which mode you got.&lt;/p&gt;

&lt;p&gt;The file cap sounds like the constraint to design around. On a normal day it is not. With agent pull requests sitting at 293 lines at the 75th percentile, the cap only binds on the regenerated file, the lockfile churn that path filters did not exclude, and the monorepo-wide refactor. The count-based limit is the one a team will meet in week one.&lt;/p&gt;

&lt;h2&gt;
  
  
  The tools side by side
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Reviewer&lt;/th&gt;
&lt;th&gt;Reviews per developer&lt;/th&gt;
&lt;th&gt;Files per review&lt;/th&gt;
&lt;th&gt;What happens at the limit&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit Free&lt;/td&gt;
&lt;td&gt;1 per hour, rolling&lt;/td&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;Review skipped; PR summarization remains&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit Essentials&lt;/td&gt;
&lt;td&gt;5 per hour, falling to 1 at 60+ reviews in 7 days&lt;/td&gt;
&lt;td&gt;150&lt;/td&gt;
&lt;td&gt;Skipped, with a usage-priced review offered up to 300 files&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit Team&lt;/td&gt;
&lt;td&gt;8 per hour, falling to 1 at 70+ reviews in 7 days&lt;/td&gt;
&lt;td&gt;300&lt;/td&gt;
&lt;td&gt;Skipped, with a usage-priced review offered up to 300 files&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit Advanced and Enterprise&lt;/td&gt;
&lt;td&gt;10 and 12 per hour, falling to 1 at 80+ reviews in 7 days&lt;/td&gt;
&lt;td&gt;300&lt;/td&gt;
&lt;td&gt;Skipped, with a usage-priced review offered up to 300 files; above 300 files unsupported&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot code review&lt;/td&gt;
&lt;td&gt;Not stated per hour on the pages reviewed&lt;/td&gt;
&lt;td&gt;Not stated; effort level instead&lt;/td&gt;
&lt;td&gt;Effort level changes depth and estimated credit cost, not admission&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus&lt;/td&gt;
&lt;td&gt;Unlimited on every plan&lt;/td&gt;
&lt;td&gt;Configurable file limit; hard ceiling of 2,000 changed files&lt;/td&gt;
&lt;td&gt;Review skipped when the pull request exceeds the configured file limit&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two rows in that table are numbers I could not verify and have marked as such rather than filled in. A vendor's silence on a limit is not evidence that the limit does not exist, and it is worth asking about directly before a rollout depends on it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to check before you install
&lt;/h2&gt;

&lt;p&gt;The two numbers to pull from a vendor's own documentation are the refill rate for a developer seat and the files-per-review cap, and the refill rate is the one that will shape your rollout. Three settings move it without changing the product.&lt;/p&gt;

&lt;p&gt;Set the review cadence to pushes with a pause rather than every commit, and confirm what the pause threshold is. CodeRabbit's &lt;code&gt;auto_incremental_review&lt;/code&gt; and &lt;code&gt;auto_pause_after_reviewed_commits&lt;/code&gt; are the controls, and Kodus defaults to three pushes in fifteen minutes. Then keep lockfiles, generated code and vendored directories out of the review scope through path filters, because a cap counted after exclusions is a cap that a well-built filter never reaches. Finally, watch for the rate-limit notice as a configuration signal rather than a capacity problem. It means the workflow is producing more review events than the allowance covers, and the cheapest fix is usually fewer events per change rather than a higher plan.&lt;/p&gt;

&lt;p&gt;Where the verdict of the review has to clear a merge gate, that is a separate decision from the throughput ceiling, and &lt;a href="https://agentwrotethis.dev/blog/which-ai-reviewer-approvals-satisfy-your-merge-requirement/" rel="noopener noreferrer"&gt;the approval toggles and path globs&lt;/a&gt; are set in the repository. Where the number of open pull requests has already outrun review hours, the ceiling is not the first thing to fix, and &lt;a href="https://agentwrotethis.dev/blog/when-review-time-plateaued-reviewers-had-stopped-reading/" rel="noopener noreferrer"&gt;the plateau in review time on the largest changes&lt;/a&gt; is a better signal to start from. Coverage per change, which is a config question rather than a capacity one, is the number that decides &lt;a href="https://agentwrotethis.dev/blog/how-much-of-code-review-an-ai-reviewer-actually-carries/" rel="noopener noreferrer"&gt;how much of the review an AI reviewer carries&lt;/a&gt; once it is running at all.&lt;/p&gt;

&lt;p&gt;Vendor limits move, and these are the kind of numbers that change between quarters. Read them from the plans page rather than from a screenshot of it.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>pullrequests</category>
      <category>reviewmetrics</category>
    </item>
    <item>
      <title>AI code review on GitHub: what the platform decides for you</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Fri, 23 Oct 2026 00:30:09 +0000</pubDate>
      <link>https://dev.to/tessainsley/ai-code-review-on-github-what-the-platform-decides-for-you-390f</link>
      <guid>https://dev.to/tessainsley/ai-code-review-on-github-what-the-platform-decides-for-you-390f</guid>
      <description>&lt;p&gt;Search for how to add an AI reviewer to GitHub and you land on a pile of tool READMEs, a Reddit thread asking whether any of them are worth it, and GitHub's own Copilot documentation. Each one describes the product. None of them describe the layer underneath, which is where the behavior of the reviewer actually gets decided.&lt;/p&gt;

&lt;p&gt;A reviewer installed on GitHub can read certain files, write certain things, and carries a credential while it does. Those are set by the installation and the workflow, before the model sees a single line of the diff. Get them wrong and the reviewer still posts comments and still looks healthy, which means the failure does not arrive as an error. It arrives as context that quietly was not there.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two ways a reviewer attaches to GitHub, owned by different parties
&lt;/h2&gt;

&lt;p&gt;The first shape is a hosted app installed on the repository. It receives a scoped token from GitHub, runs on the vendor's infrastructure, and reads the diff through the API. You control neither the runner nor the working tree the model sees. GitHub Copilot code review, CodeRabbit, Qodo, and Greptile all work this way to varying degrees.&lt;/p&gt;

&lt;p&gt;The second shape is a workflow inside your own repository. &lt;a href="https://github.com/Nikita-Filonov/ai-review" rel="noopener noreferrer"&gt;AI Review&lt;/a&gt; ships as a pip package and a Docker image, runs in your pipeline, and posts inline comments, summaries, and now replies on existing review threads through a token you supply. Its README states that it never proxies or inspects your requests, and that it talks to OpenAI, Claude, Gemini, Ollama, Bedrock, OpenRouter, or Azure OpenAI depending on your config. &lt;a href="https://github.com/anthropics/claude-code-action" rel="noopener noreferrer"&gt;claude-code-action&lt;/a&gt; runs Claude Code inside a job in your repository with your permissions block. PR-Agent and Alibaba's OpenCodeReview sit in the same family. Kodus spans both shapes: a hosted app, plus a self-hosted deployment and a CLI that runs the review wherever you point it.&lt;/p&gt;

&lt;p&gt;The difference between the two shapes lands in who owns the failure. With a hosted app, the API access the vendor negotiates is the whole story, and their scoping choices become yours to accept. With a workflow, the runner, the checkout, and the token are repository configuration, and so is every way they can be configured wrong.&lt;/p&gt;

&lt;h2&gt;
  
  
  The trigger event sets what the job is allowed to hold
&lt;/h2&gt;

&lt;p&gt;GitHub's &lt;a href="https://docs.github.com/en/actions/reference/security/secure-use" rel="noopener noreferrer"&gt;secure use reference for Actions&lt;/a&gt; is direct about the starting position: the GITHUB_TOKEN should default to read-only for repository contents, and individual jobs should raise permissions only as far as they need. A pull request from a fork already runs with a read-only token and no secrets.&lt;/p&gt;

&lt;p&gt;An AI reviewer needs a secret. Either the model provider key or an API token for the review service. That pushes teams toward &lt;code&gt;pull_request_target&lt;/code&gt;, and it works, because that event runs with the base repository's GITHUB_TOKEN and access to repository and organization secrets. It also means the job holds credentials while a pull request from anyone can influence what the job does. GitHub's separate guide on &lt;a href="https://docs.github.com/en/actions/reference/security/securely-using-pull_request_target" rel="noopener noreferrer"&gt;securely using pull_request_target&lt;/a&gt; explains the trade and names the specific way teams break it: checking out the untrusted pull request head into the workspace root before the trusted step runs.&lt;/p&gt;

&lt;p&gt;Anthropic documents the same pattern for its own action and recommends a two-checkout arrangement. The base ref goes at the workspace root, since the action expects a git repository there. The head ref goes into a subdirectory that gets passed to Claude through &lt;code&gt;--add-dir&lt;/code&gt;, so the model can read the proposed changes without them occupying the paths your trusted configuration resolves against.&lt;/p&gt;

&lt;p&gt;If you want the review to post inline comments, the job needs &lt;code&gt;pull-requests: write&lt;/code&gt;. If you want it to push fix commits or resolve threads, it needs more, and each additional scope is something a prompt injection in the diff can use. Writing the permissions block is writing the review policy. A reviewer that cannot push produces a bad comment when it is wrong. A reviewer that can push produces a bad commit.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which files the reviewer reads, and where they came from
&lt;/h2&gt;

&lt;p&gt;This is the question I would want answered before installing anything, and it is the one most vendor pages skip: when an agentic reviewer runs against a pull request, which files in its working tree came from the base branch?&lt;/p&gt;

&lt;p&gt;Anthropic answers it for its own tool in the &lt;a href="https://github.com/anthropics/claude-code-action/blob/main/docs/security.md" rel="noopener noreferrer"&gt;claude-code-action security documentation&lt;/a&gt;. Before Claude starts, the action restores a fixed list of paths from the pull request's base branch: &lt;code&gt;.claude/&lt;/code&gt;, &lt;code&gt;.mcp.json&lt;/code&gt;, &lt;code&gt;.claude.json&lt;/code&gt;, &lt;code&gt;.gitmodules&lt;/code&gt;, &lt;code&gt;.ripgreprc&lt;/code&gt;, &lt;code&gt;CLAUDE.md&lt;/code&gt;, &lt;code&gt;CLAUDE.local.md&lt;/code&gt;, and &lt;code&gt;.husky/&lt;/code&gt;. Paths on that list that do not exist on the base branch are deleted, and the pull-request versions are kept aside under &lt;code&gt;.claude-pr/&lt;/code&gt; for reference. Everything else in the working tree stays at the pull request head, including &lt;code&gt;package.json&lt;/code&gt;, lockfiles, the Makefile, &lt;code&gt;node_modules/&lt;/code&gt;, and formatter or linter configuration.&lt;/p&gt;

&lt;p&gt;The split is deliberate and it is also incomplete by design, which the doc says outright. If a hook in the base branch's &lt;code&gt;.claude/settings.json&lt;/code&gt; runs a package manager script, a make target, or a repo-relative script, that command resolves through files the pull request supplies. The recommendation is to call the tool directly with a pinned version and pass configuration on the command line, something like &lt;code&gt;bunx prettier@3.5.3 --no-config --write .&lt;/code&gt; rather than &lt;code&gt;bun run format&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;A reviewer whose rules come from files in the repository has the same exposure. If your AI reviewer reads &lt;code&gt;AGENTS.md&lt;/code&gt; or &lt;code&gt;.cursorrules&lt;/code&gt; from the pull request head, the diff can rewrite the rules that are being applied to it. Base-branch rule loading is the property worth checking, and it is the reason I keep pointing at where rules come from rather than how many a tool claims to support. Kodus documents a &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/configs/rules_file_detection.md" rel="noopener noreferrer"&gt;rules file detection&lt;/a&gt; path that imports &lt;code&gt;.cursorrules&lt;/code&gt;, &lt;code&gt;.cursor/rules/**/*.mdc&lt;/code&gt;, &lt;code&gt;.github/copilot-instructions.md&lt;/code&gt;, and &lt;code&gt;AGENTS.md&lt;/code&gt;, together with inheritance from global to repository to directory, which is the shape that lets you decide what is centrally controlled and what a pull request can touch. If the reviewer reads sibling repositories for cross-repo context, that set of repositories is configuration too, and it is the &lt;a href="https://agentwrotethis.dev/blog/multi-repo-ai-review-a-context-problem-not-a-volume-problem/" rel="noopener noreferrer"&gt;same context problem that shows up with monorepos&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to check before you install anything
&lt;/h2&gt;

&lt;p&gt;The criteria that separate these options are not model quality. They are where the job runs, who holds the credential, where the rules are read from, and what a wrong review is capable of doing.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Hosted app&lt;/th&gt;
&lt;th&gt;Action in your CI&lt;/th&gt;
&lt;th&gt;Self-hosted platform&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Where the review runs&lt;/td&gt;
&lt;td&gt;Vendor infrastructure&lt;/td&gt;
&lt;td&gt;Your runner, under the event you choose&lt;/td&gt;
&lt;td&gt;Your infrastructure&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Who holds the provider credential&lt;/td&gt;
&lt;td&gt;Vendor&lt;/td&gt;
&lt;td&gt;Your repository secrets&lt;/td&gt;
&lt;td&gt;Your deployment&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Where rules are read from&lt;/td&gt;
&lt;td&gt;Vendor config, usually plus repo files&lt;/td&gt;
&lt;td&gt;Files in the checkout, at whichever ref you set&lt;/td&gt;
&lt;td&gt;Your deployment, with rule inheritance across scopes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What a bad review can do&lt;/td&gt;
&lt;td&gt;Depends on the scopes the app was granted&lt;/td&gt;
&lt;td&gt;Bounded by the job's permissions&lt;/td&gt;
&lt;td&gt;Bounded by the token you issue&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Failure mode when misconfigured&lt;/td&gt;
&lt;td&gt;Missing context you cannot inspect&lt;/td&gt;
&lt;td&gt;Silent gaps in the checkout&lt;/td&gt;
&lt;td&gt;Silent gaps in the config&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Examples&lt;/td&gt;
&lt;td&gt;Copilot code review, CodeRabbit, Qodo, Greptile&lt;/td&gt;
&lt;td&gt;AI Review, claude-code-action, PR-Agent, OpenCodeReview&lt;/td&gt;
&lt;td&gt;Kodus self-hosted, OpenCodeReview on your own runner&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The table is not a ranking. It is a list of the four things to ask a vendor before you connect a repository, and the honest answer is that the hosted column is often unknown from the outside. That is not a reason to avoid hosted reviewers. It is a reason to know which column you are in before you assume the reviewer sees what you think it sees.&lt;/p&gt;

&lt;p&gt;There is also a cost side to the choice, and it mostly lands on the self-hosted and CI columns, since those are the ones where runners, setup steps, and caches become yours to pay for. I looked at &lt;a href="https://agentwrotethis.dev/blog/what-self-hosting-ai-code-review-actually-costs/" rel="noopener noreferrer"&gt;what self-hosting an AI reviewer actually costs&lt;/a&gt; in more detail, and the short version is that the setup cost recurs on every push rather than once per installation.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the gate sits, and who decides
&lt;/h2&gt;

&lt;p&gt;The last piece is the one that gets decided in the repository settings rather than in the tool, which is what the reviewer is allowed to do about a failing review.&lt;/p&gt;

&lt;p&gt;Most reviewers post findings and leave the merge decision to a human, and that is the safe default because it keeps a wrong finding in the comment thread where it costs a minute. The alternative is letting the reviewer block a merge, which only makes sense if you have decided what a block means and who can clear it. Kodus explains its own position in the &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/policy.md" rel="noopener noreferrer"&gt;review policy documentation&lt;/a&gt;, including what blocks a pull request, what does not, and who decides. That is the level of detail to ask for from any reviewer you plan to put in front of a merge queue, because the general problem with &lt;a href="https://agentwrotethis.dev/blog/review-policy-cant-rely-on-flagging-ai-code/" rel="noopener noreferrer"&gt;leaning on review policy to catch AI-authored code&lt;/a&gt; is that a policy built around guessing which code was machine-written tends to fail quietly when the guess is wrong.&lt;/p&gt;

&lt;p&gt;GitHub's own documentation for Copilot code review is worth reading on this point; the default review action is a comment, not an approval, so the gate stays where it was unless you move it on purpose.&lt;/p&gt;

&lt;h2&gt;
  
  
  A starting checklist
&lt;/h2&gt;

&lt;p&gt;Read the security page before the features page. If the reviewer runs as an action, find out which event triggers it and what that event grants the job, then check whether the checkout puts any untrusted ref at the workspace root. Confirm the &lt;code&gt;permissions:&lt;/code&gt; block is read-only except for the one scope the reviewer needs to comment. If the reviewer reads rule files or configuration from the repository, establish whether those come from the base branch or the pull request head, and treat anything from the head as input the diff controls. Then decide, deliberately, whether the reviewer comments or blocks.&lt;/p&gt;

&lt;p&gt;Four answers, obtainable before installation, and they tell you more about how a reviewer will behave on your repository than any benchmark score does.&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Does an AI code reviewer on GitHub need pull_request_target?
&lt;/h3&gt;

&lt;p&gt;Only if it must read secrets. Pull requests from forks run with a read-only GITHUB_TOKEN and no secrets, so a reviewer that calls a model provider needs a trigger that has credentials. &lt;code&gt;pull_request_target&lt;/code&gt; grants the base repository's token and secrets, which is why GitHub documents checking out the untrusted head ref into the workspace root as the specific mistake to avoid. Check out the base ref at the workspace root and pass the head ref through a subdirectory instead.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can a pull request change the rules my AI reviewer applies?
&lt;/h3&gt;

&lt;p&gt;It can, if the reviewer reads its rule files from the pull request head. Agentic reviewers restore a fixed list of configuration paths from the base branch for exactly this reason, and everything outside that list stays at the head. If your coding standards live in &lt;code&gt;AGENTS.md&lt;/code&gt; or &lt;code&gt;.cursorrules&lt;/code&gt; in the repository, confirm which ref the reviewer loads them from.&lt;/p&gt;

&lt;h3&gt;
  
  
  Should an AI reviewer be allowed to block a merge?
&lt;/h3&gt;

&lt;p&gt;That depends on whether you have defined what a block means and who can clear it. The safer default is comment-only, because a wrong finding costs a minute in a thread rather than a stuck pull request. Reviewers that do block usually document what blocks a merge and what does not, and that documentation is the thing to read before putting one in front of a merge queue.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Originally published at &lt;a href="https://agentwrotethis.dev/blog/ai-code-review-on-github-what-the-platform-decides-for-you/" rel="noopener noreferrer"&gt;agentwrotethis.dev&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>githubactions</category>
      <category>codereview</category>
      <category>pullrequests</category>
    </item>
    <item>
      <title>Which AI reviewer approvals satisfy your merge requirement</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Wed, 21 Oct 2026 00:30:06 +0000</pubDate>
      <link>https://dev.to/tessainsley/which-ai-reviewer-approvals-satisfy-your-merge-requirement-4doc</link>
      <guid>https://dev.to/tessainsley/which-ai-reviewer-approvals-satisfy-your-merge-requirement-4doc</guid>
      <description>&lt;p&gt;Whether an AI reviewer's approval clears a merge requirement is a repository setting, and on most platforms it starts off. GitHub's Copilot code review will post a review the moment it is enabled, but a separate toggle decides whether that review can submit an approving review, and a second decides whether the approval counts toward the required approvals on the branch. CodeRabbit's request-changes workflow ships disabled and only exists on paid tiers. Kodus documents auto-approve as optional and recommends leaving blocking behavior off until your thresholds and CI are settled.&lt;/p&gt;

&lt;p&gt;The consequence is that a team can run an AI reviewer for months, watch it comment on every pull request, and never notice its approval was never in the merge path. The reverse is worse. Someone enables the toggle, a bot approval clears the gate on a change nobody read, and the first time anyone notices is an incident.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the approval toggle actually controls
&lt;/h2&gt;

&lt;p&gt;GitHub splits this across three settings on the repository, under Settings, then Copilot, then Code review. Allow Copilot to approve pull requests turns on approving reviews. Allow Copilot approvals to count toward merge requirements is the one that lets those approvals satisfy branch protection. The third is a file path list, one glob per line, up to 15 entries, which narrows where an approval counts: it counts only on pull requests where every changed file matches one of the globs.&lt;/p&gt;

&lt;p&gt;That glob list is the most useful of the three and the one most teams leave blank. If the bot is allowed to approve and its approvals count, an empty list means a bot approval carries the same weight on a payment handler as it does on a changelog. Filling it in keeps the approval in the merge path for the changes where it is worth something and out of it everywhere else. GitHub labels the whole arrangement as public preview, which is worth knowing if your merge gate is load-bearing.&lt;/p&gt;

&lt;p&gt;Kodus takes the opposite default and says so in its &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/policy.md" rel="noopener noreferrer"&gt;review policy documentation&lt;/a&gt;: suggestions are non-blocking by default, request-changes and auto-approve are optional behaviors you turn on, and the page recommends enabling blocking only where the team has agreed thresholds and strong CI in place. That is a defensible starting position because it keeps the failure mode to a noisy thread rather than a stuck pull request.&lt;/p&gt;

&lt;h2&gt;
  
  
  The effort dial is a separate control from the approval
&lt;/h2&gt;

&lt;p&gt;Copilot code review has a review effort level with three values. Lite is described as a standard review, Balanced goes deeper on complex logic, security-sensitive code, and cross-service changes, and Max is listed as coming soon. The built-in default is Balanced.&lt;/p&gt;

&lt;p&gt;Effort changes what the reviewer examines and what it costs. GitHub's own estimate is $0.05 to $1 of AI credits for a Lite review and $0.25 to $5 for a Balanced one, excluding Actions minutes, with consumption rising alongside pull request size and repository custom instructions. Those are estimates from the vendor, not measurements, so treat the ranges as an order of magnitude.&lt;/p&gt;

&lt;p&gt;Effort and approval are independent. Raising the effort level changes what the reviewer finds. It does not change whether the reviewer's approval can clear the gate, and it does not change which paths that approval counts on. A team that wants a stronger review and a narrower gate sets two different controls, and teams regularly conflate them.&lt;/p&gt;

&lt;p&gt;There is a second layer here that shows up on a bad CI day. Copilot's agentic capabilities, meaning full project context gathering and passing suggestions to the cloud agent, run on GitHub Actions. If Actions is unavailable or the workflow fails, reviews still post, just without the agentic extras. The same repository can produce a shallower review because a runner was unavailable, and nothing in the comment tells you which mode you got. That is the coverage question, and it is why &lt;a href="https://agentwrotethis.dev/blog/how-much-of-code-review-an-ai-reviewer-actually-carries/" rel="noopener noreferrer"&gt;coverage per change is the number to ask a vendor for&lt;/a&gt; rather than a comment count.&lt;/p&gt;

&lt;h2&gt;
  
  
  When an approval stays pending
&lt;/h2&gt;

&lt;p&gt;CodeRabbit's &lt;a href="https://docs.coderabbit.ai/pr-reviews/request-changes-workflow.md" rel="noopener noreferrer"&gt;request changes workflow&lt;/a&gt; is the most explicit of the tools about this. When enabled, CodeRabbit requests changes if a review posts actionable inline comments, and approves once the approval requirements are met. Approval stays pending when the latest review is missing, in progress, failed, or rate-limited; when the current pull request HEAD is not among the commits it reviewed; when a required review thread is unresolved; when a pre-merge check is failing; or when HEAD changes while CodeRabbit is verifying the requirements.&lt;/p&gt;

&lt;p&gt;Two of those are worth reading twice. A rate-limited run can still resolve threads it considers addressed, but the approval stays pending because the latest commit did not complete a review. And if every changed file is excluded by path filters, CodeRabbit skips the review content but still evaluates the remaining approval requirements and can approve. An empty review is not the same as a blocked one. Path filters can produce an approval on a change the reviewer never read.&lt;/p&gt;

&lt;p&gt;CodeRabbit also ships two override commands, @coderabbitai resolve and @coderabbitai approve, which can submit approval without requiring the latest commit to have completed a review and without pre-merge checks passing. By default the pull request author can run them on their own pull request, and reviews.allow_author_approval: false turns that off. So with the workflow on, an author-facing command can approve around the checks the workflow exists to enforce. Whether that is acceptable is a policy decision, but it should be a made one, in the same spirit as &lt;a href="https://agentwrotethis.dev/blog/review-policy-cant-rely-on-flagging-ai-code/" rel="noopener noreferrer"&gt;a review policy that cannot lean on detecting AI code&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who the review is billed to
&lt;/h2&gt;

&lt;p&gt;Copilot attributes an automatic review's AI credits to the pull request author by default, and a manually requested review to whoever requested it. For pull requests authored by the Copilot cloud agent, usage is attributed first to the human co-author, and if that person cannot be billed, to the organization. For pull requests authored by other bots, or when a bot requests the review, it is billed directly to the organization.&lt;/p&gt;

&lt;p&gt;The attribution is about cost, and it still shapes who enables what. An organization that pays for every bot-authored review has a reason to keep automatic review off on agent-heavy repositories, and that choice removes the reviewer from those pull requests entirely. The trigger event and the token scopes sit in the same layer, which is the part &lt;a href="https://agentwrotethis.dev/blog/ai-code-review-on-github-what-the-platform-decides-for-you/" rel="noopener noreferrer"&gt;the platform decides for you&lt;/a&gt; before a model sees the diff.&lt;/p&gt;

&lt;h2&gt;
  
  
  The tools side by side
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Approval default&lt;/th&gt;
&lt;th&gt;What can block or clear a merge&lt;/th&gt;
&lt;th&gt;Limits worth knowing&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot code review&lt;/td&gt;
&lt;td&gt;Approval off by default, counting toward merge requirements off by default&lt;/td&gt;
&lt;td&gt;Approving reviews, then a separate toggle to count them as required approvals&lt;/td&gt;
&lt;td&gt;File path globs, up to 15, gate which pull requests count; public preview&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit&lt;/td&gt;
&lt;td&gt;Request-changes workflow disabled by default, Essentials tier and above&lt;/td&gt;
&lt;td&gt;Requests changes on actionable inline comments, approves when requirements are met&lt;/td&gt;
&lt;td&gt;Approval stays pending on a rate limit or a stale HEAD; author-facing resolve and approve commands&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus&lt;/td&gt;
&lt;td&gt;Non-blocking suggestions by default&lt;/td&gt;
&lt;td&gt;Request-changes and auto-approve are optional, enabled per repository&lt;/td&gt;
&lt;td&gt;Docs recommend blocking only with agreed thresholds and strong CI in place&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Graphite AI reviews&lt;/td&gt;
&lt;td&gt;Reviews run without manual configuration&lt;/td&gt;
&lt;td&gt;Not documented on the pages I read&lt;/td&gt;
&lt;td&gt;unknown&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Graphite's AI reviews page describes automatic review of every pull request and points at acceptance rates and rule effectiveness in a dashboard, but the pages I read do not document approval or merge-gate behavior. That is an unknown, not an absence.&lt;/p&gt;

&lt;h2&gt;
  
  
  Questions to settle before a bot approval counts
&lt;/h2&gt;

&lt;p&gt;Four questions cover most of the risk.&lt;/p&gt;

&lt;p&gt;Does the approval count as a required approval, and on which paths? If the answer is all paths, the glob list is your first piece of work.&lt;/p&gt;

&lt;p&gt;Can the approval survive a stale HEAD or a rate limit? If not, the bot will be the reason a pull request sits, and you should know that before reviewers start blaming each other.&lt;/p&gt;

&lt;p&gt;Who can override it, and can the author of the pull request override their own? An override command is a feature. An override command that the author runs on their own change is a policy decision.&lt;/p&gt;

&lt;p&gt;What does the reviewer do when it reviewed nothing? Path filters and failed agentic runs both produce a posted review with less behind it than the comment suggests.&lt;/p&gt;

&lt;p&gt;None of these are reasons to keep a bot out of the merge gate. They are the settings that decide whether the gate means what the team thinks it means. The reviewer's opinion and its authority are separate things, and only one of them is set on the branch.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>githubactions</category>
      <category>pullrequests</category>
    </item>
    <item>
      <title>What your review queue's ranker can and cannot see</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Mon, 19 Oct 2026 02:30:01 +0000</pubDate>
      <link>https://dev.to/tessainsley/what-your-review-queues-ranker-can-and-cannot-see-1aaa</link>
      <guid>https://dev.to/tessainsley/what-your-review-queues-ranker-can-and-cannot-see-1aaa</guid>
      <description>&lt;p&gt;A team with more open pull requests than review hours does not need another reviewer first. It needs something that decides which pull request to look at, and on at least one platform that decision is now a documented product feature with stated limits. CodeRabbit's Triage builds a ranked queue across repositories, and its documentation spends nearly as much space on what the ranking cannot see as on what it can. That part is worth reading before you put a ranker in front of a backlog that agents keep filling.&lt;/p&gt;

&lt;p&gt;This matters because the volume problem agents create shows up as a ranking problem before it shows up as a review-time problem. When volume rises and review time plateaus, the plateau is a disengagement signal rather than a throughput win, which is what &lt;a href="https://agentwrotethis.dev/blog/when-review-time-plateaued-reviewers-had-stopped-reading/" rel="noopener noreferrer"&gt;the Salesforce review data showed&lt;/a&gt;. A ranker is the tool teams reach for at that point, so it is worth knowing exactly what evidence it ranks on.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the mechanical state stops being the signal
&lt;/h2&gt;

&lt;p&gt;Triage separates two questions per pull request. Priority is how much acting on it is worth compared to everything else in the queue. Next action is what specifically has to happen for it to move. Its &lt;a href="https://docs.coderabbit.ai/triage/prioritization.md" rel="noopener noreferrer"&gt;prioritization documentation&lt;/a&gt; keeps those apart on purpose, and the examples make the split concrete: failing checks, merge conflicts, draft status, a branch behind its base, unresolved review threads, and a stale approval all shape the next action and can make a pull request un-mergeable, while none of them make it urgent.&lt;/p&gt;

&lt;p&gt;A trivial dependency bump with red checks should not outrank a customer-facing fix that is simply waiting on a reviewer. The state of a pull request tells you what to do about it. It does not tell you what the change is worth.&lt;/p&gt;

&lt;p&gt;That is the whole argument for a queue over a repository list once volume climbs. Sorting by last-updated or by author puts a decision in front of you that has nothing to do with consequence, and reviewers respond by reading the top of the list.&lt;/p&gt;

&lt;h2&gt;
  
  
  The ranker publishes what it cannot match
&lt;/h2&gt;

&lt;p&gt;Administrators describe how their organization wants pull requests ranked, in plain language, and CodeRabbit turns that into an ordered list of rules assigning P0 through P3. The matchable facts are broad: the repository, its owner, the target branch, draft state, change type, issue severity, risk, security risk, blast radius, review effort, check status, merge conflict status, workflow state, next action, involved people with their roles, words in the title, and how many other pull requests are blocked behind this one.&lt;/p&gt;

&lt;p&gt;Then the exclusions. Rules cannot match labels, file paths, CODEOWNERS, team membership, assignees, or the code itself. When part of a description asks for something rules cannot express, CodeRabbit reports that part as unsupported and does not apply it, rather than approximating it.&lt;/p&gt;

&lt;p&gt;The CODEOWNERS exclusion is the one to underline. CODEOWNERS is GitHub's own answer to who owns which path, and the queue's ranking layer cannot read it. The two systems answer different questions. The ownership file decides who gets asked to review, and the ranker decides what is worth reviewing now, and nothing forces them to agree. If your mental model of priority is whatever touches the paths your senior people own, that is not expressible as a ranking rule, and the tool says so instead of guessing.&lt;/p&gt;

&lt;p&gt;The file itself is also less solid than people assume. GitHub's &lt;a href="https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners" rel="noopener noreferrer"&gt;CODEOWNERS reference&lt;/a&gt; documents that a line with invalid syntax is skipped, that a file over 3 MB is not loaded at all, that &lt;code&gt;docs/*&lt;/code&gt; does not match nested paths like &lt;code&gt;docs/build-app/troubleshooting.md&lt;/code&gt;, and that gitignore-style &lt;code&gt;!&lt;/code&gt; negation and &lt;code&gt;[ ]&lt;/code&gt; character ranges do not work. If your priority model depends on an ownership map, check the map first.&lt;/p&gt;

&lt;h2&gt;
  
  
  What it takes for the ranker to call something urgent
&lt;/h2&gt;

&lt;p&gt;Automatic P0 requires external evidence. A pull request reaches P0 on its own only when it carries a validated linked issue at High or Urgent priority in Jira or Linear. Without that, the base score is capped at P1 no matter how severe the internal signals look. An administrator rule can assign P0 without a linked issue, and a person can set P0 by hand.&lt;/p&gt;

&lt;p&gt;The base score comes from three signals: the validated severity of issues the reviewer found, the priority of a linked external issue, and how many other open pull requests are blocked behind this one. That third signal is the interesting one. Downstream dependency is something a ranker can compute and a human rarely does, and it is exactly the quantity that grows when agents open changes faster than anyone merges them.&lt;/p&gt;

&lt;p&gt;Triage does not show a numeric score. Levels are the interface, and the number behind them is deliberately undocumented because it changes as the ranking model improves. Two pull requests in the same provider state routinely land on different levels, which is the intent. The trade is that you cannot audit a rank the way you can audit a rule.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the queue stops and the merge starts
&lt;/h2&gt;

&lt;p&gt;The ranker also carries actions, and the merge action has a documented limit. Triage merges only the commit you were shown, and if someone pushed since, the merge is refused. On GitHub there is no merge method to choose, because Triage uses the first method the repository allows in the order merge commit, squash, rebase. When the branch requires a merge queue, the control becomes Add to merge queue and GitHub controls the ordering, checks, and method, and a queued pull request is not yet merged.&lt;/p&gt;

&lt;p&gt;Manual actions run as you, using your own Git provider authorization, so an action you could not perform in the provider is refused in the queue too. Automated actions use the organization's integration and need administrator authorization. Opening the queue at all requires an active Review seat, and the feature is Team plan and above, generally available on GitHub Cloud with GitLab in beta and Bitbucket unsupported, and not available on self-hosted CodeRabbit deployments.&lt;/p&gt;

&lt;p&gt;If what you actually care about is whether a bot approval clears branch protection, that is set in the repository, and &lt;a href="https://agentwrotethis.dev/blog/which-ai-reviewer-approvals-satisfy-your-merge-requirement/" rel="noopener noreferrer"&gt;the approval toggles and path globs&lt;/a&gt; are a separate decision from anything the queue does.&lt;/p&gt;

&lt;h2&gt;
  
  
  The other layer: what happened to the suggestions
&lt;/h2&gt;

&lt;p&gt;Ranking decides what to read. It says nothing about whether anyone acted on it. Kodus measures that separately in its Cockpit, on a tab called &lt;a href="https://docs.kodus.io/en/how_to_use/cockpit/kodus_review.md" rel="noopener noreferrer"&gt;Kodus Review&lt;/a&gt;, which asks whether the team is acting on what the reviewer said. The headline metric is implementation rate, implemented suggestions divided by sent suggestions, and only delivered suggestions count, meaning drafts the tool filtered out before commenting are never in the denominator. Suggestions are attributed to the week the pull request closed, because implementation status is only final once it merges.&lt;/p&gt;

&lt;p&gt;Two details there are easy to reuse in any review measurement. Negative vote rate shows raw counts instead of a percentage below ten reactions, and charts built on very few suggestions are faded and marked, because a 0% or 100% from a handful of suggestions is not a signal. The severity chart also carries an All / Kodus only toggle, because a custom rule carries the severity you set on the rule rather than a risk assessment by the tool, and mixing the two distorts the read.&lt;/p&gt;

&lt;p&gt;The metric I have not seen elsewhere is critical suggestions left unimplemented on pull requests that already merged. That is a risk list rather than a quality score, and it is the closest thing to a measure of what the review process let through. It also pairs with the coverage question, since &lt;a href="https://agentwrotethis.dev/blog/how-much-of-code-review-an-ai-reviewer-actually-carries/" rel="noopener noreferrer"&gt;how much of a change a reviewer actually reads&lt;/a&gt; determines what a suggestion count can mean in the first place.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reading the numbers the platform hands you
&lt;/h2&gt;

&lt;p&gt;If you pull review and adoption numbers from GitHub's own &lt;a href="https://docs.github.com/en/copilot/concepts/billing-and-usage/copilot-usage-metrics/copilot-metrics" rel="noopener noreferrer"&gt;Copilot usage metrics&lt;/a&gt;, the caveats are documented and specific. Most metrics come from client-side IDE telemetry, and end users need telemetry enabled in their IDE for the richest data. Server-side telemetry catches active users that client telemetry misses, and those users count toward active totals, but their per-feature and lines-of-code breakdowns stay empty. The data excludes Copilot Chat on GitHub.com and GitHub Mobile, and license and seat information lives in a separate API.&lt;/p&gt;

&lt;p&gt;Attribution follows organization membership rather than where the action happened, so one person's usage can appear in several organization dashboards while counting once at the enterprise level. GitHub states that organization-level analytics are not designed to be compared directly with enterprise totals. The Copilot impact dashboard groups users into adoption cohorts and connects adoption to pull request output, which is the nearest the platform gets to tying a review tool to delivery.&lt;/p&gt;

&lt;p&gt;None of that makes the numbers wrong. It makes them numbers with a stated scope, and a review metric quoted without its scope is how a planning meeting turns into an argument.&lt;/p&gt;

&lt;h2&gt;
  
  
  Three measurement layers, side by side
&lt;/h2&gt;

&lt;p&gt;Each of these answers a different question, and none of them substitutes for the others.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Layer&lt;/th&gt;
&lt;th&gt;Question it answers&lt;/th&gt;
&lt;th&gt;What it can read&lt;/th&gt;
&lt;th&gt;What it declares out of scope&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit Triage&lt;/td&gt;
&lt;td&gt;Which pull request is worth acting on now&lt;/td&gt;
&lt;td&gt;Repository, branch, draft state, change type, severity, risk, blast radius, review effort, checks, conflicts, workflow state, involved people, title words, downstream dependents&lt;/td&gt;
&lt;td&gt;Labels, file paths, CODEOWNERS, team membership, assignees, the code itself; the numeric score is undocumented&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kodus Cockpit (Kodus Review tab)&lt;/td&gt;
&lt;td&gt;Whether the team acts on what the reviewer said&lt;/td&gt;
&lt;td&gt;Delivered suggestions, their implementation status at PR close, reactions, per-rule trigger counts, review-run outcomes&lt;/td&gt;
&lt;td&gt;Filtered-out drafts never count; rates are suppressed below ten reactions and thin samples are marked&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot usage metrics&lt;/td&gt;
&lt;td&gt;How Copilot is adopted and how that tracks pull request output&lt;/td&gt;
&lt;td&gt;IDE, CLI and agent app telemetry, server-side active-user signals, repository-level PR activity, adoption cohorts&lt;/td&gt;
&lt;td&gt;Copilot Chat on GitHub.com and GitHub Mobile, license and seat data, org-level figures compared to enterprise totals&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The scoping differences are the point of the table. A Triage rule can see blast radius but not a file path. A Kodus implementation rate sees what happened to a suggestion but not which path it touched. GitHub's metrics see adoption and pull request activity but not the reviews themselves. If you want one number that covers all three, you are going to build it from two exports and a join, and you will spend the first week reconciling definitions.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to check before you trust a queue
&lt;/h2&gt;

&lt;p&gt;The cheapest test I know takes an afternoon and no integration work. Take the ten pull requests your team would rank as most important today, in order, by hand. Then write the rule you would need to reproduce that ranking, in whatever language the tool accepts. If the rule reaches for file paths, labels, CODEOWNERS, or team membership, the ranker cannot express it, and the queue you get will be ordered by something else.&lt;/p&gt;

&lt;p&gt;Do the same for the number you plan to report upward. Ask what the denominator is, which population it counts, and which cases the documentation says are excluded. A ranker that tells you what it cannot see is easier to trust than one that does not mention the question, and the ones that document their blind spots have just handed you the audit you were going to need anyway.&lt;/p&gt;

&lt;p&gt;The context question sits underneath all of this. A queue that ranks across repositories still hands the reader one change at a time, which is why &lt;a href="https://agentwrotethis.dev/blog/multi-repo-ai-review-a-context-problem-not-a-volume-problem/" rel="noopener noreferrer"&gt;cross-repository context&lt;/a&gt; is a separate problem from ranking order. Ranking decides when you look. It does not decide whether what you are looking at makes sense on its own.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>pullrequests</category>
      <category>reviewmetrics</category>
    </item>
    <item>
      <title>Which of your rule files the reviewer actually reads</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Fri, 16 Oct 2026 00:15:06 +0000</pubDate>
      <link>https://dev.to/tessainsley/which-of-your-rule-files-the-reviewer-actually-reads-4963</link>
      <guid>https://dev.to/tessainsley/which-of-your-rule-files-the-reviewer-actually-reads-4963</guid>
      <description>&lt;p&gt;Every AI review tool claims it reads your AGENTS.md or CLAUDE.md. What decides whether your standards actually land is which rule wins when two apply to the same file, and whether the tool can show you which one it used for a specific pull request.&lt;/p&gt;

&lt;p&gt;A reviewer that follows your team's standards is making a claim about precedence and about what the tool will show you. It says very little about how well the model writes code. Almost every AI review tool now picks up AGENTS.md, CLAUDE.md, .cursorrules or a Copilot instructions file, so the yes/no version of the question resolves to yes for all of them. The version that decides whether your standards land comes down to which files it reads, which rule wins when two apply to the same file, and whether you can prove for one specific pull request that the rule you care about was in scope.&lt;/p&gt;

&lt;h2&gt;
  
  
  Detection is the easy part
&lt;/h2&gt;

&lt;p&gt;CodeRabbit's &lt;a href="https://docs.coderabbit.ai/knowledge-base/code-guidelines.md" rel="noopener noreferrer"&gt;code guidelines page&lt;/a&gt; lists the patterns it detects by default: &lt;code&gt;AGENTS.md&lt;/code&gt;, &lt;code&gt;.cursorrules&lt;/code&gt;, &lt;code&gt;.github/copilot-instructions.md&lt;/code&gt;, &lt;code&gt;.github/instructions/*.instructions.md&lt;/code&gt;, &lt;code&gt;CLAUDE.md&lt;/code&gt;, &lt;code&gt;GEMINI.md&lt;/code&gt;, &lt;code&gt;.cursor/rules/*&lt;/code&gt;, &lt;code&gt;.windsurfrules&lt;/code&gt;, &lt;code&gt;.clinerules/*&lt;/code&gt;, &lt;code&gt;.rules/*&lt;/code&gt;, and &lt;code&gt;AGENT.md&lt;/code&gt;. Kodus's &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/configs/rules_file_detection" rel="noopener noreferrer"&gt;rules file detection page&lt;/a&gt; covers a similar set and adds &lt;code&gt;.aider.conf.yml&lt;/code&gt;, &lt;code&gt;.opencode.json&lt;/code&gt;, and &lt;code&gt;docs/coding-standards/**/*&lt;/code&gt;. GitHub Copilot supports three kinds of custom instructions, documented on the &lt;a href="https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions" rel="noopener noreferrer"&gt;repository custom instructions page&lt;/a&gt;: a repository-wide &lt;code&gt;copilot-instructions.md&lt;/code&gt; in &lt;code&gt;.github&lt;/code&gt;, path-specific &lt;code&gt;NAME.instructions.md&lt;/code&gt; files under &lt;code&gt;.github/instructions&lt;/code&gt;, and &lt;code&gt;AGENTS.md&lt;/code&gt; files stored anywhere in the repository.&lt;/p&gt;

&lt;p&gt;Three vendors, three lists that overlap almost completely. If detection were the whole problem, any of them would do, and the comparison would be about model quality. It is not, because none of those lists tell you which file wins when your repo has a root &lt;code&gt;CLAUDE.md&lt;/code&gt;, a &lt;code&gt;services/billing/CLAUDE.md&lt;/code&gt;, and a shared standards repository that also gets imported. That is where teams lose enforcement without noticing.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which rule wins when two apply
&lt;/h2&gt;

&lt;p&gt;Kodus resolves rules through an inheritance hierarchy: global, then repository, then directory. The effective set at any level is the rules defined there, plus the rules inherited from the parent level, minus anything explicitly excluded at that level. There are two ways to stop a rule flowing down. You can mark it non-inheritable when you create it, in which case it applies only where it was created. Or you can exclude a parent rule at a child level, and this is the part worth reading twice: the exclusion does not cascade. Exclude a global rule at the repository level and a configured directory inside that same repository still inherits it, unless you exclude it there too. &lt;a href="https://docs.kodus.io/en/how_to_use/code_review/configs/global_rule_sources" rel="noopener noreferrer"&gt;Global rule sources&lt;/a&gt; let you point Kodus at a standards repository and import its rule files as global rules that apply to every connected repo, and the source repo itself is treated as configuration rather than as a codebase, so Kodus skips review on pull requests opened in it.&lt;/p&gt;

&lt;p&gt;CodeRabbit resolves configuration differently, and the default matters. &lt;a href="https://docs.coderabbit.ai/configuration/configuration-inheritance.md" rel="noopener noreferrer"&gt;Configuration inheritance&lt;/a&gt; is disabled by default. You have to set &lt;code&gt;inheritance: true&lt;/code&gt;, after which CodeRabbit merges up the chain and stops at the first level where &lt;code&gt;inheritance&lt;/code&gt; is false or unset. Merge behavior depends on the data type. Objects deep merge, scalars take the child value, and arrays append unique parent items after the child's, deduplicated by &lt;code&gt;path&lt;/code&gt;, &lt;code&gt;label&lt;/code&gt;, &lt;code&gt;name&lt;/code&gt;, &lt;code&gt;id&lt;/code&gt; or &lt;code&gt;key&lt;/code&gt;. The vendor's own worked example shows the consequence: a central &lt;code&gt;path_instructions&lt;/code&gt; entry for &lt;code&gt;src/**&lt;/code&gt; is dropped because the repository already defines an entry with the same path. No error, no warning. The central instruction is simply not in the merged config.&lt;/p&gt;

&lt;p&gt;Copilot's rule is positional. The nearest &lt;code&gt;AGENTS.md&lt;/code&gt; in the directory tree takes precedence, and when a path-specific instruction file matches the file being reviewed, both it and the repository-wide file are used. The docs also note a prerequisite that is easy to miss: for Copilot code review, your personal setting for using custom instructions has to be enabled, which it is by default. Turn it off and the review silently runs without your rules.&lt;/p&gt;

&lt;h2&gt;
  
  
  The failures that look like success
&lt;/h2&gt;

&lt;p&gt;The dropped array entry above is the cleanest example of a rule that exists, is detected, and never applies. There are several more of the same shape.&lt;/p&gt;

&lt;p&gt;A path glob that does not match. Kodus's own troubleshooting line is blunt: a rule only runs on files matching its path, so a rule can show as active in the UI and never appear in the evaluation trace for the files you expected. Nothing about the UI tells you the difference.&lt;/p&gt;

&lt;p&gt;Case sensitivity. CodeRabbit's guideline patterns are case-sensitive, so a file named &lt;code&gt;claude.md&lt;/code&gt; is not matched by &lt;code&gt;**/CLAUDE.md&lt;/code&gt;. A team that renames a file, or that has one contributor on a case-insensitive filesystem, ends up with guidelines that quietly stop applying.&lt;/p&gt;

&lt;p&gt;Guidelines reviewed instead of used. Adding &lt;code&gt;CLAUDE.md&lt;/code&gt; to &lt;code&gt;path_instructions&lt;/code&gt; tells CodeRabbit to review that file as changed code, not to apply it as a guideline. The docs call this a common mistake, and the symptom is a reviewer that comments on your standards document instead of enforcing it.&lt;/p&gt;

&lt;p&gt;LLM conversion of a free-form file. Kodus imports &lt;code&gt;.kody/rules/**&lt;/code&gt; and &lt;code&gt;rules/**/*.md&lt;/code&gt; verbatim, preserving your wording, identifiers and Bad/Good examples. Files that do not follow that template fall back to the LLM importer, which merges several guidelines from one file into a single rule. Want two independently manageable rules? They need to be two files. There is a related trap: if you hand-edit a rule that was created from an IDE rule file, the next sync of that file overwrites your edit.&lt;/p&gt;

&lt;p&gt;Markers that are live controls. Adding &lt;code&gt;@kody-ignore&lt;/code&gt; to a rule file makes Kodus skip it on the next sync and remove any rules previously created from it, and removing the marker brings them back. That is the intended behavior, and it means a comment in a markdown file is a control plane for what gets enforced.&lt;/p&gt;

&lt;p&gt;Cross-repo guidelines that are not pinned. CodeRabbit can read guideline files from another repository in the same organization, and it reads them from that repository's default branch at review time. Freshness is the benefit. The cost is reproducibility: a comment from last month may not reproduce today because the guideline text behind it has moved.&lt;/p&gt;

&lt;p&gt;Rule files that drift. Cloudflare's &lt;a href="https://blog.cloudflare.com/ai-code-review/" rel="noopener noreferrer"&gt;CI-native reviewer&lt;/a&gt; includes a plugin that verifies the repository's &lt;code&gt;AGENTS.md&lt;/code&gt; is up to date, which is a reasonable response to stale rule files. They also built the whole system themselves, because off-the-shelf tools did not offer enough flexibility for an organization their size. Stack Overflow's piece on &lt;a href="https://stackoverflow.blog/2026/03/26/coding-guidelines-for-ai-agents-and-people-too/" rel="noopener noreferrer"&gt;building shared coding guidelines for AI&lt;/a&gt; makes the adjacent point that guidelines for agents need to be more explicit and demonstrative than guidelines for people, because an agent does not absorb the tacit conventions a new hire picks up by reading the codebase.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to prove a rule actually fired
&lt;/h2&gt;

&lt;p&gt;This is the part most vendor pages do not answer, and it is the part that turns the claim into something checkable.&lt;/p&gt;

&lt;p&gt;Kodus on a self-hosted deployment writes grep-able markers into the API logs. &lt;code&gt;[kody-rules-sync]&lt;/code&gt; summarizes each sync run, including which files were imported, which were skipped with a reason, and which were removed. &lt;code&gt;[kody-rules-eval]&lt;/code&gt; is a per-file evaluation trace that names the rule uuid and title selected into the prompt for each reviewed file. Two docker logs greps give you an answer for a specific pull request rather than for the feature in general.&lt;/p&gt;

&lt;p&gt;CodeRabbit exposes the resolved configuration rather than the prompt. Running &lt;code&gt;@coderabbitai configuration&lt;/code&gt; on a pull request prints the fully resolved YAML annotated with source comments, so each setting shows which level in the merge chain supplied it. That is a direct way to catch the dropped &lt;code&gt;src/**&lt;/code&gt; entry.&lt;/p&gt;

&lt;p&gt;For GitHub Copilot, the documentation describes how the three kinds of instructions are assembled, and I did not find a documented way to inspect the assembled instructions for a particular review. That capability is unknown from the sources I read, which is different from saying it does not exist.&lt;/p&gt;

&lt;p&gt;The check that works on every tool is a canary rule. Write one rule scoped to a single glob that forbids one obvious thing, open a pull request that violates it inside a file matching that glob, and confirm the finding appears. Then move the violation to a file outside the glob and confirm it does not. That is ten minutes of work and it exercises detection, scoping, precedence and firing in one pass. Repeat it for the language you care most about, because rule evaluation is not uniform across file types, and repeat it after any change to the rule file layout.&lt;/p&gt;

&lt;h2&gt;
  
  
  The criteria that decide this
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Rule files detected&lt;/th&gt;
&lt;th&gt;How scope is decided&lt;/th&gt;
&lt;th&gt;How precedence resolves&lt;/th&gt;
&lt;th&gt;Can you see which rule fired&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Kodus&lt;/td&gt;
&lt;td&gt;IDE rule files plus &lt;code&gt;.kody/rules/**&lt;/code&gt;, &lt;code&gt;rules/**/*.md&lt;/code&gt;, &lt;code&gt;docs/coding-standards/**&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Nested files scoped to their directory; per-rule path globs; directory-level settings&lt;/td&gt;
&lt;td&gt;Global to repository to directory inheritance; non-inheritable rules and child exclusions that do not cascade&lt;/td&gt;
&lt;td&gt;Yes on self-hosted, via &lt;code&gt;[kody-rules-sync]&lt;/code&gt; and &lt;code&gt;[kody-rules-eval]&lt;/code&gt; log markers&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CodeRabbit&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;AGENTS.md&lt;/code&gt;, &lt;code&gt;.cursorrules&lt;/code&gt;, Copilot instruction files, &lt;code&gt;CLAUDE.md&lt;/code&gt;, &lt;code&gt;GEMINI.md&lt;/code&gt;, &lt;code&gt;.cursor/rules/*&lt;/code&gt;, &lt;code&gt;.windsurfrules&lt;/code&gt;, &lt;code&gt;.clinerules/*&lt;/code&gt;, &lt;code&gt;.rules/*&lt;/code&gt; (case-sensitive)&lt;/td&gt;
&lt;td&gt;Directory-scoped by default, with explicit &lt;code&gt;applyTo&lt;/code&gt; mapping and cross-repo &lt;code&gt;repo:path&lt;/code&gt; sources&lt;/td&gt;
&lt;td&gt;Inheritance off by default; when on, chain stops at first false or unset level, and arrays dedupe by path so a parent entry can be dropped&lt;/td&gt;
&lt;td&gt;Yes, &lt;code&gt;@coderabbitai configuration&lt;/code&gt; prints the resolved config with source annotations&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GitHub Copilot&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;copilot-instructions.md&lt;/code&gt;, &lt;code&gt;NAME.instructions.md&lt;/code&gt;, &lt;code&gt;AGENTS.md&lt;/code&gt;, &lt;code&gt;CLAUDE.md&lt;/code&gt;, &lt;code&gt;GEMINI.md&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Nearest &lt;code&gt;AGENTS.md&lt;/code&gt; in the directory tree wins; path-specific files apply on path match&lt;/td&gt;
&lt;td&gt;Positional for &lt;code&gt;AGENTS.md&lt;/code&gt;; repository-wide and path-specific both apply when the path matches&lt;/td&gt;
&lt;td&gt;Unknown from the documentation I read&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A fourth option is what Cloudflare did: build a coordinator around an open-source agent and treat your internal standards as one more plugin with its own compliance check. That gives you full control over precedence and over what the trace looks like, and it costs an internal tool to own. Their post reports running it across tens of thousands of merge requests, which is the kind of volume that justifies the build.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to do before you trust the claim
&lt;/h2&gt;

&lt;p&gt;Look at how many rule files your repository actually contains, including the nested ones. Pick the rule you would most hate to see silently skipped and find its path glob, then check that glob against the files it is supposed to cover. If two files define guidance for the same path, determine which one wins on your tool and delete or scope the loser. Find the command or log marker that shows the resolved rule set, and run it on a real pull request rather than trusting the settings page. Then add the canary rule and keep it, because the thing that breaks rule enforcement later is a file layout change nobody connected to the reviewer.&lt;/p&gt;

&lt;p&gt;A rule file is an artifact, and it deserves the same treatment as the code it governs: version it, scope it, and check that it fires. Teams that get real value out of "the reviewer follows our standards" can point at the file, the glob, and the log line. Teams that cannot are running a policy that exists in a repository and not in their review. If your rules live in a central standards repo, the &lt;a href="https://agentwrotethis.dev/blog/multi-repo-ai-review-a-context-problem-not-a-volume-problem/" rel="noopener noreferrer"&gt;multi-repo context question&lt;/a&gt; is the next one to settle, and if you are still deciding where the reviewer runs at all, the operational cost of &lt;a href="https://agentwrotethis.dev/blog/what-self-hosting-ai-code-review-actually-costs/" rel="noopener noreferrer"&gt;self-hosting it&lt;/a&gt; changes which of these verification paths you get. A policy that leans on &lt;a href="https://agentwrotethis.dev/blog/review-policy-cant-rely-on-flagging-ai-code/" rel="noopener noreferrer"&gt;flagging AI code&lt;/a&gt; rather than on scoped rules has the same blind spot, one layer up.&lt;/p&gt;

&lt;p&gt;Claims checked 2026-10-04.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>aiagents</category>
      <category>devtools</category>
    </item>
    <item>
      <title>The artifact worth reviewing when agents write the code</title>
      <dc:creator>Tess Ainsley</dc:creator>
      <pubDate>Wed, 14 Oct 2026 00:15:05 +0000</pubDate>
      <link>https://dev.to/tessainsley/the-artifact-worth-reviewing-when-agents-write-the-code-2bbn</link>
      <guid>https://dev.to/tessainsley/the-artifact-worth-reviewing-when-agents-write-the-code-2bbn</guid>
      <description>&lt;p&gt;GitHub's Security Lab reported 24 Android vulnerabilities found by an AI security agent, and the part worth copying is what ended up version-controlled. Not the exploit code. The &lt;a href="https://github.blog/security/how-we-found-24-android-vulnerabilities-using-our-open-source-ai-security-agent/" rel="noopener noreferrer"&gt;set of YAML taskflows&lt;/a&gt; that guided the model through the audit, checked into a public repository, runnable by anyone with a Copilot license. The agent did the finding. The taskflows are the thing a team can read, diff, and argue about.&lt;/p&gt;

&lt;p&gt;That is a small shift with a large consequence for review. When a person writes a patch, the diff is a decent summary of the judgment that went into it, because the person held the reasoning and the code is the residue. When an agent writes the patch, the reasoning lives somewhere else entirely: a prompt, a rule file, a model version, a sequence of tool calls. Reviewing only the residue means reading the output of a process you never see.&lt;/p&gt;

&lt;h2&gt;
  
  
  The diff stops being the whole artifact
&lt;/h2&gt;

&lt;p&gt;Ian Bicking's post on &lt;a href="https://blog.glyph.im/2026/09/serious-ai-product.html" rel="noopener noreferrer"&gt;what a serious AI product would look like&lt;/a&gt; puts the failure precisely. Checking for mistakes, he writes, is pushed off into code review, which encourages the author to hand the work to a reviewer without ever looking. He wants a two-column worksheet where every claim has a checkbox you only tick after you have verified it, and he notes that the vendors' own warning labels ("AI can make mistakes, double-check responses") are fine print designed to move responsibility onto the user.&lt;/p&gt;

&lt;p&gt;His complaint is about products. The same structure shows up in review. If the process that produced a change is invisible, then the reviewer becomes the only place where checking happens, and the volume of changes is exactly what makes that unworkable. The fix is not to ask reviewers to work harder. It is to make the process itself a reviewable object, so that some of the checking happens where it can be repeated instead of where it cannot.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a reviewable workflow actually looks like
&lt;/h2&gt;

&lt;p&gt;The GitHub Security Lab agent is a concrete example. The taskflows are YAML files with names like &lt;code&gt;gather_mobile_entry_point_info.yaml&lt;/code&gt; and &lt;code&gt;classify_application_local.yaml&lt;/code&gt;. One splits entry points into mobile and non-mobile so the agent understands the right attack surface. Another enumerates vulnerability classes and asks the model to consider them against each entry point, so an intent-based entry point gets checked against known intent-based bug classes rather than whatever the model feels like noticing.&lt;/p&gt;

&lt;p&gt;The team also ran both a strict prompt and a broad prompt across multiple runs, because the model is non-deterministic. Output lands in a SQLite table with a &lt;code&gt;has_vulnerability&lt;/code&gt; column you filter with a checkmark. There is a real cost attached, and the post is upfront about it: a GitHub Copilot license, premium model requests, many tool calls, and one to two hours on a medium-sized repository.&lt;/p&gt;

&lt;p&gt;Every one of those attributes is reviewable before you run anything. You can read the vulnerability class list and ask whether it covers your stack. You can see the run is repeated. You can see where the findings land and what they claim. Compare that with a code review comment that says "this looks suspicious" and moves on.&lt;/p&gt;

&lt;p&gt;Cloudflare's &lt;a href="https://blog.cloudflare.com/ai-code-review/" rel="noopener noreferrer"&gt;CI-native reviewer&lt;/a&gt; takes a different shape to the same end. They built it on OpenCode and put several reviewers behind a deduplication coordinator, so a finding that two reviewers agree on surfaces once. There is also a check on whether the repo's AGENTS.md file is current. The coordinator is the reviewable part. Without it, the same issue appears four times and the reviewer learns to skim.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rules are part of the workflow
&lt;/h2&gt;

&lt;p&gt;The rules a reviewer applies live in the same category. Stack Overflow's post on &lt;a href="https://stackoverflow.blog/2026/03/26/coding-guidelines-for-ai-agents-and-people-too/" rel="noopener noreferrer"&gt;building shared coding guidelines for AI&lt;/a&gt; is written mostly from the generation side, how to get agents to write to your standards, and it contains the line that matters for review: code review will be most engineers' first look at the code, since they did not write it. Vish Abrams, chief architect at Heroku, makes the point that seasoned engineers assume things like DRY as common knowledge, and that assumption does not transfer to an agent.&lt;/p&gt;

&lt;p&gt;A rule that only exists in a config file the reviewer never reads is decoration. What matters is whether the reviewer ingests the files your team already keeps, AGENTS.md, CLAUDE.md, &lt;code&gt;.cursorrules&lt;/code&gt;, Copilot instruction files, and scopes them so a rule for the payments service does not fire on the CLI tool. CodeRabbit reads repo config, Copilot reads instruction files, and &lt;a href="https://kodus.io" rel="noopener noreferrer"&gt;Kodus&lt;/a&gt; ingests repo rule files as scoped rules rather than as loose context. Those are three shapes of the same idea, and the useful test is whether you can point at the file and the line that produced a comment.&lt;/p&gt;

&lt;h2&gt;
  
  
  A test you can run before you trust the workflow
&lt;/h2&gt;

&lt;p&gt;Take any agent-produced change your team merged last week and try to answer these without opening the diff.&lt;/p&gt;

&lt;p&gt;Where is the prompt or taskflow, and is it in the repository or in someone's chat history? Which model version ran, and would a rerun use the same one? Which rules were in scope for this file, and where do those rules live? What did the workflow check that a test suite would not catch? If the workflow found nothing, is that because there was nothing, or because the run was cut short?&lt;/p&gt;

&lt;p&gt;If the answers are all "somewhere in a chat window," the review process is carrying work it cannot carry at volume. If the answers are files, you have something a second engineer can review before anyone merges anything, which is the point.&lt;/p&gt;

&lt;h2&gt;
  
  
  What this does to review time
&lt;/h2&gt;

&lt;p&gt;None of this makes review faster in the sense of reading fewer lines. It moves a specific category of checking out of the reviewer's head and into an artifact that can be read once and rerun every time. That is the difference between reviewing a change and reviewing a process, and only the second one scales with the number of changes an agent can produce.&lt;/p&gt;

&lt;p&gt;There is a cost, and it is worth naming. Versioning prompts and taskflows adds config files to maintain, and they drift, which is why Cloudflare checks the AGENTS.md currency at review time instead of trusting it. A workflow nobody updates is worse than no workflow, because reviewers will assume it still reflects how the team works.&lt;/p&gt;

&lt;p&gt;The practical thing to do this week is boring. Pick the agent workflow your team uses most, find its prompt or config, and put it in the repository next to the code it governs. Then review it the way you review anything else, with the diff open beside it. Teams that already wrote a &lt;a href="https://agentwrotethis.dev/blog/review-policy-cant-rely-on-flagging-ai-code/" rel="noopener noreferrer"&gt;review policy around flagging AI code&lt;/a&gt; have this half done, because a policy is a workflow with a name. Teams that have not should notice that their reviewer is currently doing a job the workflow file should be doing, and that the &lt;a href="https://agentwrotethis.dev/blog/when-review-time-plateaued-reviewers-had-stopped-reading/" rel="noopener noreferrer"&gt;plateau in review time on the largest pull requests&lt;/a&gt; is what that looks like when it stops working.&lt;/p&gt;

&lt;p&gt;This piece first ran on &lt;a href="https://agentwrotethis.dev/blog/the-artifact-worth-reviewing-when-agents-write-the-code/" rel="noopener noreferrer"&gt;agentwrotethis.dev&lt;/a&gt;, where I keep the source links for every claim.&lt;/p&gt;

</description>
      <category>aicodereview</category>
      <category>codereview</category>
      <category>aiagents</category>
      <category>devtools</category>
    </item>
  </channel>
</rss>
