Alibaba open-sourced its internal AI code reviewer on 18 May 2026. Six months later it has 52,007 GitHub stars, 4,105 forks, and a new release — v1.13.10, published 15 November 2026 — that put it on GitHub Trending on 16 November. The tool is called Open Code Review, it runs from the command line as ocr, and it does one job: read your Git diff, send the changed files to a language model you choose, and leave precise line-level review comments. The code is free under the Apache-2.0 license. Running it is not free — you bring your own model API keys and pay that bill — and that distinction is where most of the viral posts about it go wrong.
The reason it matters is the design. Most AI reviewers are a general-purpose coding agent with a review prompt taped on. Open Code Review splits the job in two: deterministic engineering handles the steps that must not go wrong — which files get reviewed, how related files are grouped, which rules apply to each file — and an LLM agent handles the steps that need judgement, reading full files and searching the codebase for context. Alibaba says that split is why its reviews are more precise and use roughly one-ninth of the tokens of a general-purpose agent doing the same review. That token figure is the project's own benchmark claim, not an independent measurement, and this article keeps that label on it throughout.
What the viral posts get wrong
- "Battle-tested at Alibaba's scale" is Alibaba's own claim, not an independent benchmark. It is the repository's tagline and the README's account of its internal history — tens of thousands of developers, millions of defects found over two years. No independent party has verified those internal figures, and the benchmark the project publishes (AACR-Bench) is the project's own benchmark, cross-validated by 80+ senior engineers. Report it as project-reported, which this article does.
- It is NOT free to run. The code costs nothing (Apache-2.0), but every review calls a language model you configure yourself — OpenAI-compatible or Anthropic-compatible — and you pay that provider per token. Delegation mode avoids a second API key by using your coding agent's own model, but that model is itself a paid subscription. There is no free model included.
- It is a self-hosted enterprise tool, not a one-click app. You install a CLI, configure a model provider, hold API keys, and — for CI — wire up a workflow. Setup is measured in minutes for a single developer and in real engineering effort for a team. Anyone presenting it as "install and forget" is skipping the configuration.
- It does not replace human review. The project deliberately trades recall for precision: it would rather miss a real defect than flood you with false alarms. That is the right trade for a review bot, and the wrong basis for skipping human review.
The short version
- What it is: Alibaba's open-source AI code review CLI (
ocr), Apache-2.0, written in Go, created 18 May 2026. It reviews Git diffs and whole files with a hybrid of deterministic pipelines and an LLM agent. - How big: 52,007 stars and 4,105 forks on GitHub (checked 16 November 2026); latest release v1.13.10 (15 November 2026); GitHub Trending on 16 November 2026.
- What it costs: $0 for the tool; the model bill is yours. You configure your own LLM provider and API keys, and pay per token. Delegation mode uses your coding agent's model instead.
- What it checks: built-in multi-language rules for null-pointer errors, thread-safety, XSS, SQL injection and more, plus agent-driven review with full-file context.
- The honest caveat: the headline benchmark figures (higher precision and F1, ~1/9 of the tokens versus Claude Code) come from the project's own benchmark. Precision is higher; recall is deliberately lower.
Related reading
Developer CLI tools: uv: the Python Package Manager That Replaced pip for Most Developers · CLI guides: Gemini API CLI: the Complete Guide · GitHub workflows: Muse SSH/FTP Blocked? The GitHub Deploy Route · Tools: browse all free tools on Asad Webs (no code-review tool exists on the site yet, so there is no direct tool link for this story).
What Open Code Review is
Open Code Review is an AI-powered code review CLI tool from Alibaba Group, published as open source under the Apache-2.0 license. It started life as Alibaba's internal official AI code review assistant. According to the README, it served tens of thousands of developers inside the company over two years and identified millions of code defects before Alibaba incubated it into an open-source project for the community. Those internal figures are Alibaba's own account — the repository does not publish the underlying data — but the public trajectory since the open-source release is independently checkable: created 18 May 2026, 52,007 stars and 4,105 forks by 16 November 2026, and a release cadence that reached v1.13.10 on 15 November 2026.
The tool reads Git diffs, sends the changed files to a configurable language model through an agent with tool-use capabilities, and generates structured review comments with line-level precision. The agent is not limited to the diff: it can read full file contents, search the codebase, and inspect other changed files for context, which is how it aims to produce deep reviews rather than surface-level diff feedback. Beyond diff review, the ocr scan command reviews entire files, which is designed for auditing an unfamiliar codebase or a directory that has no meaningful diff.
It is written in Go, runs on Windows, macOS and Linux, and needs Git 2.41 or newer, because it relies on Git for diff generation, code search and repository operations. The project also carries an OpenSSF Best Practices Gold badge, and its documentation and official website live at open-codereview.ai.
Why it exploded: 52,000 stars in six months
The numbers explain the attention. A repository created on 18 May 2026 reaching 52,007 stars by 16 November 2026 means roughly 52,000 stars in under six months — about 280 stars a day on average, with the growth concentrated in bursts around releases and trending appearances. The latest burst came with v1.13.10 on 15 November 2026, which landed the project on GitHub Trending the next day. For comparison, that star count puts it in the same league as established developer tools that have been public for years, achieved in months.
Three forces are driving it. First, the author is Alibaba, and an internal tool from one of the world's largest engineering organisations carries a credibility that an unknown startup's launch does not. Second, the timing: AI code review is the most crowded corner of developer tooling in 2026, and every team is deciding whether review should live in the editor, in the pull request, or in CI. Third, the architecture pitch is genuinely different from the competition's. Most AI reviewers are a prompt on top of a general agent; Open Code Review's pitch is that review needs hard engineering constraints around the agent, not just a better prompt. That argument resonates with engineers who have watched a general-purpose agent skip files on a large changeset or report an issue at the wrong line number.
None of that makes the star count a quality measurement. Stars are bookmarks as much as endorsements, and a trending spike says more about attention than about how many teams run the tool daily. The honest reading is narrower: a lot of developers found the idea interesting enough to star, and the project ships often enough to keep reappearing.
What the viral posts get wrong
The corrections box at the top of this article is the short version; this section is the evidence behind it. The most repeated line about Open Code Review is "battle-tested at Alibaba's scale", which is the repository's own description: "Secure, fast, efficient, battle-tested at Alibaba's scale." It is a tagline, not a test result. The supporting detail in the README — tens of thousands of developers, millions of defects over two years — is Alibaba's account of its internal use. It is plausible, it is consistent with Alibaba's size, and it is unverifiable from outside the company. Treat it as the author's claim about their own history, not as independent proof.
The benchmark needs the same treatment. AACR-Bench is a real dataset — 50 popular open-source repositories, 200 real pull requests, 10 programming languages, 1,505 annotated ground-truth issues, cross-validated by 80+ senior engineers — and it is published on Hugging Face for anyone to inspect. But it is the project's own benchmark, built by the same team that built the tool, and the headline results (higher precision and F1 than Claude Code with the same underlying model, roughly one-ninth of the tokens, faster reviews) are the project's own measurements. The README is transparent about the trade-off that makes those numbers possible: recall is lower than general-purpose agents, deliberately, because the design favours precision over noise.
The cost misunderstanding is the most practical one. "Open source" describes the license, not the running cost. Open Code Review contains no model of its own. Every review calls a model you configure — an OpenAI-compatible or Anthropic-compatible provider — and that provider bills you per token. A team reviewing hundreds of pull requests a week will have a real, recurring model bill, and the "~1/9 of the tokens" claim matters precisely because it shrinks that bill. Delegation mode changes who pays, not whether anyone pays: it lets your coding agent (Claude Code, Codex, Cursor or Kimi Code) perform the review with its own model, so no separate OCR API key is needed — but the host agent's subscription is still the thing being billed. And the setup is real work for teams: a single developer can be reviewing in minutes, but a team needs provider configuration, API key management, CI workflows and custom rules. That is normal for an enterprise tool. It is only a flaw in the telling when a post presents a self-hosted CLI as if it were a browser extension you switch on.
How it works: deterministic engineering × agent hybrid
The core idea is a division of labour. Review steps that must not go wrong are handled by deterministic engineering — code, not the language model — and the agent is used only where dynamic decisions and dynamic context retrieval are needed. The README is explicit that this is a response to the failure modes of general-purpose agents used for review: incomplete coverage on large changesets, position drift where reported issues don't match the actual code location, and unstable quality when small prompt changes swing the output.
On the deterministic side, four mechanisms do the constraining. Precise file selection decides exactly which files need review and which should be filtered, so no important change is missed. Smart file bundling groups related files into a single review unit — the README's example is bundling message_en.properties with message_zh.properties — and each bundle runs as a sub-agent with isolated context, a divide-and-conquer strategy that stays stable on very large changesets and naturally supports concurrent review. Fine-grained rule matching pairs review rules to each file's characteristics, keeping the model's attention focused and removing information noise at the source. And independent comment-positioning and comment-reflection modules systematically improve both the location accuracy and the content accuracy of the AI's feedback.
On the agent side, the strengths are concentrated in two places: scenario-tuned prompts, meaning prompt templates deeply optimised for code review that aim to improve effectiveness while reducing token consumption, and a scenario-tuned toolset distilled from deep analysis of tool-call traces in large-scale production data — call frequency distributions, per-tool repetition rates, and the impact of new tools on the overall call chain.
In practice the flow is: your Git diff goes in, the deterministic pipeline selects and bundles files and resolves the rules, the agent reads full files and searches the codebase for context, and the positioning and reflection modules check the comments before they are delivered as structured, line-level feedback. That pipeline is also why the project claims its token usage is low: the deterministic stages filter noise before the model ever sees it, so the model is not spending tokens reading files that don't matter.
What it actually checks
The built-in rule set covers the defect classes the repository advertises: null-pointer errors (NPE), thread-safety problems, cross-site scripting (XSS) and SQL injection, across multiple languages. These are deterministic rules matched to each file's characteristics, so a Java file gets the rules that apply to Java and a Go file gets the rules that apply to Go, rather than the model being asked to remember every language's pitfalls from its prompt. The README also documents custom review rules with path filtering, so a team can add its own checks — for example, rules that only apply to a payments directory — and the docs cover that configuration in the Review Rules section.
Beyond the rules, the agent review looks for the things rules can't express: logic errors, wrong API use, missing error handling, and inconsistencies between the changed files and the rest of the codebase. Because the agent can read full files and search the codebase, it can catch a change that is correct in isolation and wrong in context — a function renamed in one file but still called by its old name in another, or a new validation rule that duplicates one that already exists two directories away.
The benchmark, honestly
AACR-Bench is the dataset behind the headline numbers: 50 popular open-source repositories, 200 real pull requests, 10 programming languages, and 1,505 annotated ground-truth issues, cross-validated by more than 80 senior engineers. The dataset is published on Hugging Face under Alibaba-Aone, so anyone can inspect the ground truth instead of taking the project's word for it. That openness is a genuine point in its favour — many vendor benchmarks are numbers on a slide with no data behind them.
The results the project reports from that benchmark are: compared with general-purpose agents (Claude Code is the named comparison) using the same underlying model, Open Code Review achieves significantly higher precision and F1, consumes only about one-ninth of the tokens, and completes reviews faster. Precision here means the proportion of reported issues that are real defects — higher is fewer false alarms to triage. F1 is the harmonic mean of precision and recall, the project's preferred single number for overall review quality. Recall — the proportion of real defects found — is lower than general-purpose agents, and the README says that is a deliberate trade-off favouring precision over noise.
That trade-off deserves a plain reading. A reviewer that reports fewer, more accurate issues is easier to live with in a busy pull request queue: developers actually read its comments instead of learning to ignore them. But it also means some real defects slip through. The right mental model is a first-pass filter that catches the clear defects cheaply, with human reviewers still responsible for architecture, intent and judgement calls.
Two caveats belong on the numbers themselves. First, the benchmark is the project's own: the team that built the tool built the test and ran the comparison. Cross-validation by 80+ senior engineers and a published dataset are real mitigations, but neither turns a vendor benchmark into an independent evaluation. Second, "~1/9 of the tokens" is a ratio against a general-purpose agent on the same review — relative efficiency, not a promise about your absolute token bill, which depends on your model, changeset size and settings.
Setup, step by step
Setup has three stages: install, configure a model, and run your first review. The whole thing is a CLI workflow, and the commands below come from the README. Keep your API keys out of shared files and screenshots.
1. Check the prerequisite. You need Git 2.41 or newer, because the tool relies on Git for diff generation, code search and repository operations. Check yours first:
git --version
2. Install the CLI. The recommended route is npm, which installs the ocr command globally. The README also documents an install script, a GitHub Release binary, and building from source if npm is not your route.
npm install -g @alibaba-group/open-code-review
3. Configure a model provider. You must configure a language model before reviewing code, unless you use Delegation Mode (step 5). The interactive commands walk you through provider selection, API key entry and model choice, then automatically test connectivity:
ocr config provider # Select a built-in provider or add a custom one ocr config model # Pick a model for the active provider
One thing the README states explicitly and many posts skip: when OCR calls the model — ocr review, the /open-code-review:review command and the open-code-review skill — it uses OCR's own provider configuration, not your Claude Code Team or Pro subscription login. Authentication requirements depend on the provider you choose.
4. Run your first review. From inside your project, review all staged, unstaged and untracked changes:
cd your-project ocr review
5. Try Delegation Mode if you already pay for a coding agent. In delegation mode your AI coding agent performs the review itself — OCR handles file selection and rule resolution, and no LLM configuration or credentials are needed in OCR. The host agent's configured model and authentication are used instead:
ocr delegate preview ocr delegate rule src/main.go src/handler.go
Delegation mode is the cheapest way to try the tool if you already have Claude Code, Codex, Cursor or Kimi Code, because it adds no second model bill. The trade is that the review then runs on the host agent's model and configuration rather than OCR's own provider setup.
The four ways to run a review
Open Code Review has four review modes, and picking the right one is mostly about what you are looking at. Workspace mode (ocr review with no arguments) reviews all staged, unstaged and untracked changes in your working tree — the mode you use while you are still writing code. Branch-range mode (ocr review --from main --to feature-branch) reviews a feature branch's changes since it diverged from main, using merge-base mode; this is the mode for a pre-push check or a pull-request-style review of a whole branch. Single-commit mode (ocr review --commit abc123) reviews one commit, which is useful for auditing a specific change after the fact.
The fourth mode is different in kind: ocr scan reviews entire files instead of a diff, so it needs no Git history at all. Run it on the whole repository (ocr scan) or on a directory or specific files (ocr scan --path internal/agent). That is the mode for auditing an unfamiliar codebase, onboarding onto a legacy service, or checking a directory that has no meaningful diff to review. Interrupted reviews can be resumed — ocr session list shows sessions, and --resume <session-id> picks one back up for both range and scan reviews.
For automation, results can be saved as JSON (ocr review --format json --output result.json), which the README recommends for AI host agents consuming the output. And for teams, the CI/CD integration covers GitHub Actions, GitLab CI, GitFlic CI and Gerrit, with a Session Viewer for browsing and replaying review sessions in the browser and OpenTelemetry integration for observability.
Real use cases
The most natural home for Open Code Review is the pull request queue of a team that already reviews code and wants the first pass done before a human opens the diff. Wired into CI through GitHub Actions or GitLab CI, it comments on changes with line-level precision while the human reviewer is still reading the description. The deterministic file selection matters here: on a large pull request, a general-purpose agent may quietly skip files; OCR's pipeline is designed to cover the changeset and to bundle related files so the review stays coherent.
The second use case is the solo developer or small team that can't afford a dedicated reviewer for every change. Running ocr review before pushing is a cheap second pair of eyes, and because the tool is free, the only cost is the model tokens for that review. For a developer already paying for Claude Code or Cursor, delegation mode makes that second pair of eyes nearly free at the margin, since it uses the model subscription already in place.
The third use case is auditing unfamiliar code. ocr scan exists for exactly this: point it at a directory you inherited, a vendored library you need to trust, or a legacy service nobody on the team wrote, and get a structured list of issues with file and line references. That is also the mode that makes sense for a security-minded pass over a specific area — a payments directory, an authentication module — where the built-in rules for injection and cross-site scripting do their most useful work.
The fourth is the enterprise case the tool was built for: a large organisation standardising review across many repositories, with custom rules per path, session replay through the Session Viewer, and telemetry through OpenTelemetry to watch review latency and volume. That is where the "battle-tested at Alibaba's scale" story is most relevant — not as proof, but as a description of the environment the tool was shaped by: many repositories, many developers, and a review queue that cannot tolerate noise.
Limitations — the honest list
Start with the recall trade-off, because it is the one the project states itself: Open Code Review finds a smaller share of real defects than a general-purpose agent, deliberately, in exchange for fewer false alarms. If your priority is catching everything — a security audit, a pre-release sweep — a high-precision reviewer is the wrong primary tool, and you should pair it with something that optimises for coverage.
Second, the model bill. The tool is free; the reviews are not. Token costs scale with changeset size and review frequency, and the "~1/9 of the tokens" claim is relative to a general-purpose agent, not a cap on your spending. A team that wires it into CI on every push without thinking about when reviews trigger will get a bill that surprises them. Review rules, path filtering and trigger discipline are the controls for that.
Third, setup is real work for teams. A single developer can be reviewing in minutes; a team needs provider configuration, API key management, CI workflows, custom rules and a decision about who acts on the comments. The documentation covers all of it, but it is engineering effort, not a toggle.
Fourth, it does not run your code, does not know your team's conventions until configured, and its review quality depends on the model you choose. A weak or cheap model will produce weak reviews no matter how good the pipeline around it is. The project is also young as an open-source project: created in May 2026, it is shipping fast (v1.13.10 by mid-November), which is a sign of life and also a sign that interfaces and defaults can still change. Language coverage follows the rule set too — a team in a niche stack should check the rules cover their language before committing, rather than assuming multi-language means every language equally.
Security and privacy
The central privacy fact is architectural: your code leaves your machine. Open Code Review sends changed files to a language model provider you configure, so your source code is transmitted to that provider's API under that provider's terms. For most teams that is normal — it is how every hosted AI coding tool works — but it has consequences worth stating plainly. Do not point it at a repository containing secrets, credentials, customer data or proprietary code you are not permitted to share with a third-party model provider, and check your provider's data-retention terms before the first review, not after. The README's configuration docs cover custom providers, which is the route for teams that need their model traffic to stay inside a specific boundary.
On the install side, the usual hygiene applies. The npm package is @alibaba-group/open-code-review under the Alibaba Group scope — install exactly that name, and be wary of lookalike package names. If you use the install script route instead of npm, read the script before running it. API keys go in the tool's configuration or environment variables, never in a shared file, a screenshot, or a repository. The project itself carries an OpenSSF Best Practices Gold badge, which speaks to its own development practices, not to how your code is handled once it reaches a model provider.
Open Code Review vs the alternatives
Three options cover most teams' real choices: Open Code Review itself, a general-purpose coding agent doing reviews, and GitHub's own Copilot code review. The table compares them on the facts verified for this article. The benchmark figures in the Open Code Review column are the project's own, as labelled throughout.
| Open Code Review | General-purpose agent (Claude Code, Codex, Cursor) | GitHub Copilot code review | |
|---|---|---|---|
| What it is | Open-source CLI (ocr), Apache-2.0, built for review only | General coding agent with review prompts or skills | GitHub's built-in pull-request reviewer |
| What you pay | $0 for the tool; your own LLM API bill per token | Paid agent subscription (e.g. Claude Code Team/Pro) | Paid Copilot plan; review effort levels cost roughly $0.25 (Lite), $1.50 (Balanced) or $10 (Max) per review, per GitHub's own rough guide |
| Where it runs | Your machine or CI (GitHub Actions, GitLab CI, GitFlic CI, Gerrit) | Your machine, editor or terminal | On GitHub, in the pull request; runs in an ephemeral environment via GitHub Actions |
| Review method | Deterministic pipeline (file select, bundling, rule matching) + LLM agent; positioning and reflection checks | Language-driven agent with review skills; no hard constraints on coverage or positioning | Agentic review with severity labels (High/Medium/Low) and suggested changes you apply in clicks |
| Review scope | Diffs (workspace, branch, commit) and full-file scan; JSON output for automation | Whatever you point it at; coverage can be incomplete on large changesets (the README's own critique) | Pull requests; also uncommitted changes in VS Code; usually under 30 seconds per review |
| Known trade-off | Lower recall by design — fewer false alarms, some real defects missed | Higher recall, more noise; quality varies with prompt wording | Lives inside GitHub only; re-reviews can repeat dismissed comments |
Frequently Asked Questions
Is Open Code Review really free?
The tool is free — Apache-2.0, no paid tier, no licence fee. Running it is not free: every review calls a language model you configure, and that provider bills you per token. Delegation mode uses your coding agent's model instead, so there is no second API key, but the host agent's subscription is still the thing being paid for.
What does "battle-tested at Alibaba's scale" actually mean?
It is Alibaba's own description of the tool's history: an internal assistant that served tens of thousands of developers and found millions of defects over two years before being open-sourced. Those internal figures are the company's account and are not independently verified. The public, checkable facts are the release cadence, the star count and the published benchmark dataset.
How do I install it?
Install the CLI with npm install -g @alibaba-group/open-code-review, which provides the ocr command. You need Git 2.41 or newer. Then run ocr config provider and ocr config model to choose a model, and ocr review inside your project. An install script, a GitHub Release binary and building from source are also documented in the README.
Can it review code without a Git diff?
Yes. ocr scan reviews entire files instead of a diff — run it on the whole repository or on a directory or specific files with --path. It needs no Git history, which makes it the right mode for auditing an unfamiliar codebase or a directory with no meaningful diff.
Does it work with Claude Code, Cursor or Codex?
Yes, two ways. Plugins and skills exist for Claude Code, Codex, Cursor, Kimi Code and OpenCode, and there is a portable agent skill for skill-compatible agents. Separately, Delegation Mode lets your coding agent perform the review itself using its own model, so no separate OCR API key is needed — OCR handles file selection and rule resolution.
Should it replace human code review?
No. It is designed as a precise first pass: higher precision, deliberately lower recall, so it reports fewer issues and misses some real ones. Use it to clear the obvious defects cheaply and keep human reviewers for architecture, intent and judgement calls. A clean OCR review is not proof that code is correct.
Sources
- GitHub — alibaba/open-code-review (README, license, install, features, benchmark): https://github.com/alibaba/open-code-review — checked 16 November 2026; 52,007 stars, 4,105 forks, Apache-2.0, created 18 May 2026, latest release v1.13.10 (15 November 2026)
- Open Code Review — official website: https://open-codereview.ai/ — checked 16 November 2026
- AACR-Bench dataset (the project's review benchmark — 50 repositories, 200 pull requests, 10 languages, 1,505 annotated issues): https://huggingface.co/datasets/Alibaba-Aone/aacr-bench — checked 16 November 2026
- GitHub Docs — Using GitHub Copilot code review (effort levels, rough per-review costs, review flow): https://docs.github.com/en/copilot/how-tos/use-copilot-agents/request-a-code-review — checked 16 November 2026
Note on sources not linked: the project's documentation pages under open-codereview.ai/docs/ (quickstart, installation, configuration, CI/CD) returned 404 to this machine on two checks, and the npm package page for @alibaba-group/open-code-review returned 403 on two checks, so neither is linked — the install and configuration commands in this article come from the README itself, which returned 200. No URL has been guessed.
Related reading: uv: the Python Package Manager That Replaced pip for Most Developers · Gemini API CLI: the Complete Guide · Muse SSH/FTP Blocked? The GitHub Deploy Route




Be the first to share a useful question or thought.