Changelog

Prelint used to review every PR against your default branch. On a PR that targets a release or stacked branch, it would call code missing that in fact exists on the base. Prelint now reads the branch the PR actually targets, so those false findings are gone. This affected one review in five.

A re-review now adds a “Since the last review” section. Every concern from the previous round gets a status: Addressed in code, Addressed by explanation, Still open, or No longer applicable. Each one points to the commit, comment, or change behind it.

New Project and Connect GitHub now open the same guided setup, and you can run it again for your second and third project. Back works, a trip to GitHub returns you where you started, and repos already used by another project are disabled. If an install connects nothing, the message says why: repos pending org-admin approval, or repos already linked elsewhere.

The markdown cleaner treated any “<” as the start of an HTML tag and deleted everything up to the next “>”. Shell redirects, generics, and text like “< 60 min” removed kilobytes from stored docs. That is fixed, and damaged documents are re-read and re-indexed.

If a decision review cannot be parsed, Prelint no longer posts raw JSON on your PR. The check goes red and asks you to push a new commit.

The concurrency cap counted a PR's own running review against itself, so a small balance allowed one review per PR and refused every push after it. The cap now ignores the review it is replacing. The message also tells you to add credits rather than to wait.

Turning on reviews no longer starts indexing a repo's markdown. Onboarding asks whether to index docs from the repos you pick, and you manage it under Ideas → Sources. A repo tracked for docs only now re-indexes on every push, with review monitoring off.

After the first scan of a repository, re-indexing its docs on a push is much faster. The bigger the repo, the bigger the difference.

Archived GitHub repos are hidden from the repo pickers, behind a Show archived toggle. You cannot turn on monitoring for one, because it takes no new PRs but would still start billing.

Edit a PR title or body, or retarget it to a different base branch, and Prelint updates what it shows. It used to wait for your next push.

Opening many PRs on a low balance used to overdraft, once per review. Prelint now starts only as many paid reviews as your balance covers, and the rest say the balance is committed to reviews already running. Decision reviews are free and never capped.

New commands: statement confirm, statement provenance, statement location, contradictions resolve, glossary events, topic events, and ingestions delete. Contradiction and ingestion lists take --page and --page-size, so page 2 is reachable. Stale statements are marked in list output.

Decision reviews now follow Simplified Technical English: one instruction per sentence, twenty words or fewer, active voice, no marketing adjectives. Code, file paths, and error strings stay verbatim.

Statement extraction hit a fixed 175-second cap, failed, and left the import stranded. The cap now follows the real budget, so a long document completes.

The always-included slice of your statements was ordered alphabetically, so every review of a large project saw the same few topics and an oversized topic was dropped whole. It now reads newest first and ranks settled statements ahead of assumed and open ones. The glossary gets its own share of the budget: 43 of the 52 projects with a glossary were showing none of it. When the slice is cut, the reviewer is told how much it is seeing.

A failed document import used to show a raw error like no_response. It now says what to do: split a document that is too large, or re-import one that timed out.

Dedup could merge “Audit logs are retained for 30 days” with the 90-day version. Two statements that differ on a number, a date, or a qualifier such as a limit, plan tier, or environment are now kept apart.

Three skip reasons rendered as raw tokens in the review panel and now read as sentences. A review cancelled because the PR closed first says so, instead of reporting an unexpected failure.

The Buy Credits dialog is now a card on Settings → Billing. Pick $10, $25, $50, $100, $250, or a custom amount up to $10,000, and each tile shows how many reviews it buys. With a card on file, one click charges it. Apple Pay, Google Pay, and Link sit on the same form, and every method is saved for auto-recharge.

If every changed file in a PR matched your ignore patterns, the model got an empty diff and approved the PR anyway. Those runs now stop before the model is called, and you are not charged. The check says how many files matched.

A PR containing a deleted file was retired as superseded and never reviewed at all. Those PRs are reviewed normally now.

curl -fsSL https://install.prelint.com | sh

One extra comma in the model's JSON threw away a whole extraction. Prelint repairs it and keeps the result.

The job that grants referral rewards was never scheduled, so lifetime earnings sat at $0. When someone you referred runs their first review, your org now gets the $20 credit and the reward email. The reward no longer expires while you wait for them to run it.

In comment approval mode, a PR with no findings produced no output at all. It now posts “All clear - no findings.”

On a re-review, files that had not changed since the last round were withheld from the diff, and Prelint would warn that a file was missing or forgotten. Those files are now named in the prompt with their status and line counts, and any claim that they are absent is dropped before it is posted.

Pushing a new commit now cancels the review still running for the old one and closes its GitHub check. A force-push back to a commit Prelint already reviewed no longer runs a second review or charges you twice.

Prelint can bill your organization with a Stripe invoice on net terms instead of a card charge. The invoice arrives with a payment link and appears in your invoice history. Credits land on your balance when it is paid.

A VAT ID stuck at “could not be verified” used to need clearing and retyping. Billing settings now has a Re-verify VAT ID button and polls for the verdict after you save. If verification fails for good, your billing contact gets an email.

Settings → Billing has a Redeem Code button. Any member can enter a campaign code and the credit lands right away. The dialog names the amount and when it expires.

Every invoice is on the billing page: date, status, amount, and a PDF link. Your VAT ID syncs to Stripe, so EU invoices are taxed correctly.

Push new commits after a decision review raises concerns and Prelint re-checks each concern against the new code, then updates its comment in place.

API lists could skip or repeat a row when paging deep. Page order is now stable, every time.

Onboarding used to pre-select every repository you have. It now suggests the repos that belong with your most active one as your first project — and finally explains what a project is. Repos you leave out are simply ignored.

The dashboard used to fetch unfiltered data first and apply your saved filters after. Filters now load before the first fetch — no flash of the wrong view.

The reviewer now gets a list of changed files that were excluded from review — lockfiles, generated code, your ignore patterns. It no longer guesses about changes it wasn't shown.

The Ship it and Discuss first badges no longer render with stretched lettering.

Each decision in a decision review gets its own collapsible block with a verdict badge: Agree, Agree with concerns, Disagree, Discuss first. The overall call sits on the title line: Ship it, Ship with changes. Disagreements start expanded, and a badge can no longer contradict the reasoning next to it.

Prelint approves a PR only when every finding has been cleared. A re-review that didn't look at a file can no longer resolve that file's findings, and a review that hit its budget no longer counts as a pass.

When a review can't run because your organization is out of credits, the GitHub check now posts as neutral instead of a red failure. Your PR doesn't look broken, and merge queues keyed on check failures don't block.

The usage breakdown on the billing page now groups reviews by who wrote the PR, not by what triggered the review. The “Webhook (automated)” row that used to swallow most reviews is gone — you see actual teammates. Tables also say so when the 25-row cap cuts the list short.

If posting a finished review to GitHub keeps failing, the check run now closes with an explanation instead of spinning forever. GitHub secondary rate limits are retried instead of dropped.

Uninstalling and reinstalling the Prelint GitHub App could silently stop document indexing for a repo — permanently. Indexing now resumes on its own after a reinstall.

Review policy settings are no longer behind the billing gate. Out of credits or between subscriptions, you can still adjust how Prelint reviews your PRs.

If Stripe takes your payment but the credits are slow to land, Prelint adds them automatically and emails you the amount.

A new card on profile settings exports everything Prelint knows about you as JSON — profile, memberships, preferences, and sign-in metadata. It stays available even while your account is pending deletion.

Retrying a failed source import used to be limited to whoever started it — if they left the org, the import was stuck forever. Org admins can now retry any member's import.

The admin-or-member binary is gone. Admins can grant members exactly what they need — ingest content, manage sources, manage the knowledge base, or manage review configuration — from checkboxes in the members table and invite dialog. A webhook event fires whenever permissions change.

Prelint can label your PRs on GitHub with the outcome of a decision review — “ship-it” when it's clean. Toggle, rename, and recolor the labels per project or per repository; labels that already exist on your repos keep their colors.

Approval mode and draft-PR handling at the project level now have an “Inherit from organization” option that shows which value you're inheriting. Previously an override could only be replaced, never removed.

Account deletion is now self-service, from profile settings. Type your email to confirm, and the account enters a grace window — cancel from the app or from an emailed link, no login required. After the window, everything is purged for good.

The billing.credits_added event now fires for every way credits reach your balance — purchases and auto-recharge included, not just grants. Each event says where the credits came from, the transaction id, and your new balance — no parsing descriptions.

A review that failed on a transient model error used to leave a red “contact support” check on your PR. Prelint now re-runs it automatically — the retry almost always succeeds.

Doc scans now fetch file contents in batches instead of one API call per file. Big repos scan much faster, and the documents page refreshes itself when a scan finishes.

Connect Google Docs or Read.ai without granting all the requested scopes and Prelint now tells you immediately, instead of storing a half-working connection that fails later mid-fetch.

Import an empty file or a template stub and it shows a neutral Skipped badge with “Nothing to extract”, instead of a spinner that never stops. Extraction skips them.

If an auto-recharge charge is declined, your billing contact now gets an email right away — one per decline streak, not one per attempt. Credits no longer run dry silently.

The organization switcher is now an inline submenu of the account dropdown — one fewer click, less clutter. If you're in a single org, you just see its name.

Importing content used to create near-duplicate topics — “Auth” next to “Authentication” — and cleanup only ran every six hours. Duplicates now merge right after each import. Topic names got better too: three words max, about what your product does rather than which vendor it uses, and no more catch-all “General”.

Importing many documents at once used to stall — items could sit “queued” forever or get marked failed without ever being processed. The whole backlog now runs to the end, oldest first.

The CLI now prints its version up front, shows it's still waiting while you finish in the browser, and on timeout tells you what to do — check the browser tab, or update an outdated binary — instead of hanging silently.

The health check on the Sources page was a placeholder that always said healthy. It now really probes Notion, Google Workspace, and Read.ai: a revoked token asks you to reconnect, and a platform blip doesn't.

The Notion connector now imports databases and their rows, not just pages. Databases show up labeled in the source browser — “Database · 40 entries” — so you can tell them from pages before importing, and the import status pill updates live instead of waiting for a page refresh.

The webhook endpoint dialog used to link to a docs page that didn't exist. It now explains signature verification right there — everything you need to build a working verifier without leaving the screen.

You can now change the email on your account and actually finish the flow: the verification email carries a confirmation link that completes the change. Previously it showed a raw token with nowhere to paste it.

Referral rewards now go straight onto your org's credit balance and show up in the ledger with their own transaction type — real credits you can spend on reviews, not a line buried on the Stripe balance.

One moved, deleted, or unshared sub-page used to fail an entire Notion import. Prelint now skips just the unreachable part and imports everything else.

The per-repository cap on scanned documentation went from 50 files to 1,000. If your repo has a serious docs directory, reviews now draw on all of it instead of silently ignoring everything past the first 50 files.

When the same mistake shows up in a schema, its docs, and the example that copies it, Prelint flags it once — where the fix belongs — and names the other affected files in that single comment, instead of leaving one in each. On a re-review it now carries its still-open findings forward unchanged and drops the ones your latest push fixed, so the number of comments on a PR tracks the number of real problems.

Reviews now weigh a change against the surrounding code, not just the lines in the diff. That catches issues that only show up in context — a helper used the wrong way, an assumption that no longer holds, a change that breaks something elsewhere.

The projects page loads fast and shows repo and open-PR counts on every card up front. It pulls a project's repositories only when you expand it, instead of fetching everything at once.

Prelint now feeds the reviewer what you wrote in the PR description, not just the code. It checks your stated intent against what the diff actually does — and won't re-flag something you already explained there.

The reviews list now pages by pull request, so one PR never shows up on two pages at once and every page holds a full set of rows.

Every new organization starts with $10 in credits. Reviews are $1 each — so that's ten of them before you pay anything. No card required.

Install it with Homebrew or a one-line script, and it starts instantly. A new `prelint doctor` command checks your setup when something looks off.

Auto-recharge used to wait for a finished review to notice your balance was low. Hit $0 and reviews just stopped. Now a new review triggers the top-up first — so you never sit blocked.

Hit an hourly review limit and your PR used to get nothing back. Now it gets a check run that names the limit you hit, and the review detail page says so in plain words.

The members page now loads fast, even for big teams.

Project visibility used to depend on which repos you had GitHub access to. Now every member sees the org's projects, dashboard, and rollup analytics. Repo file contents and reviews still gate on access. Curation actions stay admin-only.

If you connected GitHub in one Prelint org and join another, the new org offers to reuse your access — or you can connect a different account. No silent auto-promotion. Useful for consultants juggling client orgs.

Deleting an ingestion now soft-deletes it. Re-paste the same content and Prelint reuses the existing row instead of stacking up near-identical copies.

A Read.ai connection that keeps getting rejected now stops retrying and shows the error in the Sources panel, with a Reconnect button.

Paste “April 2” and Prelint stops fabricating “2:00 PM”. Date-only stays date-only across the meeting list, ingestion history, and statement detail.

If you're not a GitHub org admin, the Configure repositories button now says “Ask a GitHub org admin” instead of just sitting there disabled.

`prelint login` used to give up after 5 minutes while the auth code stayed valid for 10. Slow SSO/IdP no longer leaves the terminal timed out while the browser shows success.

Install the Prelint GitHub App on exactly one repository and reviews turn on the moment it lands. No detour through the dashboard before your first PR gets reviewed.

Connecting a repo used to warn “already linked to another project” even when that project was deleted, and pointed at a UI page that didn't exist. Orphans now reclaim automatically. Cross-org collisions still surface for admin attention.

When Notion, Google Docs, or Read.ai fails to refresh a connection, the Sources panel now flags it with a Reconnect button instead of going silently stale.

Browsing folders on /ideas could take close to half a minute on large results. It now loads in a snap.

Connecting a GitHub installation now tells you exactly what was assigned to your project, what was reclaimed from a deleted project, and what is still in someone else's. The old generic message was misleading.

Activity on repos Prelint doesn't track no longer takes up processing time. On busy GitHub orgs, reviews kick off noticeably faster.

If you belong to more than one organization, pick another from the profile dropdown. Session swaps in place.

If a Notion, Google, or Read.ai connection expires, the browse page now tells you and gives you a one-click Reconnect — instead of silently showing nothing.

Period and repo filters on the dashboard persist across navigation. Come back to the view you left.

“Review contradictions”, “Pending terminology”, and “Pending topic changes” on the Health page now jump straight to the right section of Browse.

Extraction now picks up end dates when they're in the content (“valid until Q2”, “through end of year”). Expired statements drop out of review grounding automatically. Re-attest with one click if it's still true.

Attendee lists and meeting duration are now kept alongside the ingestion instead of discarded after fetch.

Up from 7. Subscribe to review, repo, user, org, and billing lifecycle events — works with Zapier, Make, and any REST Hooks client. PII scrubbed before delivery.

/ideas is now split into Meetings, Documents, and History. Each has its own feel — time-grouped meeting cards, flat document list with provider metadata, unified ingestion history with kind filters.

Side-by-side boxes for the new claim and the one it contradicts. Resolve and watch the losing side fade out. Statement cards got a full redesign too — tighter typography, clearer lifecycle icons, instant feedback on Accept/Reject.

Each statement card shows how often it's been cited in reviews. Scaled so two bars means real repeat use; three means it's load-bearing.

The `prelint` CLI used to kick you out every hour. It now refreshes its OAuth token in the background.

Icon-only buttons (retry, delete, edit) now have proper names for screen readers.

Click any statement to see the full story: the source excerpt next to the extracted claim, how often reviews cite it, how it relates to other statements (refines / supersedes / contradicts), where it came from, and its history.

One page per project that surfaces what needs attention — failed reviews, pending triage, setup gaps, tips. Grouped by severity, color-coded.

Code Review and Decision Review for the same PR now share one row. Status becomes a colored dot. Repo and org names link out to GitHub or the Prelint repo page.

Reply to a Prelint comment and fix the issue — Prelint reacts with 👍 on your reply so you know it registered. Re-reviews now read the PR conversation too, so you don't get re-flagged on something you already clarified.

Enable a repo for the first time and Prelint reviews your 5 latest open PRs. No more empty reviews page right after setup.

Approval mode, required review kinds, and draft PR handling can now be set at the project level, not just org-wide.

Before extraction, Prelint classifies what it's reading — meeting transcript, product spec, architecture doc — and tunes filtering per type. Stricter on transcripts, lighter on specs.

One concise lead sentence, then optional detail. Easier to scan, shorter to cite.

Dedup used to only compare new statements against the existing knowledge base. Now it also catches duplicates within the same extraction batch, so one ingestion can't produce five near-identical rules.

Term detection now excludes generic software lingo, compound nouns, and plan names. The bar: would an experienced engineer need this explained?

The header balance pill used to always be visible. Now it only shows up when reviews are paused, or when the balance drops below $20 and auto-recharge is off.

Recurring meetings with identical titles now show when they happened. “Today at 2:30 PM”, “Apr 16 at 2:30 PM”.

Attach your own key-value metadata to statements — via API or CLI, with filtering. For tagging, routing, or your own grouping.

Org name, display name, and email at the top of the dropdown.

No seat fees, no subscription. You pay only for the reviews Prelint completes. Buy credits when you need them; auto-recharge if you want it.

Search statements by meaning, not just keywords — the same way the reviewer finds them. Available via API and `prelint statement search`.

Stuck or failed ingestions retry up to 3 times on a schedule before giving up.

Raw Python tracebacks on failed reviews are gone. GitHub check runs and the dashboard now show what actually went wrong and what to do.

Reviews that fail now email you too, not just the ones that succeed.

`prelint` detects whether it's writing to a terminal and picks table or JSON accordingly. Override with `--format`.

Every org gets a permanent referral link. When someone you referred runs a review, you both get $20 in credits. (Replaces trial-day rewards.)

The “add a passkey” prompt used to show every session. Now it shows at 24 hours and 7 days after signup, then gives up.

After installing or configuring the Prelint GitHub App, you land back on the page you started from — not always on Sources.

Enabling code review on a repo now auto-enables document tracking. Disabling it turns tracking off too. No more orphaned stale docs.

README files, ADRs, and architecture docs in your repo get extracted into Prelint's knowledge base automatically. Same pipeline as Notion or Google Docs — same dedup, same contradiction detection, same review context. Nothing to configure; extraction runs on every push to main.

Connect Notion, Google Workspace, and Read.ai as knowledge sources. Browse and import documents — or meeting transcripts — straight from Prelint, no copy-paste. Each member connects their own accounts over OAuth.

The Integrations tab on /ideas shows what's already imported with a checkmark so you don't import things twice. Search as you type, import one at a time or in bulk.

Project-scoped pages now live at /projects/<slug>/… instead of ?project=<id>. Bookmark any view. Share links that open in the right project every time.

Changed the focus of a project? Rename its slug and every URL updates. Used to be locked after creation.

If Prelint can't see a private repo you expected during onboarding, it names which ones are missing and links to the GitHub page where you grant access.

New `prelint` CLI. Log in with OAuth, switch projects, and query your product knowledge from the terminal. `prelint init` drops a config into your repo.

Extraction now drops statements that already exist in your knowledge base, even when worded differently. Near-certain duplicates skip automatically; borderline cases go through a second-pass check. No more five near-identical rules about the same thing.

New content that refines an existing topic updates it in place. Renames auto-apply; merges and archives surface for review. Topics no longer freeze the moment they're created.

Sprint plans, demo dates, and deadlines get tagged as temporal during extraction. A 'time-sensitive' badge keeps them visible but out of the pile of durable product rules.

Decision reviews now assess each listed decision instead of occasionally skipping one. If the model misses any, we log and retry.

Vision docs and roadmaps mix product rules with market stats and strategy prose. Extraction now filters the latter, so your knowledge base stays full of things a reviewer can actually act on.

Resend a pending invite from the members page. 24-hour cooldown between resends.

Dashboard now shows which kinds of issues are most common, with distribution and trend charts.

Rename a term in your glossary and Prelint rewrites everywhere it was used. Same for merges and deprecations.

A new home for your product knowledge. Paste a doc, spec, or roadmap; Prelint pulls out the rules, glossary terms, and decisions. Reviews use them as ground truth.

The same finding reworded across reviews is now recognized as one finding, so a PR gets one comment instead of many.

A second AI review that runs alongside the code review. It checks whether your PR matches your product's stated decisions and constraints, and flags how hard each change will be to undo later — schema migrations, public API shape, payment flows, anything load-bearing. Engineers see what they're locking in. Product managers see what's actually being implemented, in plain language, without reading the diff.

Pick which review kinds must pass before Prelint approves. Or set “comment only” or “silent” if you don’t want auto-approval at all.

Different projects, different main branches. Inherited from the org.

Dropdown on PRs to trigger Code Review, Decision Review, or both yourself.

First-time admins get a guided setup: pick “starting fresh” or “existing code”, connect GitHub, done.

New icon rail on the left, header bar on top. Project switcher and refer-a-friend live in the header. Fresh colors throughout.

Cmd/Ctrl+1–9 jumps between projects. Drag to reorder. Reviews, repos, and dashboard all filter to your selection.

Reviews, Sources, and Configuration are now sub-pages of /code with their own sidebar. Repos and policies scope to the active project.

Always-visible inputs, unified login methods (Google, GitHub, passkeys with Touch ID and Face ID icons).

Member invites now come from Prelint, with the same look as your login and trial emails.

Charts for issues over time and by type.

Magic links are gone. 6-digit code, works across devices, sent from our own branded emails.

Invite a friend. Both of you get extra trial days.

Choose whether reviews email you. Off by default.

PRs between main branches no longer trigger reviews.

If a review hits its budget, it tells you instead of quietly stopping.

Select multiple repos, flip them all at once.

PR already closed when the review starts? We skip it.

Fixed a path where internal model reasoning could end up in your comments.

Three new stat cards: total reviews, pass rate, and average findings per review. Filter by time period or repository.

Each repo page now shows its recent reviews inline.

Click a review, land on the GitHub PR.

Emails at key trial milestones. No more silent expiry.

If your payment method fails, the dashboard shows a clear alert with a link to update it. Admins see the fix-it link; members see who to contact.

Every finding gets a category — security, performance, correctness. Filter and prioritize.

Review summaries now use GitHub's native alert formatting with warning and caution blocks instead of tables. Finding text is truncated for readability and file paths appear as footnotes. Easier to scan at a glance.

Clean PRs get approved once. If new findings appear on a subsequent push, the stale approval is dismissed automatically. The summary comment is the single source of truth — no repeated ‘Resolved findings’ text across pushes.

Trial users now see the payment form directly, with better error recovery and clearer state transitions after subscribing.

If the GitHub App install callback fails — network error, auth expiry, browser closed — Prelint now creates the connection automatically via webhook. No more stuck state where GitHub shows ‘Configure’ but Prelint still shows ‘Connect’.

Brief infrastructure hiccups no longer delay your reviews — delivery retries right away instead of waiting its turn in a queue.

Tightened the permissions requested by our GitHub App to read-only for user profile data.

When a review finishes with no active findings, Prelint now approves the pull request instead of just posting a comment. One less manual step before you can merge.

Rename a repository on GitHub and Prelint picks up the new name automatically. No need to disconnect and reconnect.

Check review status, manage repositories, and adjust settings from your phone. The full dashboard now adapts to any screen size.

When a PR changes behavior that's described in your existing docs, Prelint flags it. Catch outdated documentation before it misleads your team.

Inline review comments now use GitHub's native alert formatting. Warnings, notes, and tips each get their own visual style — scan findings at a glance instead of reading every line.

Reduced database round-trips across the app and optimized webhook processing. Everything loads faster.

Every PR gets a single summary comment that updates in place. Active findings show severity and location; resolved ones collapse automatically.

PRs that update both code and its documentation no longer get flagged against the old cached doc version.

Prelint now skips AI tool plumbing files — hooks, skills, and MCP configs — so they don't clutter your reviews. Instruction files like .cursorrules and CLAUDE.md are still reviewed normally.

Refreshing repositories is now way faster.

The reviewer now picks up more of the relevant context from your architecture docs, compliance specs, and ADRs.

Inline comments lost the branding signature, and connecting or syncing a repo is noticeably faster.

Tell Prelint which files to skip. Lock files, build artifacts, vendored dependencies — 160+ patterns are built in. Add your own with standard glob syntax. Reviews get faster and quieter.

Ignore patterns and excluded authors now cascade down four levels. Set a rule once at the org and it flows to every repo underneath. Override at any layer when you need to.

You can now retry a failed review directly from the Reviews page. Previously you had to push a new commit to trigger another one.

The dashboard and all app pages load noticeably faster, especially on repeat visits.

Prelint posts findings as inline comments on the exact lines in your diff, instead of one block of text at the top.

Push a fix to an already-reviewed PR and Prelint only re-reviews the files that changed. Faster feedback, and findings on unchanged files don't get repeated.

Prelint tracks its own comments across re-reviews. Duplicates get deduped, and findings that no longer apply get auto-minimized. Your PR stays clean as the conversation evolves.

Reviews now run on the latest Sonnet model. Better reasoning, fewer false positives, same speed.

You can now drag files into the upload dropzone instead of clicking through a file picker.

Screen readers, keyboard navigation, and contrast ratios now meet WCAG 2.1 AA across the frontend.

A batch of infrastructure and security hardening as we work toward SOC 2 Type II certification.

You can now connect more than one GitHub account or installation to a single organization. Useful if your codebase spans multiple GitHub orgs or you're migrating between accounts.

Admins can scope member access to specific repositories instead of granting org-wide visibility. Handy for agencies or teams with contractors who should only see certain repos.

Empty pages now walk you through what to do next — connect GitHub, enable a repo, trigger your first review — instead of showing a blank screen. Each step highlights when it's your turn.

Prelint no longer reviews draft pull requests. Reviews kick in when you mark the PR as ready, so you're not burning cycles on work-in-progress.

Tightened OTP verification, subscription lifecycle handling, and auth token validation.

When a review is skipped (expired subscription, draft PR, repo not enabled), the Reviews page now tells you why instead of showing nothing.

Reviews now have a 10-minute hard cap. If something goes wrong with the model, the review stops and gets marked as failed instead of running indefinitely.

When a stuck review is detected and marked failed, the GitHub check run on your PR updates to match. No more permanently-pending status checks blocking your merge.

We're launching a startup program with $100k in Prelint credits. Register an account and reach out to hello@prelint.com to apply.

Enabling a repository is now snappier and more reliable, so you can start reviewing PRs sooner after connecting a repo.

Every team member can now browse projects, repositories, and review history — no admin role required. Give your whole team visibility into what's being reviewed.

Review limits raised to 200 per organization and 30 per repository, per hour.

If the same pull request triggers multiple review requests, only one review runs.

Team members now see an interface tailored to their role. Admin controls stay out of the way for everyone else.

The Reviews page updates in real time as new reviews complete.

Every finding is now double-checked before posting — is the claim true, is the severity right. Fewer false positives, higher confidence in every remark.

Review validation now runs on newer, more capable models for more precise quality checks in less time.

Subscribe to review lifecycle events and route them to Slack, your CI pipeline, or any HTTP endpoint.

Find any review instantly. Search and filter your entire review history from a single page.

Reviews that stop progressing are detected and flagged automatically.

Every organization gets its own isolated file system. Your code and specs never share storage with another tenant.

Prelint watches for pushes to your default branch and keeps its documentation context current automatically.

Reviews now keep what they learn about your repository between runs, so each one starts with richer context than the last.

Webhooks now retry automatically on failure. A brief outage on your end won't lose your events.

Large review lists and settings tables optimized for smoother scrolling and faster rendering.

Prelint validates whether code changes match their stated purpose, catching drift between what a PR describes and what it implements.

Prelint indexes your repository's specs and documentation, giving every review product context beyond the code diff.

Browse all review activity across your organization with expandable detail rows showing the full output.

PR review status now shows as a rich GitHub Check Run with detailed summaries instead of a simple status dot.

Prelint detects compliance frameworks like SOC 2, HIPAA, and GDPR in your repositories using AI classification, and adjusts its review focus automatically.

New dashboard with subscription status, onboarding progress, and a live review activity feed.

One-click installation as a proper GitHub App with cleaner permissions and streamlined repo management.

Attach context entries to projects and repositories to teach Prelint the domain knowledge your team relies on.

Prelint confirms it's reviewing your PR the moment it arrives, so you always know a review is on its way.

Every new organization starts with a 7-day free trial. No credit card required.