See what a pull request actually changes — no LLM required

Two tools, one promise: always know what your backend does

Lenscheck looks at your backend from both sides — the diff from the outside and the running app from the inside. Each catches what the other structurally can't.

$ lenscheck-contract invariants -o invariants.json        # the app's real declared egress + rules
$ lenscheck review <repo> --pr 128 --invariants invariants.json   # the reviewer stops guessing

On its own the reviewer guesses your invariants from git history. lenscheck-contract hands it the truth instead: your app's declared destinations become an enforced allowlist, so a brand-new domain sneaking into a PR is a 🔴 critical alert — grounded in fact, not a hunch. See the full docs →

Your backend can't lie about what it does

Static analysis can't see routers, loops, or mixins — but Django already resolved all of it at startup. So lenscheck-contract asks the running app instead of parsing files.

3 bad things in. 0 shipped.

A PR that "looks harmless" — caught on two layers: structural (the CI diff) and runtime (the guard).

• Layer 2 · CI diff — auth weakened (user → public) and a model field dropped → CI blocked before merge.
• Layer 3 · runtime guard — an undeclared exfiltration call blocked before it ever left the process.
• Structural mistakes → this. Logic mistakes → your tests. You need both.

A single PR can be 60 files and 18,000 lines

A normal line-diff buries the one change that matters — "user email now leaves the server" — under thousands of mechanical edits. You don't need to read all of it. You need to know what changed in behavior, how it flows, where to look, and whether it broke a promise.

# 17,841 lines changed → 3 things to actually look at

🔴 NEW ENDPOINT  /api/companions/payment
   why: new endpoint exposes a PII path with open/unspecified auth
   flow: /api/companions/payment → CompanionPayment → {Order:write} → ext: PayTM
   investigate: payment_views.py:90  email → requests.post @ services.py:9

🟠 CHANGED       /api/orders/invoice
   why: new external call: razorpay.post  ·  money path

🟢 REFACTOR      /api/users/profile
   handler renamed, semantics unchanged — nothing to see

Code → facts → diff → show what matters

No running your code. No guessing. Just Python's own parser (AST) reading structure — the same three boxes, small.

What changed → how it flows → where to look

A ranked list, an interactive flow graph for every change, and the exact file:line locations — in the terminal, a web UI, a PR comment, or your Security tab.

Why not just read the diff?

Because on an 18,000-line PR you can't — and the usual alternatives either guess, or miss what actually matters.

It doesn't replace your tests or type-checker — it sees a different layer: behavior at the endpoint, and whether a change broke a promise.

Seven things it reads for every endpoint

It reads your code with Python's own parser — it never runs it — and reports facts, not guesses.

It will never say "no PII leaves here" when it just didn't see it. Absence is shown as unknown, never as safe.

Terminal, a web UI, or on every PR

Same facts, three surfaces — pick whatever fits your workflow.

It learns the rules your code already follows

A property your codebase kept for 800 commits was almost certainly on purpose. Lenscheck mines your git history, surfaces those rules, you confirm the real ones — and then every PR that breaks one gets flagged, with the exact commit that broke it.

Built to be trusted

The honest answers

Three commands, zero setup

Needs Python 3.8+, plus git and tar. That's the whole install.

pip install lenscheck-semantic-reviewer

lenscheck review https://github.com/owner/repo --pr 481

cd your-repo && lenscheck serve