I asked an AI to tweak one lint rule.
But when I opened the code, there was an entire sophisticated filtering system I never asked for. The AI had quietly narrowed something that was supposed to catch a wide range of cases.
It passed the tests. It passed code review. But is this actually the product we wanted?
Everyone Thinks Catching Bugs Is Enough
The AI code review market is already crowded. CodeRabbit, Greptile, Qodo, Cursor BugBot — they all do roughly the same thing: scan a PR's diff and flag bugs, security vulnerabilities, and style issues.
These tools are actually competing hard on performance. In a benchmark across 50 open-source PRs, Greptile caught 82% of real bugs — 50% more than CodeRabbit. The tradeoff: more false positives too (11 vs. 2).
| Tool | Focus | Price |
|---|---|---|
| Greptile | Full codebase indexing, cross-file bugs | $30/user/month (billed after 50 reviews) |
| CodeRabbit | Diff summaries, quick setup | $24-48/user/month |
| Qodo | Jira ticket compliance checks | Free-$30/user/month |
These are all solid tools. But what they have in common is that they all ask "is this code technically correct?" No bugs, style guide followed, tests pass — that's a pass.
Here's the Thing — Bug-Free Code Can Still Be Dangerous
This is exactly where the Prelint team's thinking started. The whole company was actually founded because of one code change — an AI agent completely ignored the team's event-driven architecture and just routed around it to ship a feature. The code worked. It just wasn't how the team wanted it built.
They call this product drift. Code that passes technical review and CI, while quietly skipping a transactional outbox pattern, sneaking in an unapproved dependency, altering permission rules, or inventing a business requirement that was never actually asked for.
The Stack Overflow blog calls this "black box AI drift" — "a prompt goes in, an output comes out, but the decisions made in between stay invisible". That lint rule story from the intro? It's actually from this same blog post.
The numbers back this up. GitClear analyzed codebases from 2023 to 2026 and found block duplication up 81% (40.3 → 73.0), with copy-pasted code climbing from 9.4% to 15.7% of all changes. Meanwhile, the kind of refactoring that moves code around to clean it up dropped from 21% to just 3.8%. AI is writing code faster — but nobody's cleaning up after it.
Heads Up
An AI agent can crank out 50 files in one afternoon. Each file looks fine on its own — but stitched together, they can violate half your architecture decisions. File-by-file review won't catch that.
Enter the "Decision Ledger"
Prelint's positioning is blunt: "not a code reviewer, a decision ledger". It pulls together the ADRs (architecture decision records), docs, and past decisions sitting in your repo into a single "decision ledger," then checks every PR against it.
The workflow has three steps: (1) product specs live in the repo as markdown/YAML, (2) your AI agent generates PRs as usual, (3) Prelint flags spec violations within seconds and suggests a fix.
Prelint ran its own research across 56,706 PRs from 331 open-source repos, reviewing the same PR twice — once with docs, once without. Flag rate was 36.6% with documentation versus 13.3% without. In the Prelint team's words: "documentation doesn't find more bugs, it finds different bugs".
| Traditional AI code review | Decision ledger approach | |
|---|---|---|
| Standard | Bugs, style, security | ADRs, product specs, past decisions |
| Passing condition | Technically correct = OK | Matches product intent = OK |
| Review unit | One diff at a time | Checked against the repo's full decision history |
| Combined effect | - | Catches ~40% of issues other reviewers miss |
This isn't really about replacing other tools — it's closer to adding one more layer. If Greptile or CodeRabbit ask "is this code safe?", Prelint asks "is this code the product we actually decided to build?"
Getting Started
- Write down your key decisions first
You don't need an ADR for everything. Just document 5-10 architecture, permission, or data-flow decisions your team actually argued about in the last three months. - Connect it to your repo
Install the GitHub/GitLab app and it activates automatically in your existing PR workflow. - Run it alongside your existing reviewer
Keep CodeRabbit or Greptile running and add Prelint on top. They look at different things, so there's no overlap. - Check the first flagged case
Look at the first PR Prelint flags to get a feel for how accurate your team's decision ledger actually is. - Keep the ledger alive
Review stale decisions every quarter and retire rules that no longer apply. A stale ledger just means more false positives.
From "Code Review" to "Intent Review"
The Korean dev blog Flowkater sums up where code review is heading in the AI era: "review the spec, not the diff, and define acceptance criteria upfront". Prelint's decision ledger is basically that idea, turned into a product.
Deep Dive Resources
Prelint's official site See how it works, pricing, and an actual PR review demo. prelint.com
Prelint AI Code Pulse research The original data and methodology behind the 331-repo, 56,706-PR analysis. prelint.com
Black box AI drift (Stack Overflow Blog) The original piece on AI quietly making design decisions nobody asked for. stackoverflow.blog
Best AI Code Review Tools 2026 (Greptile) A benchmark comparison of 8 tools including CodeRabbit, Greptile, and Qodo. greptile.com
AI Architecture Drift (TechDebt Guru) Five patterns of AI agents eroding architecture, plus the GitClear stats. techdebt.guru
ADR 2.0 — A Shared Contract for Humans and Agents A Korean dev blog on how ADRs are evolving for the agent era. juhyungson.com
