You built it with your coding agent. Review the whole repository together, and make it yours again.
Made for Claude Code. Native packages for Pi and Oh My Pi. Works with any MCP agent.
Website · Install · Connect your agent · Usage · Docs · Contributing
Building with an agent is fast. Change by change, each diff looks fine, and months later the codebase works but no longer feels like yours: you don't know where things live or why they're built the way they are. Co-Review is for getting it back. Once in a while, open the entire repository as a review and read it with the agent that built it, the way you'd read a pull request. Comment on a line, a function, a file or a folder, and ask why; the agent answers in the thread, from the code. An overview shows where to start, the agent can take a first pass with findings grouped by area, and coverage tracks what you've read.
Reading the whole repository, to learn it and find its weak spots, is one of the jobs below, each one command away. 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 (how each workflow goes):
| Review | Claude Code | Pi / Oh My Pi |
|---|---|---|
| Understand the whole repository: the agent writes a guide to what it does, its map, vocabulary, flows, patterns and naming, with C4 diagrams. No findings, no verdict | /co-review:understand |
/co-review-understand |
| Audit the whole repository, once you know it: a short overview and the agent's findings by area | /co-review:audit |
/co-review-audit |
| Your change: the agent's diff as a pull-request page, with line comments, suggested edits and one verdict | /co-review:review |
/co-review-change |
| Someone else's pull request: the agent takes the first pass, you decide what goes back to the author, and post it to GitHub as a review with line comments | /co-review:pr <n> |
/co-review-pr <n> |
| A design, before the code: an L1 · L2 · L3 plan with Mermaid diagrams, revised from your comments before anything is built | /co-review:design <task> |
/co-review-design <task> |
Co-Review is a review tool with IDE features, not an IDE. It's built on Eclipse Theia, so navigation, search, Git and language servers are the real thing; everything unrelated to reviewing is removed.
you ── inline threads, Ask Agent, Submit review ──┐
▼
Co-Review (desktop app or browser)
│ reviews live in ~/.co-review, outside the repo
┌──────────────┼─────────────────────┐
Claude Code Pi / Oh My Pi any MCP client
plugin packages (Codex, Cursor, VS Code, …)
│ │ │
the agent that did the work opens the review and answers your comments —
or Co-Review launches an agent for a question (ACP: Claude Code, Codex,
Gemini, OpenCode, Goose, Pi, Oh My Pi, with the model you pick)
- Whole-repository reviews with an overview page, per-area coverage (
Cmd+Alt+Vmarks a file viewed) and an agent first pass whose findings arrive proposed for you to accept or dismiss, collected on an overview page you read like a report and comment on like any document. - Inline threads on a line, range, symbol, file, folder or the whole repository. Comments are anchored to their symbol and Tree-sitter tokens, so they follow the code through edits and are marked outdated instead of drifting.
- Agents as reviewers. Select code and Ask Agent: the answer streams into the thread with the agent's steps, and permission requests become buttons.
- A repository map (Tree-sitter, built on demand, stored outside the repo) that takes agents straight to the
right code. With Graphify installed (
uv tool install graphifyy), Co-Review also builds a code graph of the repository (Tree-sitter, no LLM, seconds), so the overview shows the most connected code, the clusters and how they connect. - Design review: rendered Markdown, Mermaid diagrams with per-node comments, and an L1 · L2 · L3 design tree whose structure is declared and checked.
- Patches and knowledge bundles:
.patch/.difffiles open as pull-request pages; OKF bundles open as commentable pages linked to the code. - One verdict — Approve, Request changes or Comment — and the agent gets every open comment in one batch. For a
GitHub pull request, the same verdict posts to it as a review with line comments and suggestions (
gh). - Phone view to read, reply and submit away from your desk.
macOS and Linux:
curl -fsSL https://sdsvn.github.io/co-review/install.sh | bashThis installs the desktop app (macOS on Apple silicon, Linux x64 and arm64) and the co-review command, which runs on
the app's own runtime (no Node.js needed). Run it again to update; CO_REVIEW_VERSION=v0.2.0 pins a release.
Windows: use the installer from the latest release.
co-review ~/src/my-service # open a repositoryTo build from source instead, see Contributing.
The builds are not code-signed yet. install.sh takes care of that on macOS. If you download a release file by hand,
macOS may say the app "is damaged": run xattr -dr com.apple.quarantine /Applications/Co-Review.app once. On
Windows, SmartScreen asks first: choose More info → Run anyway. Intel Macs have no prebuilt app; build
from source.
Co-Review collects no telemetry and needs no account. Reviews are stored on your machine in ~/.co-review; your code
goes to the agent you choose, and to GitHub only when you post a review there.
Every integration launches Co-Review through the co-review command, so install it first. Inside Co-Review,
Connect an Agent in the Review panel sets up any of the harnesses below for you.
/plugin marketplace add sdsvn/co-review
/plugin install co-review@co-review| Command | What Claude does |
|---|---|
/co-review:understand [focus] |
Helps you understand the whole repository: a guide to what it does, its map, vocabulary, flows, patterns and naming and how to change it, with C4 diagrams and a check question per chapter, then answers your questions. No findings, no verdict. Takes the agent a few minutes |
/co-review:audit [focus] |
Reviews the whole repository for problems: a short overview, where it hurts, and proposed findings by area, then acts on your verdict. Takes the agent a few minutes |
/co-review:review [base] |
Opens its change (the diff) as a pull-request page, points out what deserves attention, answers your comments and acts on your verdict |
/co-review:pr <n> |
Reviews someone else's pull request with you: its first pass, your verdict, then posted to the pull request (line comments, suggestions, your decision) when you choose to |
/co-review:design <task> |
Writes a design doc, has you review it, implements what you approved |
With Claude Code's channels on, your questions reach the running
session the moment you ask. A background co-reviewer subagent can keep answering while the main conversation fixes
things, and a session hook tells Claude which reviews are waiting. Plain requests ("review this with me") work too.
Both ship inside Co-Review, so there is nothing to clone:
co-review setup pi # or: co-review setup ompYou get the same co_review_* tools and /co-review-understand, /co-review-audit, /co-review-change, /co-review-pr and /co-review-design
commands in both (plus /co-review to join the review of the working directory),
plus a co-reviewer agent and the skills. In Oh My Pi, only the main session listens for your questions, not every
task subagent. Details: Pi and Oh My Pi.
Codex, Cursor, VS Code, Gemini CLI, Zed, OpenCode, Goose and any other MCP client: add the MCP server
(co-review mcp, config for each) and, optionally, the skills with
npx skills add sdsvn/co-review. The full contract is in llms.txt.
For quick questions while you review, ⋯ → Connect agent… in the Review panel starts an ACP agent (Claude Code,
Codex, Gemini, OpenCode, Goose, Pi or Oh My Pi) with the model you pick. Then select code → Ask Agent
(Cmd+Alt+A). See Agents for when to use which.
Important
Agents and language servers use Co-Review's environment. The desktop app loads your login shell's PATH, and
co-review passes on the terminal's.
Open the Review panel (status bar, or Cmd+Shift+Alt+R) and pick what to review: the entire repository, the
current file, a branch against its base, or a commit. Or right-click files or folders → Start Review of Selection.
| To comment on | Do this |
|---|---|
| A line or range | Click + in the gutter (drag for a range), or select and press Cmd+Alt+M |
| A symbol | Right-click inside it → Add Review Comment on Symbol |
| A file or folder | Right-click it in the explorer → Add Review Comment |
| The repository | ⋯ in the Review panel → Comment on the repository |
Once an agent is connected, asking it is the default (Ask Agent); Comment is the deliberate choice for feedback that goes with your verdict. Reply, resolve and collapse threads inline; the panel lists them by file (Open / Proposed / Resolved / All), and ⋯ has the rest.
- Whole repository: the panel's Coverage shows what you've viewed, overall and per area. Overview says
where to start, and Findings opens every finding and comment as one page.
/co-review:understand(or/co-review-understandin Pi and Oh My Pi) has the agent write you a guide first;/co-review:audithas it find the problems first. - Designs and pages: Markdown files open rendered (the toolbar opens the source; opening at a line goes to the editor). Comment on text, diagram nodes and edges, or design steps. HTML files open as source; Open in Browser (editor or explorer context menu) shows the page in your browser. See Design documents.
- Phone: ⋯ → Open mobile view, or
http://<host>:<port>/m/(local connections only; over Tailscale).
Cmd on macOS, Ctrl elsewhere. Every command is also in the command palette under Review:.
| Shortcut | Action |
|---|---|
Cmd+Alt+M / Cmd+Alt+A |
Comment on / ask the agent about the line or selection |
Cmd+Alt+↓ / Cmd+Alt+↑ |
Next / previous comment |
Cmd+Alt+O |
Go to comment… |
Cmd+Alt+V |
Mark the file as viewed (or not) |
Cmd+Enter / Esc |
Submit / discard an empty draft |
Cmd+Shift+Alt+R |
Show or hide the Review panel |
Language support (TypeScript, JavaScript, JSON, Markdown, PHP, Go with gopls, and how to add more), configuration
variables and themes are covered in Running and packaging.
Published at https://sdsvn.github.io/co-review/.
- Review workflows: the whole repository, your change, someone else's pull request, a design
- Connect your agent: Claude Code plugin, Pi and Oh My Pi packages, skills, MCP config
- Agents: ACP vs MCP, the review loop, review directories
- Design documents: the design-doc format and how to instruct agents
- Running and packaging: build, run, package, languages, configuration, phone view
- Architecture: how the Theia extension is organized
- llms.txt: the integration contract for agents
Requires Node.js 20+, Git and a C/C++ toolchain (Xcode command-line tools on macOS, build-essential on Linux).
make install # npm install + bundled extensions into plugins/
make start REPO=/path/to/repo # browser app on http://127.0.0.1:3000
make desktop REPO=/path/to/repo # desktop app
make dev # rebuild on change
make install-cli # `co-review` command running from this checkout
make package # installers in applications/electron/dist
make help # all targetsThe browser and desktop apps compile native modules for different runtimes; make browser and make desktop-build
switch between them, so build the one you run. Agent instructions (skills, commands, subagents, tool text) are
written once in prompts/: edit them there and run make prompts. There are no automated tests yet: changes are verified in the running
app and with scripted MCP and ACP clients against a local server. Releases are built by
.github/workflows/release.yml when a v* tag is pushed.
applications/ Theia browser and desktop apps (composition, electron-builder config)
extensions/review the review extension (common · node · electron-node · browser)
bin/ co-review CLI, install-cli.sh, review server mode, gen-prompts.mjs
prompts/ the agent prompts, written once; `make prompts` copies them everywhere
plugin/, .claude-plugin/ Claude Code plugin and its marketplace manifest
integrations/shared the Pi / Oh My Pi extension and slash commands
integrations/pi, omp Pi and Oh My Pi packages (harness adapter, co-reviewer agent)
docs/ guides (the source of the website's docs)
site/ website: Astro + Starlight (`cd site && npm run dev`), deployed from main
llms.txt integration contract for agents
See Architecture and Running and packaging for details.
MIT. Co-Review is built on Eclipse Theia and other open-source components under their own licenses; see third-party notices.