Your coding agent shipped 200 lines that compiled, passed CI, cleared review, and quietly bypassed the event-driven architecture your team agreed on eighteen months ago. Nobody decided that. It is now how your product works.
That is the problem Prelint exists to solve, and it is a different problem from the one every other AI reviewer is solving.
Prelint launched on Product Hunt on July 29, 2026, took #1 Product of the Day and #1 Product of the Week with 676 points, and has since collected 1.3K followers on the platform. Founder Wojtek Szkutnik says the company started because of exactly the scenario above: an agent implemented a feature that skipped the team's architecture entirely. Technically correct. All tests green. Nobody had made the call.
What it actually does
Prelint installs as a GitHub or GitLab app and reviews every pull request against your product context — specs, ADRs, tickets, and prior decisions — rather than against the code itself.
The distinction matters more than the marketing copy suggests. CodeRabbit, Greptile, cubic and Ellipsis all answer does this code work? Prelint answers should this code exist?
Here is the example Prelint leads with, and it is a good one. An agent changes a booking flow to convert the fare into the customer's currency and store that as the charge amount:
const fare = calculateFare(ride);
+ booking.amount = forex.convert(
+ fare, vendor.currency, customer.currency
+ );
+ booking.currency = customer.currency;
Clean code. Sensible-looking. No test fails. And Prelint flags it, because a Notion page titled Pricing: International Settlements says charges are always stored in vendor currency with a converted estimate shown to the customer. Vendor settlement still runs in vendor currency at fulfillment, so on advance bookings the exchange rate drifts and the platform silently eats the difference.
That is a revenue leak no linter and no code reviewer will ever catch, because there is nothing wrong with the code.
The six drift categories
Prelint organizes the problem into six failure modes, and reading them is a decent audit of your own exposure even if you never install the tool:
| Category | What it looks like |
|---|---|
| Business logic | Agent flips pricing from vendor to customer currency; FX exposure shifts silently |
| Compliance | Agent logs user activity with IP addresses and no retention policy; you find out at audit |
| Tooling & infra | Agent adds Twilio when you standardized on AWS SNS; you now pay twice |
| Domain language | Codebase says merchant; agent introduces seller, vendor, partner across new services |
| Scope creep | Agent adds a 12-language i18n framework to a US-only product |
| Strategic drift | Spec says internal dashboard; agent ships a versioned public REST API with OAuth |
Every one of these is good code building the wrong product. And as Szkutnik puts it, AI does not slow down when it is wrong — it keeps building confidently in the wrong direction, and the next agent inherits the drift as established fact.
The decision ledger is the real architecture
Ask what makes this more than a clever prompt and the answer is the thing Prelint calls a decision ledger.
Rather than diffing your PR against a docs folder, Prelint constructs a model of your product's ontology: which decisions exist, where they came from, and how much authority each one carries. A constraint written by a human in an ADR outweighs one an agent invented in a commit message. Szkutnik is blunt about why this matters commercially — he expects plain "check the code against the docs" reviewers to be commoditized by the next generation of frontier models.
Entries are never deleted. They get superseded, under three conditions:
- The source is superseded — newer code or docs override the original anchor.
- An explicit override lands — "we've been doing X, from today we do Y, final."
- A timeline expires — "support feature X until Sep 20, then we're free to phase it out."
Prelint also exposes the ledger through a CLI and an MCP server, so agents can query product decisions while they work instead of waiting for a human to find the problem at the end of the PR. That is the design choice that makes this fit an agentic workflow rather than fight it.
The evidence, and what it's worth
Prelint publishes a research series called AI Code Pulse, billed as monthly. The current edition — dated February 19, 2026, which is itself a mild credibility ding — covers 56,706 pull requests across 331 public repositories. Every PR was reviewed twice, once with docs context and once blind, then graded by Claude Opus 4.6 against what actually shipped. Public repos only; Prelint states it never uses customer data for research.
The headline finding is the one that justifies the whole product category:
Without docs context, the reviewer flagged 13.3% of PRs. With docs context, 36.6%. That is 979 issues only visible with context, plus 232 false alarms that context killed. Precision on context-driven flags: 80.8%.
Documentation did not find more of the same bugs. It found a different class of bug.
Two other numbers from that dataset are worth stealing for your own arguments. First, framework repos ship 25× more documentation than business repos — 4,040 KB versus 150 KB on average — and score lower on review accuracy: 68.5% against 81%. Business repos explain why; frameworks document what, and intent turns out to be the more useful signal.
Second, the failure profile: 43.5% of reviews graded overzealous versus 4.9% hallucinated. Flagging a deliberate design choice as a bug outnumbers inventing problems roughly nine to one. That is the noise you should expect to manage.
The claim to treat more carefully is Prelint's marketing figure that on teams running several AI reviewers, ~40% of the review comments that actually get fixed come from Prelint. That is vendor-reported, from an unnamed customer set, with no methodology attached. Believe the direction, not the decimal.
Pricing is refreshingly boring
$1 per completed review. No seats, no subscription, no minimums.
- $10 in free credits at signup, no credit card. Credits never expire.
- Only reviews that finish and post findings are charged. Failed, cancelled, and timed-out runs are free.
- Re-reviews after a new commit or force push cost another $1.
- Dependabot, Renovate, GitHub Actions and Snyk bot never trigger reviews, so they never bill. PRs from Claude or Cursor count as normal authors.
- Public repositories are free. No setup required.
- Prelint says most teams spend $40–$80 a month, and has committed $100,000 to a startup program.
Per-review pricing is the right model for a tool whose value scales with PR volume rather than headcount.
On security: tenant-isolated containers and storage per organization, no raw source code stored, TLS 1.2+ in transit, AES-256 at rest, and an explicit commitment never to train on customer code.
Where it falls short
The two published reviews on Product Hunt independently land on the same complaint: the interface is too narrow. Prelint today lives in pull requests and the CLI. Both reviewers want a way for product teams to explore the decision graph directly, and Prelint has apparently promised exactly that without shipping it.
Two structural gaps are worth naming before you buy:
Support and sales promises are invisible. A commitment made in an Intercom thread ("the renewal reminder goes out before the charge") is a real obligation that lives nowhere an agent can read. Szkutnik confirmed there is no direct support-tool integration yet; such statements only register if they land in Atlassian, Notion, or Linear, and then only as a speculative signal.
Pre-existing drift is only caught on contact. If a violation merged three months ago, Prelint flags it when a change touches that file, module, or ADR — not proactively. There is no sweep-the-repo mode.
And the honest caveat about hands-on testing: three ratings on Product Hunt is a launch-week sample, not an evidence base. This assessment is built on Prelint's published materials, its research dataset, and its founder's public answers — not on a month of production use.
The Bottom Line
Prelint is not a better code reviewer, and it should not be evaluated as one. It is a product reviewer, and the case for it rests on a single premise: if your agents write more code than you can meaningfully read, the expensive failure is no longer bad code — it is good code that quietly builds a product nobody chose.
Prelint's own recommendation is to run it alongside Greptile or CodeRabbit rather than instead of them, and its customers say the same. Code review bounds technical error; product review bounds intent error.
Try it if coding agents open PRs in your repo and you maintain ADRs or specs in version control. $10 in credits and a GitHub app install is a ten-review experiment with no commitment, and public repos are free indefinitely.
Wait if you need a product-team-facing view of the decision graph, your authoritative decisions live in Slack threads and support tickets rather than repo artifacts, or you were hoping to audit drift that already merged.
The category is real, and Prelint named it first. That is usually worth ten dollars to find out.
