Changelog

Every decision in a decision review now gets its own collapsible block with a verdict badge — Agree, Agree with concerns, Disagree, Discuss first. The overall call sits right on the title line: Ship it, Ship with changes. Disagreements come pre-expanded, because that's the part you need to read. Under the hood, verdicts are structured data rather than parsed prose, so a badge can never contradict its reasoning.

Prelint now approves a PR only when every finding has actually been cleared. A re-review that didn't look at a file can no longer silently resolve that file's findings, and a review that hit its budget no longer counts as a pass. When you get the thumbs-up, it's earned.

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. And GitHub's secondary rate limits are treated as the transient blips they are — retried, not dropped — so fewer reviews silently disappear.

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 now notices, adds them automatically, and emails you a confirmation of the amount — with an invitation to reply if you bought twice while waiting.

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 member.permissions_changed webhook event fires on changes.

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. Payloads carry a structured source field plus transaction id and ending balance, so you don't have to parse 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 now shows a neutral Skipped badge with “Nothing to extract” — instead of a spinner that never stops. Extraction doesn't waste a pass on boilerplate, either.

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.

Parallel extraction used to mint near-duplicate topics — “Auth” next to “Authentication” — and cleanup only ran every six hours, so a freshly onboarded project looked fragmented for most of a day. Consolidation now runs right after each ingestion burst and after renames, merging duplicates automatically. Topic names got better too: capped at three words, describing capabilities rather than vendors, and no more catch-all “General”.

Importing many documents at once used to trickle through a fragile one-at-a-time relay — items could sit “queued” indefinitely or get marked failed without ever being extracted. The whole backlog now drains in one run, oldest first.

The CLI now prints its version up front, heartbeats while it waits for you to finish in the browser, and fails with something actionable on timeout — 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 the whole verification scheme inline — HMAC-SHA256 over timestamp.body, the signature and timestamp headers, replay defense — enough 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 understand how a change fits with the rest of your codebase, not just the lines in the diff. The reviewer works through a change step by step, weighing it against the surrounding code, so it 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. When that context isn't available, it falls back to reviewing the diff on its own.

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.

Listing org members no longer fans out one GitHub-identity lookup per row. Big teams render fast.

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 goes terminal instead of retrying forever. The Sources panel surfaces the error 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 shows an explicit “Ask a GitHub org admin” hint instead of a silently disabled icon. Membership is checked server-side, not from client claims.

`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 used to issue ~1,000 queries per refresh on a 20-page result. Bulk upserts collapse that to a handful per page. Staging p95 dropped from 29s.

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.

Issue-comment webhooks for repos Prelint doesn't track now short-circuit before any DB work. p95 webhook latency on busy GitHub orgs drops noticeably.

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” CTAs 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, not thrown away after fetch. Groundwork for citing who said what.

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, optimistic morphs 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 accessible names. WCAG 4.1.2 gap closed.

Click any statement to see the full audit: source excerpt next to the extracted claim, sparkline of review references, relationship graph (refines / supersedes / contradicts), provenance grid, and 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 an optional qualifier paragraph. Easier to scan; shorter to cite; still re-reviewable.

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 arbitrary key-value metadata to statements. Saleor-style — CRUD endpoints, filtering, CLI support. For tagging, routing, or your own grouping.

Org name, display name, and email at the top of the dropdown. No more guessing which account you're in.

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. Uses the same embeddings the reviewer grounds in. Available via API and `prelint statement search`.

Stuck or failed ingestions retry up to 3 times on a schedule before giving up. No more manual nudging.

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 with debounce, 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, we tell you exactly which ones are missing and link you to the GitHub page to grant access. No more wondering why your repo didn't show up.

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.

Invite buried in a junk folder? Resend from the members page. 24-hour cooldown keeps it civil.

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.

Same finding reworded across reviews? We catch it. No more 17 copies of the same comment on one PR.

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. No more empty dashboard.

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 come from us now, not Stytch. Same look as your OTP and trial emails.

Charts for issues over time and by type. You can finally see if things are getting better or worse.

Magic links are gone. 6-digit code, works across devices, our own emails instead of Stytch's.

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

Choose whether reviews email you. Off by default.

PRs between main branches don't trigger reviews anymore. They were just noise.

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’.

The webhook processor now retries gateway errors during deployments in-process instead of waiting for queue redelivery. Reviews start faster when infrastructure is briefly unavailable.

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.

Updated compression and content selection algorithms for repo documents. The reviewer picks up more relevant context from your architecture docs, compliance specs, and ADRs.

Dropped the branding signature from inline comments. Bulk DB operations instead of per-document queries, deduplicated filesystem walks, and smarter binary detection make repo connects and syncs 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 now posts findings as inline comments on the exact lines in your diff. No more scrolling through a wall of text — you see what's wrong right where the code is.

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. Long overdue, now done.

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. Nothing you need to do — things just work more reliably now.

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.

We've raised review limits to 200 per organization and 30 per repository per hour, so even your busiest repos won't hit the ceiling.

If the same pull request triggers multiple review requests, we now catch it and run only one — no more cluttered review history or wasted cycles.

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. No more refreshing to check on progress.

Every review now goes through claim verification and severity calibration before posting. 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 automatically detected and flagged, so nothing slips through the cracks.

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 run in dedicated containers with persistent storage, enabling richer repository context over time.

Webhooks deliver asynchronously with automatic retries and exponential backoff. Transient failures 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.