[opensourcedex]

crit is a free, open source version control & collaboration project written in Go and released under MIT. It has 1,090 GitHub stars, 85 forks and 22 open issues, and was last pushed 21 hours ago. On this registry it ranks #24 of 30 tracked projects in Version Control & Collaboration, with 5 head-to-head comparisons available.

What is crit?

Crit is a local, single-binary review interface for agentic coding workflows that lets a developer comment directly on generated plans, code diffs, and frontend elements and send that feedback back to the coding agent.

What it is

Crit is a command-line tool written in Go and distributed under the MIT licence, published in the Developer Tools / Version Control & Collaboration category. It runs entirely on the developer's machine as one binary and produces a purpose-built review interface for each kind of output an agent generates. The README frames the problem plainly: for agents, plans and code are all the same thing, just text, but for humans, reviewing a generated plan and reviewing a running web application are two very different activities. Crit's answer is an adaptive UI, so the reviewer can point at the exact thing that is wrong and leave a comment for the agent to fix.

The concrete thing Crit replaces is reviewing agent output as undifferentiated text and pasting feedback back into a chat window. Instead of scrolling raw markdown in a terminal or describing a broken layout in prose, a reviewer opens the artifact in Crit, marks the line or element, and writes the comment in place. The feedback then travels back to the agent as a file the agent can read, which closes the loop without a human having to translate what they saw into words the agent can act on. It sits in the agentic-coding ecosystem alongside the coding agents themselves, integrating with them rather than replacing them.

Key capabilities

  • crit plan.md renders a markdown file with proper formatting and a review UI, so plans can be annotated line by line.
  • Running crit with no arguments auto-detects git changes and shows syntax-highlighted diffs for local review.
  • crit http://localhost:3000 proxies a running application and injects a review interface into it, so frontend elements can be commented on directly.
  • crit landing.html renders a static HTML artifact for review.
  • The /crit slash command, available in most integrations, automates the full loop: the agent launches Crit, waits for the review, and then acts on the feedback until the changes are approved.
  • Story mode adds a chaptered overview of a larger branch, PR, MR, or range review, with thematic chapters, a prologue, and a support bucket for noise, authored by the agent through crit story --prep and --story-file. The README is explicit that story mode is an explainer, not a reviewer.
  • Everything runs locally from a single binary, with no server component or external service required.

Who uses it and how

  • Developers working with Claude Code can install the integration through the plugin marketplace and drive reviews with the /crit command after any piece of work.
  • Teams using Cursor, GitHub Copilot, OpenCode, Codex, Gemini, Qwen, Hermes, Windsurf, Cline, Grok, Aider, or Pi can adopt Crit, because it works with any agent that can read a file and run a command.
  • Reviewers handling larger branches or pull requests run /crit-story to get a chaptered overview before line-by-line review, so they understand the shape of the change first.
  • Frontend and full-stack developers point Crit at a local dev server to review rendered UI rather than reading component diffs.
  • Individual developers can launch Crit manually in a terminal and paste the resulting prompt back into their agent when the work is finished.

Getting started

Install the binary with brew install crit, or use go install github.com/tomasz-tomczyk/crit/cmd/crit@latest, nix profile install github:tomasz-tomczyk/crit, or the Windows installer script from the GitHub releases. For Claude Code, add the plugin marketplace with claude plugin marketplace add tomasz-tomczyk/crit and then run claude plugin install crit@crit.

How it compares

The facts provided here name no paid products that Crit replaces, and no directly comparable tools in the same registry category. Crit therefore stands alone in this registry as a local agent-feedback review interface, and no licence, hosting, or cost comparison against named competitors can be made from the available information.

When to use it — and when not to

Crit is a good fit when work is already flowing through a coding agent and the bottleneck is the human review step, especially for plan review before implementation and for frontend review against a running dev server. A self-hoster does not need to operate a database, object storage, or SMTP, because Crit is a single local binary, but it does require an agent that can read a file and run a command, and it requires git in the repository for the auto-detection path. Anyone who needs a hosted, multi-user review platform with persistent accounts and server-side history should look elsewhere, since Crit's model is local and per-developer. Story mode is also explicitly an explainer rather than a reviewer, so it will not substitute for line-by-line review on large changes.

project readme (upstream, from github) — read inline

Crit

CI codecov Release License: MIT

Review and comment on plans, code diffs, frontend elements and send feedback directly to your agent.

Crit UI for "notification-plan.md" showing comment left on "Queue - Redis Streams, SQS, RabbitMQ" line saying "Just use SQS - we're in AWS"

Adaptive UI for each type of output

For agents, plans and code are all the same - it's just text, but for us, humans, reviewing generated plans and reviewing web application are two very different activities.

Crit adds a proper interface for each type of output and lets you point at the exact thing that is wrong and leave a comment for the agent to fix:

  • crit plan.md renders a markdown file with proper formatting and review UI
  • crit auto-detects git changes and shows syntax-highlighted diffs for local review.
  • crit http://localhost:3000 proxies your running app and adds a review interface to it
  • crit landing.html renders a static HTML artifact to review

Everything runs locally via one single binary.

Quickstart

1. Install Crit binary

Brew:

brew install crit
Also available via Go, Nix, Windows

Go:

go install github.com/tomasz-tomczyk/crit/cmd/crit@latest

Nix:

nix profile install github:tomasz-tomczyk/crit

Windows:

iwr https://github.com/tomasz-tomczyk/crit/releases/latest/download/crit-windows-amd64.exe -OutFile crit.exe

Note: Then move crit.exe somewhere on your PATH. ARM64 users: swap amd64 for arm64. WSL users: use the Linux binary instead.

Or download the latest release from GitHub.

2. Integrate with your agent

Claude Code:

claude plugin marketplace add tomasz-tomczyk/crit
claude plugin install crit@crit

Crit also works with Cursor, GitHub Copilot, OpenCode, Codex, Gemini, Qwen, Hermes, Windsurf, Cline, Grok, Aider, and Pi — any agent that can read a file and run a command. See integrations/ for all install methods and details.

3. Tell your agent to use crit

Most integrations include a /crit slash command that automates the full review loop. Agent launches Crit, waits for your review and acts on the feedback. Repeat the process until you approve the changes.

Here's a 2-minute demo walkthrough of plan review and branch review: Crit demo

Usage

The recommended way is to use /crit command with your agent after any piece of work - whether it wrote a plan or made some code changes. You can however, launch it in your terminal by yourself and paste the prompt when you finish to your agent.

crit                              # auto-detect changed files in your repo
crit plan.md                      # review a specific file
crit plan.md api-spec.md          # review multiple files
crit http://localhost:3000        # review a running dev server
crit landing.html                 # review a static HTML file

If talking to an agent, you can invoke the /crit command and optionally provide arguments like the above examples or the agent will try to launch the right thing based on the context of the conversation.

Story mode

For larger branch, PR, MR, or range reviews, story mode adds a chaptered overview of the diff — thematic chapters, a prologue, and a support bucket for noise — so you can understand the shape of the change before line-by-line review. It is an explainer, not a reviewer.

Recommended: invoke /crit-story (or $crit-story, /skill:crit-story, depending on your agent) after crit install . Your agent authors the story in-session via crit story --prep / --story-file. Only run it when you explicitly ask — agents will not infer it from a normal /crit review.

Alternative: crit story from the terminal uses your global agent_cmd (separate LLM spend). Generation is LLM-driven exploration — cost depends on change complexity more than raw file/diff size, and does not scale linearly. In our experience, complex PRs (~20–50 files, ~2k–5k lines) land around $1–$1.40 with Claude Opus 5. See the story mode guide for commands, custom prompts, JSON shape, and token-cost notes.

Live mode

crit live (or crit ) proxies a running dev server through Crit's review UI. Crit's iframe loads the app on a different origin/port than your browser tab, so host-scoped session cookies are not shared automatically. If the direct URL works but Crit shows a login page or hydration mismatch, forward the upstream cookies:

# one-off
crit live http://localhost:4000/dashboard --cookie "_crit_key=..."

# repeatable (Netscape jar or raw Cookie header lines)
crit live http://localhost:4000/dashboard --cookie-file .crit/live-cookies.txt

# reuse cookies from a Chrome session with remote debugging enabled
crit live http://localhost:4000/dashboard --cdp-url http://127.0.0.1:9222

Getting cookies: log in to the app in your browser, then copy the session cookie from DevTools (Application → Cookies), export a cookie jar, or start Chrome with --remote-debugging-port=9222 and pass --cdp-url so Crit reads cookies for the target origin automatically.

Config (global or project .crit.config.json; project overrides global):

{
  "live_cookie_file": ".crit/live-cookies.txt",
  "live_cdp_url": "http://127.0.0.1:9222"
}

Relative paths resolve from the repo root. Prefer a gitignored file under .crit/ over committing live_cookie inline. Run crit live --help for all flags.

crit status                       # show review file path and daemon status
crit resume                       # pick a previous review to reopen
crit stats                        # show lifetime review statistics
crit cleanup                      # delete stale review files

crit resume lists every review in ~/.crit/reviews, newest first, with its branch or files, directory, age, and open comment count. Choosing one reconnects to its daemon, or restarts the daemon in the directory the review came from when it has stopped — so you can resume a review from anywhere. Pass --list to print the list instead, or a session ID to skip the picker.

Features

Round-to-round diff

After your agent edits the file, Crit shows a split or unified diff of what changed - toggle it in the header.

Split view

Round-to-round diff - split view

Unified view

Round-to-round diff - unified view

Inline comments: single lines and ranges

Click a line number to comment. Drag to select a range. Comments are rendered inline after their referenced lines, just like a GitHub PR review.

Simple comments

Programmatic comments

AI agents can use crit comment to add inline review comments without opening the browser UI or constructing JSON manually:

crit comment src/auth.go:42 'Missing null check'
crit comment src/handler.go:15-28 'Error handling issue'
crit comment --session 839f3b4cd5d6 src/auth.go:42 'Target this review'
echo '[{"body":"Overall feedback"}]' | crit comment --session 839f3b4cd5d6 --json
crit comment --output ~/.crit src/auth.go:42 'comment'  # same as default (~/.crit/reviews/<key>/)
crit comment --output .crit src/auth.go:42 'comment'    # in-repo: .crit/reviews/<key>/
crit comment --clear   # remove the review file

Comments are appended to the review file (stored in ~/.crit/reviews/) and created automatically if it doesn't exist. Run crit status to see active review session IDs and paths. If multiple sessions match the same directory and branch, select one with --session on crit comment, crit comments, crit share, crit push, or crit pull; an unqualified command fails instead of guessing.

Share for Async Review

Want a second opinion before handing off to the agent? Click the Share button to upload your review and get a public URL anyone can open in a browser, no install needed. Each reviewer's comments are color-coded by author. Unpublish anytime.

You can also share directly from the CLI without starting the browser UI:

crit share plan.md                    # share files and print the URL
crit share plan.md --qr               # also print a QR code in the terminal
crit share plan.md --org acme         # share under an organization
crit share plan

readme truncated — read the full docs on github

Frequently asked questions

Is crit free to use?

crit is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does crit do?

Your feedback loop with the agent

What is crit written in?

crit is primarily written in Go. Its source is publicly available at https://github.com/tomasz-tomczyk/crit, and it has 1,090 GitHub stars.