Prelint Guide: How to Use It, Best Prompts & Use Cases (2026)
TL;DR: Prelint reviews every pull request against your product specs, tickets, and past decisions — catching AI coding agents that quietly drift from what the team actually decided to build. This Prelint guide covers setup, the best prompts, real use cases, and how to turn it into paid work.
What Is Prelint? (And Why Everyone's Talking About It)
Prelint is a review tool built for a failure mode that's specific to AI-assisted development: code that technically works but quietly drifts away from what the team actually decided to build. It checks every pull request against your documented product specs, tickets, and past decisions — not just whether the code runs.
Standard code review, and even most AI code reviewers, answer one question: does this work. Prelint answers a different one: is this what we said we'd build. It reads a PR's diff alongside your specs and architectural decision records, then flags anywhere the implementation makes an undocumented judgment call, contradicts a past decision, or silently expands scope beyond the original ticket.
This is landing at exactly the right moment. AI coding agents are confident by default — they'll pick a reasonable-looking approach and ship it, even when that exact approach was already tried and explicitly rejected weeks earlier, or when it quietly violates a compliance rule nobody thought to repeat in the prompt. On teams running several AI reviewers at once, roughly 40% of the review comments that actually get fixed come from Prelint specifically, because it's the only one checking intent instead of syntax.
Prelint works with GitHub and GitLab, and specs live as version-controlled Markdown or YAML files inside your own repo, right alongside the code they govern. It started as a GitHub-native review tool and has since expanded into a CLI and an MCP server, which means agents can check their own decisions against your product context while they're still working — instead of a human discovering the drift weeks after merge.
Who Is Prelint For?
Prelint is built for teams where AI coding agents are already shipping real production code, and where "the code works" has stopped being a sufficient bar for merging it.
Ideal users include:
- Engineering teams running Claude Code, Cursor, or Codex against a shared codebase with real product constraints
- Engineering leads tired of discovering, weeks later, that an agent quietly re-implemented a rejected approach
- Product managers who want visibility into judgment calls agents are making without being asked
- Compliance-sensitive teams (fintech, healthcare, regulated industries) who need business rules enforced automatically on every PR
- Freelance developers and consultants looking for a new AI-tooling service line to offer clients
Key Features of Prelint
Prelint's design choice is narrow on purpose: it doesn't try to replace your existing code reviewer or linter, it adds the one layer they're both missing — whether the code matches product intent.
Spec-Aware PR Review
Every pull request gets checked against your written specs and past decisions, with drift flagged inline exactly where it happens, not buried in a separate report.
Decision Explanation
When an agent makes a judgment call that wasn't explicitly specified, Prelint surfaces what was decided, why, and how hard it would be to reverse — so a human can approve, correct, or replace it before merge.
Version-Controlled Specs
Specs and ADRs live as Markdown or YAML in your own repo, reviewable in pull requests and versioned in git history, just like the code they govern.
CLI and MCP Support
Beyond the GitHub-native review, Prelint ships as a CLI and MCP server, letting agents check their own decisions against product context mid-task instead of waiting for a human to catch it later.
How to Get Started with Prelint in 5 Minutes
- Sign up at prelint.com and connect the GitHub or GitLab repo you want reviewed.
- Let Prelint scan your existing docs, tickets, and merged PRs to infer what decisions it can already work from.
- Write your first structured spec for an active feature (see Prompt 1 below) — this becomes the source of truth Prelint checks PRs against.
- Backfill a few architectural decision records for recent calls your team already made (see Prompt 2), so Prelint stops flagging settled questions as open ones.
- Open a real PR and watch Prelint comment inline anywhere the diff drifts from your spec. Approve, correct, or replace each flagged decision so it carries forward into the next PR.
7 Best Use Cases for Prelint
1. Catching Silent Scope Expansion
An agent quietly builds more than the ticket asked for, and Prelint flags the gap between spec and implementation before it merges.
2. Blocking Re-Implementation of Rejected Approaches
If a caching strategy was already tried and explicitly rejected, a logged ADR stops the next PR from confidently shipping it again.
3. Automatic Compliance Enforcement
A data-handling or pricing rule gets written once as a spec entry, and every relevant PR gets checked against it automatically.
4. Product Visibility Into Agent Decisions
Product managers get a real accounting of judgment calls agents made without anyone explicitly asking them to make.
5. Cross-PR Contradiction Detection
Two agents working days apart on related features stop silently contradicting each other's decisions.
6. Retroactive Drift Audits
Running a drift check against the last quarter of merged PRs surfaces shipped code that diverged from documented intent — even though it technically works.
7. Faster Senior Engineer Review
Letting Prelint catch intent-level issues before a human opens the PR frees senior engineers to focus on architecture instead of re-deriving product context every review.
5 Copy-Paste Prompts for Prelint
Here are five of the best Prelint prompts to get real value out of it fast.
Prompt 1: Bootstrap a Product Spec
Read through this feature request or ticket: [PASTE TICKET]. Write a structured spec in Markdown covering: the intended behavior, explicit constraints, what's out of scope, and any business rules that must not be violated. Format it so Prelint or a human reviewer can check a PR against it line by line.
Prompt 2: Write an Architectural Decision Record (ADR)
We just decided to [DECISION] instead of [ALTERNATIVE]. Write an ADR documenting: the context, the decision, the reasoning, and the consequences. Keep it factual and dated so it can be checked against future PRs for drift.
Prompt 3: Pre-PR Drift Self-Check
Before I open this PR, compare the diff against docs/specs/[FEATURE].md and docs/decisions/. Flag any place where the implementation deviates from the spec, contradicts a past decision, or makes an undocumented judgment call. List each one separately.
Prompt 4: Drift Audit on Existing Code
Review the last 10 merged PRs against our current specs and ADRs in docs/specs/ and docs/decisions/. Identify any places where shipped code diverges from documented intent, even if the code technically works.
Prompt 5: Ticket-to-Spec Converter
Convert this raw ticket or Slack thread into a structured spec Prelint can check PRs against: [PASTE CONTENT]. Separate out: explicit requirements, implicit assumptions that need confirming, and things intentionally left open for the implementer to decide.
Prelint vs. Standard AI Code Review: Which Should You Use?
Standard AI code reviewers — the kind that comment on style, bugs, and correctness — answer whether the code works. That's valuable, and Prelint isn't trying to replace it. Prelint answers a different question: whether the code matches what the team actually decided to build, which a correctness-focused reviewer has no way to know because it isn't reading your specs or decision history.
If your team's biggest problem is bugs and code quality, a standard AI reviewer is probably still your first investment. If your biggest problem is agents confidently shipping the wrong thing — silently, and only discovered weeks later — Prelint is solving a problem no correctness-focused tool can touch. Most teams running AI coding agents at scale eventually need both.
How to Make Money with Prelint
1. Productize the Setup
Most teams running AI coding agents have product context scattered across tickets, Slack threads, and stale docs — nowhere Prelint can actually check against. Offer a fixed-price "Spec + ADR Setup" package that structures their existing context into files Prelint can use, typically a $150–$500 engagement depending on codebase size.
2. Sell Drift Audits
Run a drift check against a team's last quarter of merged PRs and package the findings into a paid "Product Drift Audit" report. A concrete, evidence-backed finding — "here's what shipped that shouldn't have" — is one of the easiest pitches for a recurring retainer you'll ever write.
3. Build Authority Content Early
"AI code review beyond correctness" is a brand-new angle with almost no existing guides. Publishing the first tutorials, prompt packs, and case studies now, before the category gets crowded, compounds into an audience that trusts and buys everything you release after this one.
Frequently Asked Questions About Prelint
Is Prelint free?
Prelint offers a way to connect a repo and see what it infers about your existing decisions before you commit to a paid plan — check prelint.com for current plan details, since pricing wasn't published as part of the launch materials.
Is Prelint safe to use?
Specs and decision records live as version-controlled files in your own repository rather than a third-party database, and Prelint's review process is scoped to reading your specs, tickets, and PR diffs rather than modifying code directly.
What is Prelint best for?
It's best for teams running AI coding agents against real production codebases who need pull requests checked against product intent, compliance rules, and past decisions — not just whether the code runs.
How does Prelint compare to a standard code reviewer?
A standard reviewer checks whether code works. Prelint checks whether it matches what was actually decided, using your specs and ADRs as the source of truth — a layer most code review tools don't touch at all.
Can beginners use Prelint?
Yes. The core workflow — connect a repo, write your first spec, backfill a few ADRs — takes about five minutes to set up, and the included prompts handle most of the initial spec-writing work.
Final Verdict
Prelint solves a problem that's specific to the agentic coding era: code that works but quietly does the wrong thing, shipped with total confidence, and discovered — if it's discovered at all — weeks after the fact. By checking every PR against specs and decisions instead of just syntax and style, it adds the one review layer that correctness-focused tools structurally can't provide.
If your team is running Claude Code, Cursor, or Codex against a real product with real constraints, the five-minute setup pays for itself the first time Prelint catches an agent quietly re-shipping a decision your team already killed.
The bigger opportunity is timing. "AI code review beyond correctness" is still a new category with almost no competing content or established best practices. Getting hands-on with Prelint this week — for your own team's workflow or as a service you package for clients — puts you ahead of that curve instead of catching up to it once it's crowded.
Want the complete Prelint prompt pack + monetization playbook? I put together a full guide with 10 copy-paste prompts, all 10 use cases mapped out, and a step-by-step monetization playbook. Grab it on Gumroad →
Published: 2026-07-31 | Updated: 2026-07-31
Top comments (0)