Co-Review: The New IDE Tool That Treats Your Entire Codebase as a PR Review

Code review has always been the most easily overlooked yet energy-draining part of the development workflow. Traditional tools only focus on the diff, but when you're facing an unfamiliar repository written weeks ago by an agent, a teammate, or even yourself, a diff view is far from enough. Co-Review tries to solve this problem—it lets you open an entire repository as if you were opening an IDE, treating every line of code as something reviewable.

Why You Need to "Review the Entire Repository"

In everyday development, most of the code you encounter isn't written by you: other teams' repositories, agent-generated modules, teammates' commits. The code runs, but you may not understand it. When you want to read through an entire codebase, existing tools only show diffs—whether or not an agent is involved, there's no convenient entry point.

Co-Review is built precisely for this: open a repository and browse any code just like in an IDE, ask the agent questions at any time, and leave notes anywhere—as naturally as writing comments on a diff—and come back weeks later to keep reviewing. Reviewing the entire repository is its main job, and the same tool also covers agent changes, teammates' Pull Requests, and design docs before writing code.

Diff review is a common practice in version control system (such as Git) workflows: reviewers only see the lines added, deleted, and modified in a particular commit or Pull Request relative to a baseline branch. Its advantage is focused scope and low cost, but it assumes the reviewer is already familiar with the rest of the repository. When facing an unfamiliar codebase, the diff hides a lot of context—the behavior of called functions, dependencies between modules, historical conventions—all of which require reading the entire repository to build understanding. Co-Review targets exactly this gap: it expands the review subject from "what changed this time" to "what this code means in the context of the entire repository."

Four Review Scenarios, One Command to Unify the Workflow

Co-Review breaks review into four reusable scenarios, each requiring just one command, with everyone following the same process: the agent prepares, you review, and finally you give the verdict.

Scenario 1: Auditing the Entire Codebase

Run the audit agent, which first reads the entire codebase, divides the code into several regions, marks findings in each region, and tells you where to start reading region by region. Coverage tracking records what you've already seen, and you can ask the code questions directly at any location, with the agent answering from the code itself. When the review is done, the repository returns to the state you're familiar with.

Scenario 2: Reviewing the Agent's Own Changes

Have the agent open the diff as a Pull Request, summarizing what changed and why, and giving findings on key lines. You comment on a line suggesting a change, the agent replies in the thread and requests changes; then it fixes each comment as a new commit and replies in each thread.

A Pull Request (PR) is a code merge request on platforms like GitHub, typically containing a set of commits, a change description, and discussion threads. The core mechanism of PR review is the "inline comment": reviewers can leave a comment on a specific line of the diff, the author replies or submits fixes one by one, and the thread records the full back-and-forth. Co-Review reuses this interaction model in Scenario 2—you comment on a line suggesting a change, the agent replies in the thread and requests changes, then fixes each comment as a new commit and replies thread by thread. This way, the agent's fix process is as traceable and auditable as a human teammate's PR iteration, rather than quietly completed in an invisible background operation.

Scenario 3: Reviewing Someone Else's Pull Request

Hand it the PR number, and the agent reads and checks out that PR's code to complete the first round of review. It handles the scope and the riskiest parts; you keep the important findings, ignore the rest, and ask for what you need. Finally, submit the review and publish it to GitHub, with inline comments you've written yourself.

Checkout is the Git operation that switches a branch's or commit's code into your local working directory. In the PR review scenario, to truly understand changes, reviewers usually need to check out the PR branch locally and read it in the context of the full code, not just look at the diff on the web page. What Co-Review means by "reads and checks out that PR's code" is that the agent first fetches the PR's metadata and diff, then pulls the corresponding branch locally, so it can analyze the impact, call chains, and potential risks of the changes across the entire repository, complete the first round of screening, and then hand it over to a human for judgment.

Scenario 4: Design Before Writing Code

After you describe the task, the agent investigates and writes a plan, including what to do, how to do it, what might go wrong, accompanied by diagrams. You can comment on any step or diagram node, and it will revise accordingly. Once approved, it builds only what you agreed on, and the changes come back to you as a review.

A Complete Loop from Design to Merge

Stringing these four scenarios together, the workflow for a new feature becomes clear: design and approve the plan first, the agent builds, you review its changes until approved, then it opens a Pull Request, and teammates review it the same way.

In all four cases, the plugin keeps Claude in the session: as soon as you ask a question, comments reach the session in the background, the writing reviewer keeps responding while Claude fixes issues, and new sessions know what to wait for. Beyond Claude Code, the API and native commands offer the same four review capabilities, and Codex, OpenCode, Cursor, Gemini, Goose, and any MCP agent can plug in.

MCP (Model Context Protocol) is an open protocol that lets AI applications connect to external tools and data sources in a standardized way. Agents that support MCP (such as Codex, OpenCode, Cursor, Gemini, and Goose mentioned in this article) can call external services through a unified interface without writing a separate integration for each tool. Co-Review uses MCP to expose the four review capabilities to these agents, giving them the same review workflow as the Claude Code plugin; it also provides an API and native commands for scenarios requiring more direct integration. This is also why "any MCP agent can plug in"—once the protocol layer is unified, the integration cost mainly falls on configuration rather than rework.

Installation and Getting Started

Starting with Claude Code, add the marketplace and install the plugin—four commands put it at your disposal. The core philosophy stays consistent: you are always the reviewer, and the agent stays accountable.

Co-Review's value isn't in replacing human review, but in expanding the granularity of review from the diff to the entire repository, letting the agent handle the first round of screening while humans focus on high-risk areas and key decisions. For development workflows with increasing agent involvement, this division of labor may be closer to how work actually gets done than pure diff review.

One-line Summary

Co-Review expands code review from the diff to the entire repository, unifying four review scenarios with a single command.

Paragraph Summary

Co-Review is a code review tool built for the agent-era development workflow. Traditional tools only show diffs, and when developers face unfamiliar repositories, agent-generated modules, or teammates' commits, a diff view can't provide enough context. Co-Review lets developers open an entire repository as if in an IDE, ask questions and leave notes on any line of code, and come back weeks later. It breaks review into four scenarios: whole-repo audit, reviewing agent changes, reviewing teammates' PRs, and designing before writing code—each requiring just one command. Agents handle the first round of screening and fixes, while humans retain final judgment on high-risk decisions and key findings. The tool installs from the Claude Code plugin marketplace and can also connect to agents like Codex, Cursor, and Gemini via API, native commands, or MCP.