Co-Review
Review code and designs with your agent

You built it with your coding agent. Make it yours again.

Months of agent-written changes later, the code works, but you no longer know it. Co-Review opens the entire repository as a review: read it like a pull request, ask the agent why anything is the way it is, and come away knowing your codebase again.

$curl -fsSL https://sdsvn.github.io/co-review/install.sh | bash
macOS and Linux. Installs the app and the co-review command.Then set up your agent →
Works withClaude CodePiOh My PiCodexCursorCopilotGemini CLIOpenCodeand any MCP agent
Four ways to review

A repository, a change, a pull request, or the design before it.

The same review tool, whichever you reach for. In every one the agent sets up the review and takes a first pass before you see it, so it opens on what to look at.

  1. Repository

    A whole repository

    Open the entire codebase as one review, to get it back in your head or to check your own work. The overview shows where to start, the agent takes a first pass with findings grouped by area, and coverage tracks what you have read.

    Review a repository →
  2. Change

    Your change

    The agent's diff, a branch against its base or a commit, opened as a pull-request page with the code around it: line comments, suggested edits and one verdict. The review you would do on a PR, before anything is committed or merged.

    Review a change →
  3. Pull request

    Someone else's pull request

    The agent reads the pull request, checks out its code and takes the first pass. You decide what goes back to the author, and your verdict posts to GitHub as one review with line comments and suggestions.

    Review a pull request →
  4. Design

    A design, before the code

    Review the plan, not the source: a design written as an L1 · L2 · L3 tree with Mermaid diagrams. Comment on the step or node that worries you; the agent revises and only builds what you approved.

    Design before code →
Why Co-Review exists

Code you shipped, but no longer know.

Building with an agent is fast. Change by change, one diff at a time, the codebase grows past what you hold in your head. Reviewing the whole thing together, once in a while, is how you get it back.

  1. 01

    It starts as your code

    You know where everything lives and why, because you wrote it or read every line.

  2. 02

    Then it drifts

    Hundreds of agent changes later, every diff looked fine. The whole? It works, but it no longer feels like yours.

  3. 03

    So you review it together

    Once in a while, open the entire repository in Co-Review and read it with the agent that built it. Ask anything; it answers from the code.

How a repository review goes

Read the whole codebase with the agent that wrote it.

  1. 01

    Start from the overview

    An overview page shows where to start, the areas of the code and how they connect. Let the agent go first with proposed findings, grouped by area.

  2. 02

    Read, and ask where you read

    Comment on a line, a function, a file or a folder. Select a few lines and ask why; the question lands in a thread under the code.

  3. 03

    It answers from the code

    A map of every file and what it defines takes the agent straight to the right place. Answers are short, plain and link to the code.

  4. 04

    Know what you have covered

    Mark files as viewed and watch coverage per area. A file changed since you read it counts as unread again.

Changes, pull requests and designs too

Review each change, or the plan before the code.

Between repository reviews, your agent hands over its change as a pull-request page, with the code around it in the explorer. A teammate's pull request opens the same way, and your verdict goes back to GitHub. Or the agent writes the plan first, as a design tree: what happens, then how, then the edge cases. You comment on the step that worries you, it answers or revises, and it only builds what you approved.

CodeLines, ranges, functions, files or the whole repo. Comments follow the code through edits and say when it changed.
DesignsMarkdown with a foldable step tree and a checked format.
DiagramsMermaid, down to a single node or edge.
Pull requestsDiffs and .patch files as pull-request pages; verdicts post to GitHub.
How design documents work →
design.mdL1L2L3
1
Save the order and a charge request together
one transaction, no network calls inside it
insert a charge_requested row keyed by order idnew payment_outbox table
2
Charge from a background worker
at-least-once, safe to retry
call the provider with the order id as idempotency key
mark the row sent, or retry with backoffa charge can succeed while the mark fails
YouIf we crash before marking the row, does the worker charge twice?
Set up your agent

One MCP server for every agent.

Every agent reviews through co-review mcp. Claude Code, Pi and Oh My Pi get native packages; the others add the server to their config and, optionally, the skills.

1 · Install

In Claude Code:

/plugin marketplace add sdsvn/co-review
/plugin install co-review@co-review
2 · Use
/co-review:audit [focus]Reviews the whole repository with you: splits it into areas, proposes findings in each, then answers your questions.
/co-review:reviewWhen a change is ready: it opens the diff as a pull-request page and stays in the review until you submit.
/co-review:pr <n>Someone else's pull request: its first pass, your verdict, posted to GitHub as a review when you choose to.
/co-review:design <task>To design first: it writes a design doc, you review it, it builds what you approved.
Claude Code setup guide →
Made for Claude Code

One plugin: review tools, workflows and slash commands.

Also works with Pi, Oh My Pi, Codex, Cursor, VS Code, Zed, Gemini CLI and any other MCP agent. Connect your agent →

/co-review:auditThe whole repository: Claude splits it into areas, proposes findings for you to accept or dismiss, then answers your questions.
/co-review:reviewWhen a change is ready: Claude opens it as a pull-request page and stays in the review until you submit.
/co-review:prSomeone else's pull request: Claude takes the first pass, you decide what goes back to the author, and it posts to GitHub.
/co-review:designBefore there is code: Claude writes a design doc, you review it, it builds what you approved.
Live commentsWith channels on, your question reaches the running session the moment you ask it.
co-reviewer subagentKeeps answering your review in the background while the main conversation works.
Session hookOpen Claude Code in a repository with waiting questions, and it already knows about them.
Claude Code setup guide →

Install the app

One command installs the desktop app and the co-review command on macOS (Apple silicon) and Linux. Run it again to update. Reviews stay on your machine, outside the repository.

$curl -fsSL https://sdsvn.github.io/co-review/install.sh | bash

Windows: the installer from the latest release. Or build from source.