The cheapest moment to fix a coding agent's mistake is before anyone else has to read it. Local code review moves the first check into the agent session and the developer's machine, so the pull request arrives smaller and cleaner.
Most review now happens before a PR exists on the Claude Code team, and its merged PRs more than doubled from June to September while the share reverted fell by more than 40%, according to the team's Oct 15, 2026 post on solving code review (self-reported).
Large PRs are where review breaks down. 19.0% of developers say PRs are now larger and harder to parse, which leads to review fatigue, according to the Qodo State of AI Code Quality 2026 (Censuswide, August 2026, self-reported).
The Review Timeline: Five Moments Before Merge
Review before the PR isn't one tool. Review before the PR is a timeline, and each tool runs at one moment on it:
- While the agent works, inside the coding session
- Before you commit, in the IDE
- Before you push, in the agent or a git hook
- Before the PR opens, on the whole branch
- On the PR, with the same standards
High-velocity teams whose agents open many PRs a day feel the difference first. Platform teams want the same standards at every stage, whichever agent or IDE a developer uses.
Nnenna Ndukwe already made the case for why after-the-PR is too late, so this piece maps which tool runs at which moment, and which one should be independent.
TL;DR: Seven Local Code Review Tools Mapped to When They Run
Pick one check per stage, and make at least one of them independent of the agent that wrote the code.
| Tool | Command or entry point | Stage | Scope | Rules file | Edits code? |
|---|---|---|---|---|---|
| Qodo's Agentic Toolbox (local review) | CLI qodo review, plugins for Codex and Claude Code, a Kiro Power, MCP |
While the agent works, plus PR review in your Git | Local commits, uncommitted and untracked changes; pathspecs | Imported repo rule files (AGENTS.md, CLAUDE.md) plus rules learned from accepted comments | Returns findings |
OpenAI Codex /review
|
/review |
While the agent works | Uncommitted, base branch, commit | AGENTS.md ## Code Review Rules
|
No |
Claude Code /code-review
|
/code-review |
While the agent works | Branch, uncommitted, ranges, PR, path | CLAUDE.md | Only with --fix
|
| GitHub Copilot code review in the IDE | Source Control in VS Code; "Review changes with Copilot" in Visual Studio | Before commit | Selection, uncommitted | copilot-instructions.md | Suggestions |
| JetBrains AI Assistant Self-Review | Commit dialog | Before commit | Selected uncommitted changes, a commit | Markdown rules path | Quick fixes when available |
Cursor Agent Review and /review-bugbot
|
/agent-review, /review-bugbot
|
Before push | Each commit (auto), all local changes vs main, branch vs base | BUGBOT.md | Fix links |
JetBrains Junie CLI /review
|
/review, headless junie --review
|
Before the PR opens | Vs main, last commit, staged, unstaged, ranges | Project guidelines | Never |
Six of the seven run inside a coding agent or assistant that can also write the code, so the order you stack them matters as much as the tools you pick.
Stage 1: While the Agent Is Still Working
The agent session is where a finding costs least, because the agent still holds the intent behind the change. The first three rows of the table run here, which is the idea behind pre-PR code review.
Qodo's Agentic Toolbox: Local Review in Your CLI or Coding Agent
Qodo, the AI code review platform, runs its review inside the agent session through Qodo's Agentic Toolbox. The Reviewer skill in Qodo's Agentic Toolbox reviews local, committed and uncommitted changes, including untracked files, with the same engine as Qodo's PR review in your Git.
Qodo's local review takes the session context you provide, such as a summary of intent, key decisions and links to the ticket or spec. Record a deliberate decision once, and the reviewer doesn't re-flag it as an issue. Each run can be a fast single pass or a deeper review, scoped with git pathspecs.
Findings come back in a machine-readable form, so an agent loop can read them.
Qodo's local review returns findings for the agent to act on, so the fix runs through the agent's own editing workflow, and only the base commit has to be pushed, because the engine clones the base from your Git provider. The local review docs list every option.
Worked Example: The Agentic Toolbox in Your CLI
Install the Agentic Toolbox (Node.js 20 or later), then run a CLI code review from the repo.
curl -fsSL https://get.qodo.ai | sh
# from your repo, with local changes in place
qodo review
Qodo's docs show this example output:
qodo review
Reviewing acme/widgets @ a1b2c3d4e, 3.2KB of local changes
Correctness/action_required
-> Off-by-one in pagination cursor (src/api/list.ts)
Security/action_required
-> Unescaped input in a shell command (src/jobs/run.ts)
2 finding(s), fixed before any pull request exists
A developer or agent fixes each finding and runs qodo review again.
Qodo's suggested loop is review, fix, review again, with a cap on iterations so the agent doesn't loop forever.
Where Else Qodo's Agentic Toolbox Runs
Qodo's Agentic Toolbox also runs as a plugin for Codex and Claude Code, as a Kiro Power, and through any MCP client that supports Streamable HTTP and custom request headers. Store the API key in your client's secret management. For the step-by-step agent setup, see Kiran Naragund's walkthrough.
Local review now runs through the Agentic Toolbox, since Qodo retired its IDE plugin on Nov 1, 2026, as the deprecation notice explains.
OpenAI Codex /review
In the CLI, Codex's built-in /review command reviews changes against a base branch, uncommitted changes (staged, unstaged and untracked), a single commit, or custom review instructions; the app and IDE extension support the base-branch and uncommitted scopes.
Codex reports prioritized findings without changing your working tree, and the ## Code Review Rules section of AGENTS.md guides its GitHub reviews.
Codex /review needs no setup inside Codex, and the same reviewer runs on GitHub PRs through @codex review.
Claude Code /code-review
Claude Code's /code-review command finds bugs in the current branch and uncommitted changes, and also takes commit ranges, branches, a PR number or a path. The --fix flag applies fixes, and --comment posts findings on a GitHub PR, or on a GitLab MR via glab.
Claude Code /code-review takes a branch, a revision range, a PR number or a path as its target. I covered Claude's PR side in my post on Claude Code Review.
For add-ons that extend Claude's local pass, the hub keeps a list of Claude Code review skills.
One Stage, Two Kinds of Reviewer
Codex /review and Claude Code /code-review review inside the tool that wrote the code. You shouldn't review code with the same tool that wrote it, so an independent reviewer gives the agent a second opinion it can't talk itself out of. The technical case is in why AI self-review fails.
Stage 2: Before You Commit
The commit is the last moment a developer reads the diff alone, so IDE review fits here. A Stage 2 pass in the IDE can catch what the Stage 1 pass missed.
GitHub Copilot Code Review in the IDE
In VS Code, Copilot reviews uncommitted changes from the Source Control view, through "Copilot Code Review - Uncommitted Changes". In Visual Studio, the command is "Review changes with Copilot". Copilot code review also runs in Xcode and JetBrains IDEs.
Copilot reads .github/copilot-instructions.md, *.instructions.md and AGENTS.md, and Copilot's IDE review is one click in editors developers already use. On GitHub PRs, teams also pick an effort level, Lite, Balanced (the default) or Max (public preview).
JetBrains AI Assistant Self-Review
JetBrains AI Assistant lets a developer ask for a review before committing, from the commit dialog. Self-Review takes selected uncommitted changes, a commit, or files in a commit, and reads review rules from a Markdown file path the team configures.
JetBrains Self-Review lives exactly where the developer decides what to commit.
Why the IDE Pass Pays Off
AI has made review harder work. 36.4% of developers say reviewing takes the same time but more cognitive effort to spot hidden AI bugs, according to the same Qodo survey. A Stage 2 pass shrinks what reaches a person.
Lint and static checks still belong in the same moment, as I wrote in static analysis vs code review.
Stage 3: Before You Push
The push is where a team can add a check every developer runs, whether or not each developer asked for one.
Cursor Agent Review and /review-bugbot
Cursor Agent Review reviews local changes inside Cursor, from /agent-review, the Source Control tab or automatically after commits, at Quick or Deep depth. The /review-bugbot and /review-security commands run in the agent before you push, in Cursor 3.7 or later and the Cursor CLI.
Rules live in BUGBOT.md, and Cursor's project rules in .cursor/rules don't apply to Bugbot runs. Agent Review also reads BUGBOT.md, so the local pass and the PR pass share rules.
When Bugbot on GitHub, GitLab or Bitbucket sees a PR diff that /review-bugbot already reviewed locally, Bugbot skips the repeat review.
Pre-Push Hooks: Advisory or Blocking?
A git hook makes review automatic for everyone, and the default behavior varies. OpenRouter's guide to building a pre-push reviewer walks through a 233-line Python script that runs locally, as a pre-push hook or in CI (Nov 1, 2026).
OpenRouter's script blocks at high severity by default and costs about $0.015 to $0.045 per review in OpenRouter's tests. git push --no-verify skips local hooks, so the guide recommends running the same reviewer in CI.
An Architect's View on Hooks
A hook that blocks trains developers to skip the hook. Findings work better as information the agent or developer acts on, with the merge gate configured by the team on the PR.
Qodo flags; your team decides what blocks the merge. Qodo's local review hands findings to the agent or developer, and the merge gate stays with the team on the PR.
Stage 4: Before the PR Opens
The last local pass should read the whole branch, not the latest edit.
JetBrains Junie CLI /review
Junie's local code review is built for a quick sanity check before opening a pull request. Junie /review compares against main, the last commit, staged or unstaged changes, or a range, and runs headless as junie --review. Junie's reviewer never edits files, runs builds or runs tests.
Junie reads the project's guidelines and code-review skills, and the review runs as its own session that you can follow up with questions.
Stage 1 tools also cover this moment. Codex /review against a base branch reads the whole branch diff, Claude Code /code-review takes a branch, and qodo review against your base branch, with a deeper review for that run, checks the full local change.
Why the Last Local Pass Earns Trust
Teammates read AI-assisted PRs with more suspicion. 24.0% of developers report lower trust in peer PRs because they don't know how much AI wrote, according to the same Qodo survey. A branch that passed review before the push and again before the PR opens gives teammates evidence to trust instead of a guess.
Stage 5: On the PR, With the Same Standards
Local code review shrinks the PR, and PR review still runs on the final, pushed changes, as Qodo's local review docs note.
Same Engine on Both Sides of the PR
Qodo in your Git reviews the pushed PR on GitHub, GitLab, Bitbucket, Azure DevOps and Gerrit, and adds what only PR review has.
Cross-repo context flags a change in one repo that breaks a consumer in another, and PR history shows how similar findings were handled. On GitHub, GitLab and Azure DevOps, Qodo's rules detection agent also turns the team's accepted review comments into rules.
The rules detection agent learns only from accepted comments that led to code changes, and admins choose whether new rules wait for approval. Since Qodo 3.2, follow-up reviews focus on the latest fixes, and the first review of a PR is never narrowed. For the difference context makes, see full codebase context.
The Bundled PR Reviewers in One Line Each
Codex reviews PRs on GitHub with @codex review, Cursor Bugbot reviews every PR update, and GitHub Copilot code review runs on GitHub PRs. For a ranked view of PR reviewers, see this list of AI code reviewers.
Why Context Decides PR Review
Architecture is where AI review still falls short. 38% of engineering leaders name keeping architecture consistent as one of their biggest quality and governance gaps, according to the same Qodo survey. Human reviewers still own the design call, as I covered in peer code review approaches.
Choose Qodo When One Review Standard Must Cover Every Stage
A team with three agents often runs three local reviewers, and PRs still arrive with the same class of bug. Qodo gives every stage one engine and one standard.
Signs Qodo Is the Right Pick
Choose Qodo when you want one reviewer that runs inside the agent session and then on the PR, with the same engine.
Choose Qodo when the agent's intent and deliberate decisions should travel with the review, so they aren't flagged again.
Choose Qodo when developers use different agents (Claude Code, Codex, Kiro, a terminal or an MCP client) and you want one review standard.
Choose Qodo when PR review must catch cross-repo breakage and apply rules your team's accepted comments taught it, with fewer, higher-signal findings.
What Each Kind of Team Gets
Both kinds of team get agent code merged sooner, with fewer rollbacks. High-velocity teams keep the rule files they already have, such as AGENTS.md and CLAUDE.md, and Qodo checks them on every PR, with setup measured in minutes and no new process.
Enterprise teams get one rulebook across many repos and agents, reviews on GitHub, GitLab, Bitbucket, Azure DevOps and Gerrit, single-tenant, on-prem and air-gapped options, and every finding logged and exportable.
For the wider tool map beyond local review, see my shortlist of code review tools for enterprise teams.
Summary
While the agent works, Qodo's Agentic Toolbox, Codex /review and Claude Code /code-review catch issues while the intent is fresh. Before commit, Copilot's IDE review and JetBrains Self-Review give the developer a last solo read. Before push, Cursor's commands and git hooks add a check everyone runs.
Before the PR opens, Junie and whole-branch passes read the full change. On the PR, the same standards apply again. Pick one check per stage, and make one of them independent of the agent. One standard at every stage means agent code merges sooner, with fewer rollbacks.
For the basics behind every stage, start with what code review is.
FAQ
Do my changes need to be pushed for local code review?
Not for Qodo's local review. Only the base commit you compare against has to be on your Git provider, because the review engine clones the base from there.
Does local review replace PR review?
No. Local review shrinks the PR, and PR review still validates the final, pushed changes, with context that only exists once the PR is open, such as cross-repo impact and PR history.
Can I review staged changes only?
Yes, with several tools. Junie /review takes staged changes, Copilot in the IDE reviews a selection, and qodo review takes git pathspecs to narrow the scope.
Should a pre-commit or pre-push review block?
The team decides. Blocking hooks are easy to skip with --no-verify, so many teams keep local findings advisory and configure the merge gate on the PR, where branch protection already lives.
Which local review tools work in JetBrains IDEs?
JetBrains AI Assistant Self-Review and Junie run in the JetBrains world, and Copilot code review runs in JetBrains IDEs. In a JetBrains IDE, developers run Qodo's local review from the built-in terminal with qodo review, or through a coding agent plugin.
Is Qodo a test generation tool?
Qodo isn't focused on test generation, even though some authors still point to it as a key strength. In my experience, Qodo is best at AI code review and code governance for reviewing a coding agent's changes before the pull request opens and again on the PR itself.
For the concepts behind local and PR review, see how AI code review works.
Top comments (0)