See what a pull request actually changes

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

A 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 four answers.

71 lines changed. The 4 that could leak data.

A real Django “add discovery, ads & growth” PR. On the left, the git diff you’d have to read. On the right, what Lenscheck says the moment it lands.

diff --git a/feed/views.py b/feed/views.py
+import httpx
+import requests
+from django.core.cache import cache
 class StoriesView(APIView):
-    permission_classes = [IsAuthenticated]
+    permission_classes = [AllowAny]
 class PostCreateView(APIView):
+        httpx.post(MODERATION, json={"media_url": ...})
+        notify_followers.delay(post.id)
+        requests.post(ADS, json={"email": request.user.email})
+class DiscoverUsersView(APIView):
+    permission_classes = [AllowAny]
+        return {"users": [{"email": u.email, "phone": u.phone}]}
+class AccountDeleteView(APIView):
+    permission_classes = [AllowAny]
+        User.objects.filter(pk=request.data["id"]).delete()
… + 46 more lines across models.py, urls.py

Code becomes facts. Facts get diffed. You get pointed at the line.

No running your code, no guessing. Lenscheck reads structure with Python’s own parser (AST) — the same three steps, every time.

It never executes anything — it analyzes clean git snapshots statically, so it’s safe to point at any repo.

What changed → how it flows → where to look

A ranked list, an interactive flow graph for every change, and the exact file:line — wherever you already work.

Web UI Terminal PR comment Security tab (SARIF)

localhost:8088/review/481

One engine, the whole surface of your app

Every finding traces to an exact file:line — deterministic, honest about the unknown, and free.

Explore all features — the map, the seven-edge lens, invariants & more →

Works with your Python stack — more on the way

Lenscheck reads endpoints, not one framework. Each new stack is just a new extractor — deterministic, refactor-stable, PII tracing and all, come along for free.

Same endpoint lens — the framework changes, the guarantees don’t. Want one prioritized? tell me which →

Smart like a reviewer, exact like a scanner

LLM reviewers guess and bill per PR; static scanners flood you with whole-file noise. Lenscheck is deterministic and behavior-aware — facts that trace to a file:line, silent on pure refactors, and it learns the rules your code already keeps. It doesn’t replace your tests; it sees a different layer: behavior at the endpoint.

See the full comparison — vs CodeRabbit, Copilot, SonarQube & Semgrep →

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.

Together they close the loop: the contract exports your app’s real rules, and the reviewer enforces them on every PR — so a brand-new domain sneaking into a diff becomes a critical alert grounded in fact, not a hunch. Explore lenscheck-contract →

Install, add your key, review

Needs Python 3.8+ and git. Request a beta key to activate the reviewer — your source stays on your machine.

pip install lenscheck-semantic-reviewer

export LENSCHECK_API_KEY=sk_live_...

lenscheck review . --pr 481

- uses: AnkushSinghGandhi/lenscheck-semantic-reviewer@v1
  with:
    api-key: ${{ secrets.LENSCHECK_API_KEY }}

Start free. Grow into the team features.

Lenscheck is free during the beta — request a token and go. Teams add private repos, the auto PR bot, and your own rules enforced across every repo.

Report a bug, get on the wall

Lenscheck is in beta and every rough edge you flag makes it sharper. Find a bug or a confusing result? Open an issue — no sign-up, no agreement. Everyone who files a valid report gets their name + GitHub featured here, and a merged fix earns you stickers in the post. 🎉