Hello Devs 👋
Here's a situation many developers will recognize.
You've finished implementing a feature. The tests are passing, the code looks reasonable, and you're getting ready to open a pull request. Before doing that, you take another look at the diff and notice a missing null check, an incorrect condition, or an edge case you didn't consider while writing the code.
It happens. Sometimes you catch it yourself, and sometimes the PR reviewer catches it later.
Now imagine having an AI code reviewer check your changes before you even create the pull request.
That's the idea behind local AI code review.
Instead of waiting for a PR to be opened, you can ask a review tool to inspect your current Git changes, identify potential problems, and return findings while the code is still sitting on your machine.
I think this is becoming an important part of AI-assisted development, especially when developers are using coding agents like Claude Code, Cursor, and Codex.
Let's look at the tools that support this workflow and what makes their approaches different.
Why review code before opening a PR?
The usual AI code review workflow looks something like this:
Developer writes code | v Commit and push changes | v Open pull request | v AI code review | v Fix reported issues | v Request another review There is nothing wrong with this workflow. PR reviews are important, and they provide a useful place for developers to discuss changes.
But there is one limitation. By the time the review happens, the developer has already finished the implementation and moved into the review process. If the tool finds a problem, the developer has to go back, understand the finding, make the correction, push another update, and wait for another review.
With local review, you can move that feedback earlier.
Developer writes code | v Run tests | v Review local changes | v Fix findings | v Run tests again | v Open pull request The advantage isn't that you no longer need PR reviews. It's that you can catch some problems before asking another developer to review your work.
For coding agents, this becomes even more useful. The agent can write the code, request an independent review, inspect the findings, and fix the issues while it still has the implementation context.
What should a local code review tool actually review?
This is something I would check before choosing a tool.
A local review tool should ideally understand more than the last commit.
For example, imagine you've modified three existing files, created two new files, and haven't committed anything yet. If the review tool only checks committed changes, it won't see the complete implementation.
A useful local review should be able to inspect:
- Modified and staged files.
- Uncommitted changes in the working tree.
- New and untracked files.
- The difference between your branch and its intended base branch.
- The purpose of the change, including relevant tickets or specifications.
- Related code and dependencies that might be affected.
The last two points are particularly important. A reviewer that only sees a diff may misunderstand why you made a particular change or flag something that was an intentional design decision.
Some tools can also provide structured findings that a coding agent can process directly. That makes it possible to build a review-and-fix loop without manually copying every finding into another prompt.
1. Qodo: Local review through the CLI and Agentic Toolbox
Qodo is particularly interesting here because local review is connected to its broader code review and coding-agent workflow.
With Qodo's Agentic Toolbox, developers can use the qodo-review skill to review local changes before opening a pull request. It uses the same review engine as Qodo's PR review, but the review happens while the changes are still in the developer's working tree.
You can also run the review directly from the command line using the Qodo CLI.
For example:
qodo review You don't need to create a pull request first.
The review can include committed and uncommitted changes, along with new and untracked files. You can also provide additional context, such as what the feature is supposed to do, important implementation decisions, and links to the ticket or specification.
This is useful because a code reviewer should understand the intention behind a change, not just compare two versions of a file.
There is another detail worth mentioning: your local changes don't need to be pushed for the review. The comparison base must be available remotely, but your working-tree changes can remain local.
Qodo collects the relevant changes and sends them to its review engine. It returns structured findings without pushing your code, creating a PR, or posting comments to your Git provider.
How the Agentic Toolbox changes the workflow
The CLI is useful on its own, but the more interesting part is how Qodo connects local review with coding agents.
Suppose you're using Claude Code or Codex to implement a new API endpoint.
The agent finishes the implementation and runs the tests. Instead of immediately preparing a pull request, you can ask it to review its local changes using Qodo.
The workflow looks like this:
Developer gives a task | v Claude Code / Codex | v Agent implements the feature | v Tests run | v Qodo independent review | v Findings returned to the agent | v Agent fixes approved issues | v Developer checks the result | v Pull request The important distinction is that Qodo provides an independent review. The coding agent writes the implementation, while Qodo's review engine examines the resulting changes.
The qodo-review skill makes this available inside the coding-agent session. The agent can receive structured findings and use them to investigate and fix problems without requiring the developer to move between multiple tools.
You can also use the qodo-codebase-wisdom skill to investigate repository relationships, pull request history, and cross-repository dependencies before or during implementation. This adds useful context when a local change could affect code outside the current repository.
Qodo 3.0 and the bigger picture
Qodo 3.0 takes this beyond reviewing an individual diff. Its Software Map helps teams understand relationships between repositories and services, while PR Triage helps organize related pull requests and understand the potential impact of larger changes.
That broader context is useful when reviewing local work too. A change might look correct in the current repository but affect a shared API, library, or downstream service.
Combined with the Agentic Toolbox, the idea is to give coding agents access to relevant system context and an independent review step before their changes reach a pull request.
I think this is a meaningful difference from simply adding a review command to a terminal. The review becomes part of the development workflow, rather than another task developers remember to perform at the end.
Qodo is worth considering when you want local review, independent findings inside your coding agent, and access to broader codebase context before creating a PR.
2. CodeRabbit: Review local changes from the CLI
CodeRabbit is another tool to look at if you want AI code review directly from your terminal.
Its CLI brings CodeRabbit's review capabilities into a local development workflow. This means developers can ask for feedback on their changes without relying exclusively on the review process that starts after opening a pull request.
The advantage is convenience. Developers who already use CodeRabbit for PR reviews can also evaluate its CLI workflow before pushing their changes.
For example, after implementing a feature, you can run a local review and inspect the findings before creating the PR.
One thing I would check during evaluation is exactly which Git changes the CLI includes. Local review requirements vary, particularly when a developer has staged changes, uncommitted modifications, and newly created files in the same working tree.
Also remember that running a CLI locally doesn't necessarily mean the AI model runs locally. You should check CodeRabbit's data-processing and model configuration if your organization has source-code privacy requirements.
CodeRabbit is worth evaluating if your team already uses its PR review workflow and wants to bring review feedback closer to the developer's terminal.
3. Greptile: CLI-based review before pushing
Greptile is also worth considering for developers who prefer running AI code review from the command line.
Its CLI provides a way to bring Greptile's code review capabilities into the local development process, rather than relying only on pull request-based feedback.
This is useful when you want to inspect a change before sharing it with the rest of the team.
Greptile's codebase understanding is another relevant aspect. A review can benefit from knowing how the changed code relates to the wider repository, rather than examining every line without context.
However, I would test the exact local workflow before choosing it. Check whether it includes the uncommitted and untracked files you care about, how it handles branch comparisons, and whether findings can be passed back into your coding agent.
As with other CLI-based review tools, don't assume that the CLI itself means the model or review engine runs on your machine. Check the actual deployment and data-flow requirements.
Greptile is worth evaluating if you want to bring its codebase-aware review capabilities into a pre-PR workflow.
4. Macroscope: Local AI review from the terminal
Macroscope is another option in this category.
Its CLI is designed to review changes from your local branch before you push them. It brings review feedback into the terminal, so developers can identify potential bugs earlier instead of waiting for a pull request review.
The idea is similar to the other CLI tools: inspect the local changes, return findings, and give the developer an opportunity to fix problems before sharing the branch.
Macroscope is worth including in a comparison because local review is its focus, rather than treating the CLI as just another way to interact with a PR review product.
As always, check the details that matter to your workflow: which files are included, how the tool handles uncommitted changes, how it communicates findings, and whether it supports the coding agent you use.
Quick comparison
Here's how I would think about these options:
| Tool | Local review approach | What stands out |
|---|---|---|
| Qodo | CLI, Agentic Toolbox, MCP, coding-agent integrations | Independent local review with session context and broader codebase understanding |
| CodeRabbit | CLI | Brings CodeRabbit review into the terminal workflow |
| Greptile | CLI | Codebase-aware review available in a local workflow |
| Macroscope | CLI | Focuses on reviewing local branch changes before pushing |
One important point: a CLI review and a local model are two different things. A tool can inspect your local Git changes while sending the review request to a hosted service. If your requirement is that all analysis must happen on your machine, check model hosting and deployment separately.
What I would test before choosing one
I wouldn't choose a local review tool based only on the number of findings it reports.
I'd take a real feature branch and create a few different types of changes.
First, modify an existing function and leave the changes uncommitted. Then add a new file without staging it. Finally, make a change that depends on an existing API contract or business rule.
Run the review and check whether the tool understands the complete change.
I would pay particular attention to these questions:
- Does it review staged, unstaged, and untracked files?
- Can it compare the branch against the correct base?
- Can I provide the task description or design specification?
- Does it identify actual bugs, or mostly style and formatting issues?
- Are findings specific enough for a developer or coding agent to fix?
- Can it run inside Claude Code, Codex, or another agent?
- Does it review the changes independently of the coding agent?
- Does it understand dependencies outside the immediate diff?
Also check whether the tool modifies files automatically. Personally, I prefer a workflow where the reviewer reports findings and the developer or coding agent decides which fixes are appropriate. That keeps the review step separate from the decision to change code.
Does local review replace PR review?
No, and I don't think it should.
Local review is useful because it catches issues while the developer is still working on the change. But the final pull request can contain additional commits, merge conflicts, or changes introduced after the local review.
The PR also gives the rest of the team an opportunity to discuss the implementation, question architectural decisions, and check whether the change meets the original requirement.
I would use both stages:
Local review | | Catch issues during development v Pull request review | | Validate the final shared change v CI checks and human approval | v Merge Think of local review as an additional quality checkpoint, not a replacement for the team's existing review process.
Final Thoughts
I think local AI code review is one of the more practical additions to an AI-assisted development workflow.
When a coding agent can write a feature, run tests, and request an independent review before opening a PR, developers get feedback at a much more useful point in the process. They can fix problems while the implementation is still fresh instead of waiting for someone else to find them.
Qodo's Agentic Toolbox is particularly interesting because it connects local review with the coding agent itself. Its qodo-review skill can inspect local committed and uncommitted changes, include new files and coding-session context, and return structured findings before a PR exists. Qodo 3.0 adds a broader system context through Software Map and PR Triage, making it relevant for teams working across larger codebases.
CodeRabbit, Greptile, and Macroscope are also worth testing if you want terminal-based review options. The right choice depends on how much context you need, which coding agent you use, and how the tool handles your actual Git workflow.
For me, the ideal workflow is simple: let the coding agent implement the change, let an independent reviewer inspect it, fix the important findings, and only then open the pull request.
The earlier you find a problem, the less expensive it usually is to fix.
👨💻 TL;DR
If you want to review code before a pull request exists:
- Qodo: Local CLI review and Agentic Toolbox integration, including committed, uncommitted, and untracked changes. Strong option when you want independent review inside your coding-agent workflow.
- CodeRabbit: CLI-based local review, useful for teams already using CodeRabbit for PR reviews.
- Greptile: CLI-based review with codebase understanding.
- Macroscope: Terminal-focused review of local branch changes.
Thank You!!🙏
Thank you for reading this far. If you find this article useful, please like and share this article. Someone could find it useful too.💖
