Best AI Code Review Tools That Discover Coding Rules From Pull Request History (2026)

I write about how engineering teams build and keep review standards, most recently on what a base-branch REVIEW.md teaches about agent standards. Your team's real code review rules live in pull request (PR) comments, while CLAUDE.md and AGENTS.md hold only what someone remembered to write down. I ranked eight AI code review tools by how each one turns review history into rules: which signal the tool counts, whether each rule shows its source, and how unused rules retire.

TL;DR

• Your real rulebook lives in review threads. The rules your senior reviewers actually apply sit in PR comments, and few of them reach your rule files.
• Mining review history works when people keep the final say. Stationwise turned two and a half years of PR comments into a skill file of around 11,000 tokens, with the team choosing which repeats to keep (Stationwise engineering, February 2026).
• Choose by signal, source and retirement. Signal is which review comments a tool counts, source is whether each rule traces back to its PRs, and retirement is what happens to a rule your team keeps dismissing.
• Qodo is my #1 because its rules earn their place on signal, source and retirement. Rules come only from accepted comments that changed code, weighted by code ownership, every rule opens the PRs behind it, and rules your team rarely fixes retire on their own.

The 8 Best AI Code Review Tools That Discover Coding Rules From Pull Request History

1. Qodo: rules discovered from accepted review comments
2. CodeRabbit: configuration files and chat preferences
3. Greptile: dashboard rules, team comments and reactions
4. Cursor Bugbot: Team Rules, BUGBOT.md and remember comments
5. cubic: replies, reactions and chosen reviewers
6. Kodus: three months of closed PRs
7. Bito: negative feedback and guideline files
8. GitHub Copilot code review: instruction files and skills

Tool	Where its rules come from	Best for	Price as of October 2026
Qodo	Accepted review comments that led to code changes, plus imported rule files and rules you write	Platform and staff engineers who want rules mined from real fixes, traceable to source PRs and retired by fix rate	14-day free trial; Pro Team from $30 a month for 2,500 credits; Enterprise custom, with self-learning listed under Enterprise
CodeRabbit	.coderabbit.yaml, path instructions, code guidelines files, preferences stated in chat	Reviewers who state preferences to the bot in chat	Essentials $24 per user a month, billed annually; Team $48
Greptile	Dashboard or .greptile rules, team PR comments, replies, reactions, whether comments were addressed in later commits	Teams who want everyday comments and reactions to shape review	$1 per credit
Cursor Bugbot	Team Rules, BUGBOT.md, repository rules, rules generated from GitHub activity, @cursor remember	Engineering groups who add rules with a remember comment in the PR	Billed through a Cursor plan
cubic	Replies, thread context, reactions, past comments from reviewers picked at onboarding	Leads who pick which reviewers' history shapes the rules	Team $40 per developer a month
Kodus	Kody's past reviews and recurring feedback in the last 3 months of closed PRs	Teams who want weekly rule suggestions from recent PRs	Free Community plan; Teams $10 per developer a month plus model tokens
Bito	Negative feedback on Bito's own comments, dashboard or .bito.yaml guidelines, repo guideline files	Teams who correct the bot by reacting to its comments	Guidelines on the Professional plan
GitHub Copilot code review	Instruction files, AGENTS.md, organization instructions, .github/skills	Teams that already keep instruction files in their GitHub repos	Paid Copilot plans; reviews use AI credits

Most Teams Have Two Rulebooks: Rule Files and Review Threads

One rulebook lives in CLAUDE.md, AGENTS.md or REVIEW.md. The other lives in the comments senior reviewers leave on PR after PR, and nobody writes it down.

The real rulebook keeps changing in review threads, and new hires and coding agents repeat mistakes the team fixed a year ago.

Mining the Second Rulebook Works When People Keep the Final Say

A tool can find the repeats in review history, and the rules that work are short, come from real fixes and stay under human judgment.

What Two and a Half Years of PR Comments Contained

The repeats are findable. One of Stationwise's patterns was to use parseISO from date-fns instead of new Date() for date strings, flagged in 25+ distinct PRs (Stationwise engineering, February 2026).

Stationwise's final file stayed lean, so the diff still has room in context. The machine found the repeats, and people decided which ones were worth keeping.

Rules Mined From History Change What Agents Do

Repository norms measurably improve agent output. Agents that drew on a repo's explicit and implicit norms, consulting its Git history when needed, showed a 31.64% to 45.44% relative improvement in norm compliance over a no-guidance baseline, across 121 tasks and three coding models (RepoNorm, October 2026).

The list that works is short and comes from real fixes. When every accepted review comment became a persistent rule for a coding agent on a 35+ service platform, the list grew to just 18 rules, and the error classes those rules covered didn't come back across 11 recorded sessions, which is early evidence (arXiv, July 2026).

One Review Comment, Repeated: Use parseISO

A reviewer has asked for the same date fix in many PRs (illustrative).

// Flagged in review, again
const due = new Date(invoice.dueDate); // "2026-11-08" parses as midnight UTC (Coordinated Universal Time)

// What the reviewer asks for
import { parseISO } from "date-fns";
const due = parseISO(invoice.dueDate);

What Makes a Mined Code Review Rule Worth Trusting

Trust in a mined rule comes down to three questions.

1. Signal decides which comments count.
   1. The tool counts comments that changed code. Praise, questions and nitpicks aren't standards, and the parseISO request counts because authors applied the fix.
   2. The tool weights the reviewer who owns the code.
   3. The tool scopes rules to the paths where the feedback happened, so the parseISO rule belongs in web/ and stays out of the Go services.
2. Source shows where a rule came from.
   1. Every rule links back to the PRs it came from, so a developer can judge the rule before dismissing a finding.
   2. The tool keeps your existing rule files as a starting point, with mined rules beside them.
3. Retirement decides what happens when the team stops following a rule.
   1. You choose whether rules wait for approval or apply at once.
   2. Rules nobody fixes fade out, and rules you need can be locked.

The funnel narrows all review comments to comments accepted with a code change, then to owner-weighted, recurring feedback, and finally to one rule scoped to web/**.

The rule card shows three states: active with a Source link to three PRs, deactivated after the team rarely fixed its findings, and locked so the rule stays active.

Mined rules do the most good when the review that applies them sits outside the agent writing the code, because you shouldn't review code with the same tool that wrote it.

How I Evaluated the Tools

I checked signal, source and retirement for every tool that builds custom review rules, using each vendor's own docs as of October 2026.

The 8 Tools Ranked on the parseISO Comment

1. Qodo Turns Accepted Review Comments Into Rules You Can Trace

Tool Overview

Qodo gives you rules your team already proved in review, because Qodo's Rule Miner learns only from comments that changed code. Qodo builds Qodo Rules from your rule files, rules you write and your PR history, checks each PR against those rules with Rule enforcement.

Main Features

1. Signal. Four signals decide what becomes a rule: reviewer code ownership, recurring comments, pattern clustering by path, and rejected suggestions, which lower an active rule's signal over time. One comment qualifies when it comes from a reviewer with strong ownership of that code.
2. Source. Each mined rule carries a Source field that links to the PR it came from. When a pattern came from several PRs, the field shows the count and the rule sidebar lists every contributing PR, so a developer reads the original threads first.
3. Retirement. The "Auto-approve rule miner suggestions" setting decides whether a new rule is active on the next review or waits in Pending rules for an admin. Since Qodo 3.1 (October 15, 2026), Qodo deactivates rarely fixed rules on its own. Locking keeps a rule active, and the rules analytics page shows a "Deactivated by Qodo" count for the last 30 days.
4. Your existing files as the starting point. Qodo imports rule files such as AGENTS.md, CLAUDE.md, GEMINI.md, copilot-instructions.md and everything in .cursor/rules/. Only new rules in imported files sync, so you edit and retire rules in the Rules tab.
5. Shared rules before the agent writes. The Get Rules skill in the Agentic Toolbox loads your Qodo Rules into a coding agent before the agent writes, and the PR review still checks every change.
6. Cadence and providers. The first run reads up to about 1,000 recently merged PRs once PR history indexing finishes and generates up to 10 rules per repository. Rule Miner then runs every two weeks and adds up to 5. Rule Miner runs on GitHub and GitLab, on multi-tenant and single-tenant deployments.
7. Pricing. A 14-day free trial, then Pro Team from $30 a month for 2,500 credits pooled across the team, with self-learning under custom Enterprise pricing (October 2026).

Best For

Qodo is best for platform and staff engineers who want rules mined from real fixes, traceable to their source PRs and retired by how often the team fixes them.

How It Ranked

Qodo counts only accepted comments that changed code, links each rule to every contributing PR, and retires rules by fix rate unless you lock them. In the parseISO case, Rule Miner proposes a rule scoped to web/**, with the source PRs one click away.

2. CodeRabbit: Configuration Files and Chat Preferences

Tool Overview

CodeRabbit is an AI PR reviewer on GitHub, GitLab, Azure DevOps and Bitbucket. CodeRabbit builds its rules from config, guideline files, preferences stated in chat and learnings CodeRabbit infers during review.

Main Features

1. Configuration and learnings. .coderabbit.yaml holds path instructions and code guidelines files, and learnings apply per repository or org-wide.
2. Traceable learnings. Each learning shows who created it and the repository, and pending learnings show the source PR when available.

Best For

CodeRabbit is best for reviewers who state preferences to the bot in chat.

How It Ranked

Chat-sourced learnings apply at once by default, with an optional approval delay of up to 30 days, and inferred learnings apply right away to their source PR. Nothing retires a learning automatically, and the dashboard flags never-used learnings. In the parseISO case, the rule arrives through chat, config or a learning inferred during review.

3. Greptile: Dashboard Rules, Team Comments and Reactions

Tool Overview

Greptile is an AI PR reviewer on GitHub, GitLab, Bitbucket and Cursor Origin, priced at $1 per credit. Greptile learns from team comments and whether they get addressed.

Main Features

1. Custom rules. Rules written in the dashboard or .greptile config apply as written.
2. Learning from the team. Greptile learns from team comments on PRs, replies, reactions and commits that show whether comments were addressed between the first and last commit.
3. Rule discovery and suppression. Greptile infers suggested custom rules from repeated team comments, and comment types the team keeps ignoring are suppressed.

Best For

Greptile is best for teams who want everyday comments and reactions to shape review.

How It Ranked

Greptile counts whether comments were addressed and suppresses ignored comment types. In the parseISO case, the repeated, applied requests are documented inputs, while Greptile's docs don't say whether a learned rule links back to its source PRs (October 2026).

4. Cursor Bugbot: Team Rules, BUGBOT.md and Remember Comments

Tool Overview

Cursor Bugbot is Cursor's PR reviewer, billed through a Cursor plan. Bugbot learns from repository activity and from an explicit @cursor remember comment in the PR.

Main Features

1. Rule sources. Team Rules, .cursor/BUGBOT.md and repository rules sit next to rules Bugbot generates from GitHub activity or a manual backfill.
2. Remember comments. A @cursor remember comment turns a point raised in a PR into a rule, with rules capped at 30,000 characters each and 100,000 combined.
3. Rule analytics. Each rule shows issues found, accepted issues and acceptance rate.

Best For

Cursor Bugbot is best for engineering groups who add rules with a remember comment in the PR.

How It Ranked

Bugbot enables or disables learned rules as it learns more, and per-rule acceptance rates show their value. In the parseISO case, the rule arrives through activity-generated rules or one @cursor remember comment.

5. cubic: Replies, Reactions and Chosen Reviewers

Tool Overview

cubic is an AI PR reviewer on GitHub, with Team at $40 per developer a month. cubic learns from replies and reactions from anyone, and adds the history of up to five reviewers a lead picks, going back up to four years.

Main Features

1. Feedback on cubic's comments. cubic learns from replies to its comments, thread context and reactions.
2. Chosen reviewers' history. Past PR comments from senior reviewers picked at onboarding appear under Team patterns.
3. Traceable learnings. Each learning shows an actionable summary and the original feedback, and when a stored learning drives a comment, cubic references the learning in that comment.

Best For

cubic is best for leads who pick which reviewers' history shapes the rules.

How It Ranked

cubic links comments to the learning behind them, and a weekly cleanup archives learnings that stop helping. In the parseISO case, the requests become an input through replies, or through history if the reviewer asking for the fix was picked at onboarding.

6. Kodus: Three Months of Closed PRs

Tool Overview

Kodus is an AI PR reviewer on GitHub, GitLab, Bitbucket, Azure Repos and Forgejo, with a free Community plan and Teams at $10 per developer a month plus model tokens.

Main Features

1. A rolling history window. Kodus derives rules from Kody's past reviews and recurring feedback patterns in the last 3 months of closed PRs, and needs 3 months of Kody review history first.
2. Weekly suggestions. Kodus suggests rules weekly, and suggested rules are active by default, with an approval step available.

Best For

Kodus is best for teams who want weekly rule suggestions from recent PRs.

How It Ranked

Kodus's docs don't describe how rules retire (October 2026). In the parseISO case, the requests may become a candidate rule if they fall inside the 3-month window, though a human reviewer's request may not count.

7. Bito: Negative Feedback and Guideline Files

Tool Overview

Bito is an AI PR reviewer on GitHub, GitLab and Bitbucket, with custom guidelines on the Professional plan. Bito learns from how people react to Bito's own comments.

Main Features

1. Rules from negative feedback. Negative feedback on Bito's comments becomes a learned rule that filters Bito's own unwanted suggestions rather than recording team standards. On the Learned Rules dashboard, rules start disabled, switch on at 3 negative feedbacks and can be switched on or off by hand.
2. Guideline files with citations. Guidelines come from the dashboard, .bito.yaml and repo files such as CLAUDE.md, AGENTS.md and .cursor/rules/*.mdc, and guideline comments carry a Citations section linking the guideline.

Best For

Bito is best for teams who correct the bot by reacting to its comments.

How It Ranked

Bito documents no automatic retirement, so rules are switched off by hand. In the parseISO case, a human reviewer's request becomes a rule once someone writes it into a guideline.

8. GitHub Copilot Code Review: Instruction Files and Skills

Tool Overview

Copilot code review is Copilot's PR reviewer on GitHub.com and in Azure DevOps, on paid Copilot plans where reviews use AI credits. Copilot code review follows the instruction files and skills your team writes.

Main Features

1. Instruction files. .github/copilot-instructions.md, path-specific *.instructions.md, AGENTS.md and organization instructions tell the review what to check.
2. Skills and memory. .github/skills add reusable instructions, and Copilot Memory can inform reviews.

Best For

Copilot code review is best for teams that already keep instruction files in their GitHub repos.

How It Ranked

Instructions apply as written until someone edits them, and each rule's source is the file you wrote. In the parseISO case, the rule arrives once someone writes it into an instruction file.

Detailed Comparison: Signal, Source and Retirement

Tool	Signal	Source	Retirement	parseISO case	Best for
Qodo	Accepted comments that changed code, weighted by ownership, recurrence and path	Source field linked to every contributing PR	Approve first or auto-apply; deactivated by fix rate; locking	Rule scoped to web/**, source PRs one click away	Platform and staff engineers who want rules mined from real fixes
CodeRabbit	Config, guidelines files, chat preferences and learnings inferred during review	Each learning shows who created it and the repository; pending learnings show the source PR when available	Apply at once by default; optional approval delay of 0 to 30 days for chat learnings; no automatic retirement, and the dashboard flags never-used learnings	Rule once stated in chat or config, or inferred during review	Reviewers who state preferences to the bot in chat
Greptile	Team comments, replies, reactions and whether comments were addressed in later commits, plus written rules	Docs don't say (October 2026)	Comment types the team keeps ignoring are suppressed; written rules apply as written	Repeated comments are a documented input	Teams who want everyday comments to shape review
Cursor Bugbot	Repository activity, Team Rules, BUGBOT.md, remember comments	Docs don't say (October 2026)	Learned rules enabled or disabled as Bugbot learns; per-rule acceptance rates	Activity-generated rule or one remember comment	Engineering groups who add rules with a remember comment
cubic	Replies, reactions and chosen reviewers' comments	Each learning shows the original feedback, and review comments link to the learning behind them	Weekly cleanup archives learnings that stop helping	Input through replies, or history if the reviewer was picked	Leads who pick whose history shapes the rules
Kodus	Kody's past reviews and recurring feedback in the last 3 months of closed PRs	Docs don't say (October 2026)	Docs don't describe retirement (October 2026)	Possible candidate if inside the 3-month window	Teams who want weekly suggestions from recent PRs
Bito	Negative feedback that filters Bito's own comments, guideline files	Guideline comments cite the guideline; docs don't say for feedback rules (October 2026)	No automatic retirement documented; rules can be switched off by hand	Rule once written into a guideline	Teams who correct the bot by reacting
GitHub Copilot code review	Instruction files, skills, Copilot Memory	The file you wrote	Apply as written until edited	Rule once written into an instruction file	Teams that already keep instruction files in their GitHub repos

A Retirement Policy for Mined Rules

1. Start with approval on for the first two runs of your AI code review rollout, so owners see what the history yields.
2. Lock the handful of rules tied to compliance or incidents.
3. Let everything else retire on its own when the team stops fixing it.
4. Review the deactivated count monthly and re-scope rules that fire in the wrong paths.

Conclusion: Your Code Review Rules Already Exist

Your code review rules already exist in review threads where a senior engineer asked for the same fix again and again. Bugbot, cubic and Greptile retire, archive or suppress learned feedback too, and Qodo retires a rule by how often your team fixes its findings, with every mined rule linked to its source PRs.

In the parseISO case, Qodo ends up with a frontend-scoped rule, traceable to its source PRs and retired if the team stops applying it. Keep AGENTS.md and CLAUDE.md as the starting point, because static rule files fail when nobody updates them (Qodo blog).

FAQ

Are review rules the ones in our AGENTS.md and CLAUDE.md files, or separate ones?

Review rules can come from your AGENTS.md and CLAUDE.md files and from rules Qodo mines or you write. Qodo's Rule enforcement imports rules from those files, takes rules you write, and adds rules Rule Miner finds in PR history.

How does a tool learn coding rules from pull request history?

Qodo's Rule Miner reads about the 1,000 most recently merged PRs and counts only comments that developers accepted and that led to code changes. The first run adds up to 10 rules per repository, and runs every two weeks add up to 5 more.

Can we write our own rules, including from a point raised in review?

You write rules in the Qodo portal with a category, severity and scope, including from a point raised in review, and members' rules wait in Pending rules for an admin. When a finding comes from a rule, the PR thread links to the rule, so you can check the rule or fix the code.

Can rules be layered across the org, teams, repositories and paths?

Qodo rules can be layered: global by default or scoped to Git organizations, repositories and path patterns, and a rule imported from src/payments/AGENTS.md applies only under that folder. One scope can list up to 25 organizations and repositories.

How do I make my coding agent follow my team's coding rules?

Give the agent the rules before it writes, then check the result in review. Qodo's Get Rules skill loads your Qodo Rules into a coding agent, and the PR review checks every change against the same rules.

Which AI code review tools support Copilot instructions files?

Several AI code review tools read them, and Copilot code review reads .github/copilot-instructions.md and path-specific instruction files. Qodo imports copilot-instructions.md as rules next to AGENTS.md, CLAUDE.md and .cursor/rules/, and checks every PR against them whichever agent wrote the code.