Model or dataset
tomasz-tomczyk/crit avatar
tomasz-tomczyk/crit

Crit proxies your dev server in an iframe, so your session cookies stay behind

Your feedback loop with the agent. Integrate with your agent Claude Code: 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.

1,305 stars118 forksGoMIT

At a glance

What is it?
Crit is a single local Go binary that renders plans, git diffs, static HTML and a running dev server into a review interface, collects inline comments and hands them back to your coding agent. Its sharp edges are honest ones: the live mode needs your session cookies forwarded by hand, story mode spends your own LLM budget, and the integration files are hash-checked in CI.
Who is it for?
Crit suits a reviewer who wants to point at the exact line or the exact screen and have an agent act on it, and the round-to-round diff plus programmatic comment path are the parts that make that loop real.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • tomasz-tomczyk/crit1,305 ★ · +459
Star history
Repository2026-07-302026-11-15
tomasz-tomczyk/crit8461.3k

459 Stars in the last 108 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

One binary, four surfaces, and one agent precondition

The whole tool is one local binary with four entry shapes. crit plan.md renders a markdown file with formatting and a review interface, plain crit auto-detects git changes and shows syntax-highlighted diffs, crit http://localhost:3000 proxies a running application and adds review on top of it, and crit landing.html renders a static HTML artifact. The argument behind that split is stated plainly in the readme: to an agent, plans and code are both text, but reviewing a generated plan and reviewing a web application are different human activities. Integration follows the same minimalism. Claude Code gets two plugin commands, while Cursor, GitHub Copilot, OpenCode, Codex, Gemini, Qwen, Hermes, Windsurf, Cline, Grok, Aider and Pi are covered from an integrations directory on the stated condition that the agent can read a file and run a command.

Story mode is an explainer, and the cost figure is an experience report

For larger changes there is a second mode with a clear boundary drawn around it. Story mode adds a chaptered overview of the diff, with thematic chapters, a prologue and a support bucket for noise, and the readme is explicit that it is an explainer rather than a reviewer. Two invocation paths exist. The recommended one has the agent author the story in-session through a prep step, and agents are told not to infer it from a normal review, only to run it when you ask. The alternative runs from the terminal against your global agent command and bills separately. The cost claim deserves reading carefully: it is framed as experience, not measurement, with complex pull requests of roughly 20 to 50 files and 2k to 5k lines landing around one to one and a half dollars with Claude Opus 5, and an explicit warning that spend tracks change complexity rather than raw diff size and does not scale linearly.

Live mode asks you to hand over your own session cookies

Reviewing a running app is the one mode with a genuine security conversation attached. Crit loads your application in an iframe on a different origin and port from your browser tab, so host-scoped session cookies are not shared automatically. The documented symptom is specific: the direct URL works, Crit shows a login page or a hydration mismatch. Three fixes are offered, and each one is a way of moving credentials into the tool:

bash
crit live http://localhost:4000/dashboard --cookie "_crit_key=..."
crit live http://localhost:4000/dashboard --cookie-file .crit/live-cookies.txt
crit live http://localhost:4000/dashboard --cdp-url http://127.0.0.1:9222

The cookie file accepts a Netscape jar or raw Cookie header lines, and the cdp form reads cookies for the target origin from a Chrome started with remote debugging enabled. Both file paths can live in .crit.config.json as live_cookie_file and live_cdp_url, with project settings overriding global ones, and the guidance is to keep them in a gitignored file under .crit/ rather than committing a cookie inline.

Reviews accumulate in a home directory and reconnect to a daemon

Crit keeps state between sessions, and the commands for managing it are four. crit status shows the review file path and the daemon status, crit resume picks a previous review to reopen, crit stats prints lifetime review statistics, and crit cleanup deletes stale review files. The resume picker lists every review under ~/.crit/reviews newest first, with its branch or files, directory, age and open comment count, and choosing one either reconnects to its running daemon or restarts the daemon in the directory the review came from when it has stopped. Two flags trim the friction: --list prints the list instead of opening the picker, and passing a session ID skips the picker entirely. The practical consequence is that a review is a long-lived local object rather than a screenshot, and it keeps running between visits.

Five pinned JavaScript libraries are vendored into the binary

The web interface does not load scripts from a content delivery network, and the manifest shows how that is enforced. The dependency list is five exact versions with no ranges: the Pierre diff renderer, a diff-match-patch port, DOMPurify, markdown-it and mermaid. A copy-deps script places them under web/, and the make target named verify-assets fails if the vendored files differ, diffing the minified copies of dompurify, markdown-it, mermaid and diff-match-patch plus the whole web/pierre directory. Around that sits a provenance apparatus: an asset provenance file at the root, an asset budget file, and scripts to record and verify vendored assets with installed and npm variants. Front-end tests run through the Node test runner over web/__tests__, with a separate performance suite, and the dev-side tools are esbuild, eslint, shiki for highlighting and stylelint.

Integration files are hashed, and a stale hash fails the build

The per-agent plugin files are treated as generated content, which is unusual and sensible given how many agents it ships for. The make target verify-generate runs go generate across the module and then diffs cmd/crit/integration_hashes_gen.go, failing with the message that the file is stale and telling you to regenerate and commit. The build itself injects version, commit and date into the binary through linker flags, each with a fallback of dev, unknown or the current UTC date, so a local build is identifiable without a release. build-all cross-compiles six targets, darwin, linux and windows for both amd64 and arm64, which is exactly the pair the Windows install note tells ARM users to swap. The Go dependency list is small and tells you what the binary really does: a websocket library for the live review connection, yaml for front matter, image and text typesetting, terminal handling, and two QR code libraries.

Four install paths, and only one of them is an agent plugin

Installation splits between getting the binary and hooking it into an agent. The binary comes from Homebrew, from a Go install of the command path at its latest tag, from a Nix profile, or from a release asset, with the Windows route spelled out as a single PowerShell download of the windows-amd64 executable plus the caveats that it must be moved somewhere on your PATH, that ARM64 users swap amd64 for arm64, and that WSL users should take the Linux binary instead. The agent hook is separate and mostly documented outside the readme. Claude Code installs through a plugin marketplace add followed by a plugin install of crit from that marketplace, and most integrations also provide a slash command that automates the loop: the agent launches Crit, waits while you review, applies the feedback, and repeats until you approve.

Editorial conclusion

Crit suits a reviewer who wants to point at the exact line or the exact screen and have an agent act on it, and the round-to-round diff plus programmatic comment path are the parts that make that loop real. Before adopting it, decide whether you are willing to forward session cookies into a local review interface, budget separately for story mode since it bills your own agent, and read the asset provenance and integration hash checks to see what the binary is actually shipping. Anyone wanting a hosted review service or a shared, permissioned comment thread should look elsewhere.

Frequently asked questions

What can I review with Crit?

Markdown plans with crit followed by a file name, uncommitted git changes with plain crit, a running development server with crit followed by its URL, and a static HTML file. Several files can be passed in one invocation, and plain crit auto-detects what changed in the repository.

Which coding agents work with Crit?

Claude Code through two plugin marketplace commands, plus Cursor, GitHub Copilot, OpenCode, Codex, Gemini, Qwen, Hermes, Windsurf, Cline, Grok, Aider and Pi, on the stated condition that the agent can read a file and run a command. Per-agent install methods live in the integrations directory.

Why does Crit show a login page when reviewing my dev server?

The review interface loads your app in an iframe on a different origin and port, so host-scoped session cookies are not shared automatically. You can forward them with a cookie flag, a cookie file holding a Netscape jar or raw header lines, or a cdp-url pointing at a Chrome session started with remote debugging enabled.

How much does Crit story mode cost?

It spends your own agent budget. The in-session path has your agent author the story, while the terminal path uses your global agent command and bills separately. The documentation gives roughly one to one and a half dollars for a complex pull request of about 20 to 50 files and 2k to 5k lines with Claude Opus 5, and warns that cost tracks change complexity rather than diff size.

Does Crit fetch JavaScript from the internet while I review?

The review interface ships its libraries inside the binary. The manifest pins five dependencies at exact versions, a copy script vendors them under the web directory, and a make target fails when the vendored files differ from what the lockfile expects.

Where are Crit reviews stored and how do I reopen one?

Under a reviews directory in your home, newest first, each entry carrying its branch or files, directory, age and open comment count. The resume command reconnects to that review's daemon or restarts it in the original directory, while a list flag prints the entries and a session ID skips the picker.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/tomasz-tomczyk-crit.svg)](https://hysenlabs.com/projects/tomasz-tomczyk-crit)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/tomasz-tomczyk-crit.svg)](https://hysenlabs.com/projects/tomasz-tomczyk-crit)

Was this useful?