Hello, I'm Maneshwar, and I'm building LiveReview — a blast-radius aware AI code review built for your business-critical systems. Star us to help devs discover the project, give it a try, and share your feedback to help improve the product.

Back in February, a lot of you upvoted git-lrc and pushed it to #3 Product of the Day on Product Hunt.

Thank you, genuinely.

git-lrc was built for one specific problem: people committing AI-written code they had never actually read.

It put a review in front of every commit, right in the terminal.

Teams picked it up.

And then the problem moved one step to the right, to the pull request.

Writing code got cheap. Reviewing it did not.

Every PR lands in the same queue and waits for the same handful of senior engineers.

A renamed variable and a rewritten payment flow get the same few minutes of attention.

The seniors turn into the bottleneck, they start skimming, and the risky stuff slips through.

So today we're launching LiveReview, a risk-aware code review system built for exactly this.

Check out LiveReview on Product Hunt →

If this sounds like your team, an upvote and a comment there is the best way to help other teams find it.

Up to half your PRs, approved without waiting on anyone

LiveReview gives every pull request a risk score.

The safest 30-50% get approved automatically.

Everything else goes to the right reviewer, sorted so the changes that matter most sit at the top.

How it's different from other AI reviewers

Most AI review tools do one of two things: find issues, or nitpick style.

LiveReview sits one level above that. It decides whether a human needs to look at a PR at all, and when one does, it tells them where to look first.

We compared it against CodeRabbit, Greptile, SonarQube, Claude Code review, GitHub Copilot review and Cursor Bugbot, going by their docs rather than their landing pages:

• Auto-approval of safe PRs. LiveReview approves the lowest-risk 30-50% under a policy you set. CodeRabbit can do this too, as an opt-in, once threads are resolved, checks pass and risk is under your limit. Greptile's version is in beta and only fires on a clean 5/5 review. Copilot has a public-preview approval that's off by default, with criteria they don't document. SonarQube, Claude Code review and Cursor Bugbot don't approve at all: either a quality gate passes or fails, or someone clicks approve.
• Learning from your incidents and reverts. Every revert or incident retrains your org's own LiveReview model. None of the other six document feeding production outcomes back into review.
• Trying a policy on old PRs first. You can replay a draft auto-approve policy against recent PRs before turning it on. Nobody else documents this.
• A scorecard for the policy itself. Approved vs. blocked per stage, override rate and false-approve rate. Also not documented anywhere else.
• Production impact in numbers. How many PRs went through without a human, and how many of those were later reverted or tied to an incident. CodeRabbit reports bugs caught and merge time. SonarQube reports code-quality metrics. Neither reports what happened in production.
• Blast radius per change. A code graph scores how far each change reaches. CodeRabbit has blast-radius context on its Advanced plan. Greptile and SonarQube trace ripple effects or taint paths but don't score them. Claude Code and Copilot read the surrounding code without scoring it.
• Summary decks and PR quizzes. A slide-style recap of the review, and a quiz that checks the author understood their own change. None of the six offer either.
• Charts and reports on request, through Livi. CodeRabbit and SonarQube have fixed dashboards and scheduled reports. Greptile exposes data over MCP that your own coding agent can chart. None of them let you just ask in Slack or Teams.
• Predictable pricing. Fixed monthly bands based on reviewed lines of code, with unlimited users. CodeRabbit is $24-72 per seat plus $0.25 per file past the allowance. Claude Code review is billed by tokens, roughly $15-25 a review. Cursor Bugbot is usage-based, about $1-1.50 a review. Copilot and Cursor also charge per user on top.
• Source on GitHub, self-hostable, free to start. SonarQube has a Community Build. CodeRabbit, Greptile, Claude Code, Copilot and Cursor Bugbot don't publish their source.

The short version: most tools find issues and leave the approve button to a person.

LiveReview makes that call itself, grounds it in your own production data, and only then ranks what's left for the humans.

Every row is spelled out in the full comparison.

Reviews didn't scale with AI

The usual answer from AI review tools is more comments on the PR.

But nobody's goal is more comments.

The goal is fewer incidents, fewer rollbacks, and less senior time spent on diffs that never needed it.

That's what we measure LiveReview against.

The approach comes from Meta's internal review system, RADAR, described in Automating Low-Risk Code Review at Meta: score every change for risk, fast-track the safe ones, and send the risky ones to the people who know that code.

At Meta, that got them:

• 50× fewer production incidents
• 3× fewer rollbacks
• 35% faster reviews

LiveReview takes the same idea to any team and any git provider, self-hosted and free.

How the risk score works

Each PR gets one score, built from three signals:

1. LLM analysis reads the change and works out what it actually does.
2. A custom ML model learns from your own incidents, rollbacks and reviewer overrides, not someone else's dataset.
3. Graph-based static analysis checks how far the change travels through your call graph and what it touches.

Around that score, there's a loop:

flowchart LR
    A[Production incidents and reverts] --> B[Trace back to commits and reviews]
    B --> C[Retrain your risk model]
    C --> D[Score new PRs]
    D --> E{Below your threshold?}
    E -->|yes| F[Auto-approve]
    E -->|no| G[Human review, riskiest first]
    F --> H{False approve?}
    G --> A
    H -->|yes| A
    H -->|no| I[Calibration scorecard]
    I -->|tighten or loosen| E

    classDef decision fill:#f4d35e,stroke:#b8991f,color:#1a1a1a
    classDef signal   fill:#ff9a5c,stroke:#b8642c,color:#1a1a1a
    classDef model    fill:#9d8cff,stroke:#5b4bcc,color:#1a1a1a
    classDef safe     fill:#5ee6c8,stroke:#1f9c86,color:#1a1a1a
    classDef human    fill:#6ea8ff,stroke:#2f6bc4,color:#1a1a1a

    class E,H decision
    class A,B signal
    class C,D,I model
    class F safe
    class G human

1. Track outcomes. Incidents and rollbacks get traced back to the commits and reviews that let them in.
2. Learn from them. Those outcomes join the LLM, static and ML signals in a single risk score.
3. Automate carefully. The lowest-risk 30-50% get auto-approved under a conservative, balanced or aggressive policy. Anything risky or uncertain still goes to a person.
4. Keep adjusting. Watch incidents, false approvals and overrides, and tighten or loosen the policy as the data comes in.

Your reviewers stop reading every line of every diff.

Their full attention goes to the 50-70% of changes that actually carry risk.

Risk inside the diff, not just per PR

One score per PR is too blunt.

A single PR can hold a one-line change to an auth check next to three hundred lines of UI polish.

So LiveReview scores every hunk for blast radius: how far it reaches through the call graph, how much persistent state it touches, and how well it's tested.

That's how a 3-line change to a shared auth check ends up ranked above a 300-line UI tweak.

The exact math, no black box	Every factor behind the score

The ranking comes from two numbers:

• Blast Radius: how many places call this code, whether it writes to a database, and whether those callers live in unrelated parts of the codebase.
• Review Priority: how many paths the logic can take, how deep the loops nest, how many other functions it calls, and whether it's tested.

Score badge, with full breakdown	The whole diff, ranked by risk

A checkpoint at every stage

AI writes code faster than anyone can review it by hand.

So LiveReview puts a checkpoint at every stage where that code could make its way to production, and you pick which ones each repo gets:

A throwaway repo is fine with just commit checks.

Payments, auth and core infra should get all five.

Keeping engineers in the loop on AI code

Even a fast pipeline leaves one gap: someone approving code they never really understood.

Cognitive Coverage is how we close it.

Summary decks.
Every review comes with a 60-second slide summary of what changed, why it matters and what got flagged.

PR quizzes.
A short quiz built from the diff, taken before the change is committed. It takes under a minute and shows how much of the change a human actually understood, not just whether an AI looked at it.

Every finding also shows up in the Issue Navigator, filterable by severity and category, with one click to send it to your coding agent for a fix.

Livi: ask your engineering data anything

Every review gets tracked against a risk taxonomy of 10 categories and 100+ patterns: reliability, correctness, performance, scalability, security, compliance, maintainability, architecture, developer experience and cost.

That data doesn't help anyone sitting in a dashboard nobody opens.

Livi is the assistant that lets you ask about it in plain English, on the web or in Slack, Teams and Discord.

For example:

• "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?"

It can draw 50+ chart types across adoption, repo health, engineer activity, review quality, cost and trust, so engineering leads get an actual answer instead of a guess.

CI/CD gates you write yourself

A "block on critical severity" checkbox never quite matches how a real team thinks about risk.

With CI/CD Gates, you write the condition in jq against the actual findings from a review, and hook it into any pipeline with one HTTP call.

A security-first team might block on any critical or security finding:

(.counts.by_severity.critical > 0) or (.counts.by_category.security > 0)

A startup moving fast might only block on correctness and UX bugs and let style debt wait.

Either way it's one expression over the same findings document, whether the review came from the web UI, git-lrc, CI/CD or the API.

Free and self-hostable

Run LiveReview on your own infrastructure.

No seats, and no per-review bill that grows with your team.

We're live on Product Hunt today.

Check out LiveReview on Product Hunt →

If this problem sounds familiar, an upvote and a comment go a long way in helping more teams find it.

And I'm curious: which 30% of your PRs would you trust to auto-approve?

Tell me in the comments here or on Product Hunt.

Your team's attention is limited, and the deluge of AI-generated code is making it harder to keep production secure and reliable without slowing you down.

I'm building LiveReview, a blast-radius aware AI code review built for your business-critical systems.

Instead of presenting every diff with equal emphasis, LiveReview scores each change by blast radius — how far its impact reaches through your call graph — so you can focus attention where it actually matters.

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

HexmosTech / LiveReview

Risk-Aware AI Code Review for Business-Critical Systems

LiveReview Upvote us on Product Hunt →

     

LiveReview: Risk-Aware AI Code Review for Business-Critical Systems

LiveReview is built for engineering teams that ship often, but also care about keeping production stable for customers. It approves some 40-50% of low-risk changes automatically, and it gives your team the tools to handle the rest:

• Understand risky changes faster.
• Fix problems in those changes, with human attention directed to the work that needs it.
• Enforce your engineering standards.
• Learn from production outcomes, such as incidents, rollbacks, and queue wait times.
• Improve the review process over time and make it more efficient.
• Connect to the major engineering tools that your team already uses.

Auto-Approve: Ship the Safe 50% Without a Human

Auto-Approve Upto 50% of Your Pull Requests, Safely. Risk scoring decides which MRs/PRs are safe enough to ship without a human, so your team only spends review time on risky and critical changes.

…

View on GitHub

Click below to try LiveReview with your codebase: