Introducing LiveReview: World's First Generally Available Risk-Aware Code Review System
In February, you helped git-lrc reach #3 Product of the Day on Product Hunt. Thank you.
git-lrc fixed one problem: engineers committing AI-written code they had not read. It put a review in front of every commit, right in the terminal.
As teams adopted it, a bigger problem showed up one step later, at the pull request.
AI made code cheap to write. Review stayed expensive. Every PR waited in the same queue, for the same few senior engineers. A renamed variable and a rewritten payment flow got the same amount of attention. Seniors became the bottleneck. They skimmed. Risky changes slipped through.
Today we are launching LiveReview: a risk-aware code review system built to fix exactly that.
Vote for LiveReview on Product Hunt →
If this problem is familiar, an upvote and a comment helps more engineering teams find this approach. It is the single best way to support this launch.
LiveReview auto-approving a low-risk change while routing a risky change to a human reviewer.
LiveReview auto-approves your safest 30-50% of pull requests
Every pull request gets a risk score. The lowest-risk 30-50% are approved automatically. The rest go to the right human, in the right order, ranked by how much they actually matter.
How LiveReview differs from other AI reviewers
Most tools in this space pick one of two jobs: find issues, or check style. LiveReview is built to be the layer that decides whether a human needs to look at all, and ranks what matters when they do.
Here is what actually changes when you compare LiveReview against CodeRabbit, Greptile, SonarQube, Claude Code review, GitHub Copilot review, and Cursor Bugbot, feature by feature, not by marketing claim:
- Auto-approves safe PRs. LiveReview approves the lowest-risk 30-50% of PRs under your policy; the rest go to a human. CodeRabbit offers this too, opt-in, when threads are resolved, checks pass, and risk is under your limit. Greptile's is beta, and only on a clean 5/5 review. SonarQube, Claude Code review, and Cursor Bugbot do not approve at all — a quality gate passes or fails, or a person has to click approve. Copilot has a public-preview approval, off by default, with undocumented criteria.
- Learns from your own production incidents and reverts. This is where LiveReview stands alone: every revert or incident retrains your organization's own model. None of the six alternatives are documented as feeding production outcomes back into the review itself.
- Lets you try a policy on past PRs first. Replay a draft auto-approve policy against your recent PRs before it goes live. Not documented for any of the other six tools.
- Reports an approval calibration. Approved vs. blocked per stage, override rate, and false-approve rate — a scorecard for the policy itself. Not documented elsewhere.
- Shows production impact in numbers. PRs approved without a human, and the false-approve rate — approved changes later reverted or tied to an incident. CodeRabbit reports bugs caught and merge time, not production outcomes. SonarQube reports code-quality metrics, not production outcomes.
- Blast radius of each change. A code graph scores how far each change reaches. CodeRabbit has blast-radius context on its Advanced plan. Greptile and SonarQube find ripple effects or taint paths without a blast-radius score. Claude Code and Copilot read surrounding code but don't score it.
- Summary decks and PR quizzes (Cognitive Coverage). A short slide-style summary of the review, and a quiz that checks the author actually understood the change. None of the six alternatives offer either.
- Ask for any chart or report, in plain language (Livi). CodeRabbit and SonarQube ship fixed dashboards and scheduled reports; Greptile's MCP data can be wired into a chart by your own coding agent. None let you just ask, in Slack or Teams, the way Livi does.
- Fair, predictable pricing. Fixed monthly bands by reviewed lines of code, unlimited users. CodeRabbit bills per seat ($24-72) plus $0.25 per file over the allowance. Claude Code review is token-billed, about $15-25 per review. Cursor Bugbot is usage-based, about $1-1.50 per review. Copilot and Cursor review are both billed per user on top of that.
- Source-available on GitHub, self-hostable, free to start. SonarQube has a Community Build; CodeRabbit, Greptile, Claude Code, Copilot, and Cursor Bugbot do not publish their source.
Most of the alternatives find issues and leave the approval decision to a person. LiveReview makes the "does a human need to look at this at all" decision itself, backs it with your own production outcome data, and only then prioritizes what's left for the humans who do look. See the full feature-by-feature comparison for every row.
The problem: reviews did not scale with AI
Most AI code review tools add more comments to the pull request. More comments is not the goal. Fewer incidents, fewer rollbacks, and less senior reviewer time are the goal. We measure LiveReview by production outcomes, not by comment count.
LiveReview follows the approach behind Meta's internal AI review system, RADAR: score every change for risk, fast-track the safe ones, and route the risky ones to the right reviewers. At Meta, this approach led to:
- 50× fewer production incidents
- 3× fewer rollbacks
- 35% faster reviews
LiveReview brings the same idea to any team, on any git provider, self-hosted and free.
How LiveReview scores risk
Every pull request gets one risk score, built from three signals:
- Semantic LLM analysis — what the change actually does, in plain language.
- A custom ML model — trained on your own production incidents, rollbacks, and overrides, not a generic dataset.
- Static graph-based codebase analysis — how far the change reaches through your call graph, and what it touches.
The loop runs like this:
- Track outcomes. Trace production incidents and rollbacks back to the commits and reviews behind them.
- Learn from the data. Combine those outcomes with LLM analysis, static checks, and ML signals into one risk score per change.
- Automate selectively. Auto-approve the lowest-risk 30-50% of changes. Choose a conservative, balanced, or aggressive policy. Risky or uncertain changes still go to a human.
- Keep improving. Track incidents, false approvals, and overrides, and tighten or loosen the policy as real data comes in.
The result: your reviewers stop reading every line of every diff, and start spending their full attention on the 50-70% of changes that actually carry risk.
Risk inside the diff, not just risk per PR
A PR-level score is not enough. A single pull request can mix a one-line change to an authorization check with three hundred lines of UI polish. LiveReview scores every hunk inside the diff for blast radius: how far a change reaches through your call graph, how much persistent state it touches, and how well it is tested.
A 3-line change to a shared auth check can outrank a 300-line UI tweak. Your reviewer's attention goes to the riskiest code first, not spread evenly across the diff.
| The exact math, not a black box | Every factor behind the score |
|---|---|
Two scores feed the ranking:
- Blast Radius — how many other places call this code, whether it writes to a database, and whether its callers sit in other, unrelated parts of the codebase.
- Review Priority — how many paths the logic can take, how deeply loops nest, how many other functions it calls into, and whether it has tests.
| Score badge, with full breakdown | The whole diff, ranked by risk |
|---|---|
Checkpoints at every stage, not just the PR
AI writes code faster than any human reviews it by hand. LiveReview gives you a checkpoint at every stage where that code could reach production, and you turn on only the stages that matter per repository:
| Stage | What happens |
|---|---|
| Commit | git lrc review checks your staged changes before the commit happens, in your terminal. |
| Before Push | LiveReview checks one last time before code leaves your machine. Skips are explicit and stay in the git log. |
| MR / PR | A full AI review posts as comments, with a Blast Radius and Review Priority score on every hunk. Works across GitHub, GitLab, Bitbucket, Gitea, and Azure DevOps. |
| CI / CD | A webhook triggers a review on every push. A CI/CD Gate, written as one jq rule, decides whether the result blocks the merge. |
| Scheduled Checks | Periodic sweeps catch drift in code nobody has touched recently. |
Not every repository needs the same depth. A throwaway repo is fine with commit-only checks. Payments, auth, and core infrastructure deserve the full harness: commit, push, PR, CI/CD, and scheduled, together.
Keeping engineers in touch with what AI wrote
A fast review pipeline still leaves one risk: engineers approving code they never really understood. Cognitive Coverage closes that gap.
- Summary decks — a 60-second slide summary of what changed, why it matters, and what risks were flagged, generated automatically for every review.
- PR quizzes — a short quiz, generated straight from the diff, before the change is committed. It takes under a minute, and it tells you exactly how much of the change a human actually understood, not just whether an AI reviewed it.
Every finding is also browsable in the Issue Navigator, filterable by severity and category, with a one-click send to your AI coding agent to fix.
Livi: ask your engineering data a question
LiveReview tracks every review against a 10-category, 100+ pattern risk taxonomy: reliability, correctness, performance, scalability, security, compliance, maintainability, architecture, developer experience, and cost. That data is useless locked inside a dashboard nobody opens. Livi is the assistant that makes it usable in plain English, on the web or in Slack, Teams, and Discord.
Ask Livi things like:
- "Is LiveReview adoption increasing across the org?"
- "Which repos are gaining or losing engineering velocity?"
- "Which files keep showing up with issues?"
- "How much does LiveReview cost us per day?"
Livi backs over 50 chart types across adoption, repository health, engineer activity, review quality, cost, and trust, so an engineering leader gets a real answer instead of a guess.
CI/CD Gates: your rule, not a preset
A generic "block on critical severity" checkbox never matches how a team actually weighs risk. CI/CD Gates let you write the exact condition in jq, against the real findings from a review, and wire it into any pipeline as one HTTP call.
A security-first team can block on any security finding at all. A fast-moving startup can block only on correctness and UX bugs, and let style debt through for now. Both are one jq expression against the same findings document, whether the review came from the web UI, git-lrc, CI/CD, or the API.
LiveReview is free and self-hostable
Run it on your own infrastructure. No seats, no per-review bill that climbs as your team grows.
We are launching LiveReview on Product Hunt today.
Vote for LiveReview on Product Hunt →
If this problem is familiar, an upvote and a comment is the single best way to help more engineering teams discover this approach.
Which 30% of your pull requests would you trust to auto-approve? Tell us in the Product Hunt comments.