Changelog

Look up a term instead of paging through the whole glossary. prelint glossary list takes --query, and it matches the canonical name, every alias, and the definition. Same on the API and in the MCP tools.

A statement now carries a flag when it conflicts with another one, so a search result tells you there's a problem without a second call. Narrow the contradiction list to a single statement with --statement-id.

Name the bot accounts allowed to tag Prelint on a pull request — a release bot, a dependency bot. Every bot comment used to be dropped. Bot-triggered reviews still count against your per-PR limit, so an automation loop can't run up a bill.

Search ranks by meaning and keywords together — the same retrieval reviews use — and returns a short ranked window instead of every distant neighbor. A query that used to claim 1,800 hits now returns the ones that matter.

Rate-limit windows never reset under steady traffic, so an active repo could start rejecting real GitHub deliveries — one installation lost 165 in a day, and those reviews never ran. Windows now expire on schedule.

Prelint now runs a remote MCP server. Point Claude Code or claude.ai at https://app.prelint.com/mcp and your agent can search statements, read the glossary, and check contradictions while it writes the code — instead of finding out in review. 23 tools, the same permissions as the API, and a read-only token stays read-only.

Tagging @prelint used to work only for the pull request author. Now anyone on the project's review allowlist can. Tag twice at the same commit and Prelint says the review already ran instead of charging you again.

Pending terminology changes sit on the Glossary page behind a “Requires attention” pill, not on Browse where a long backlog pushed everything else below the fold.

GitLab is a first-class platform now. Connect a group with “Continue with GitLab.com” and pick it from a list, or paste a group access token and a URL for a self-managed server. Prelint registers the webhook, reviews merge requests across the group and its subgroups, and posts inline comments and commit statuses the way it does on GitHub.

Set a reviews-per-pull-request limit at organization, project, or repository level. The default is 5. When a PR hits it, Prelint says so once and links to the setting that owns the limit. Tagging @prelint still works.

Review authors, excluded authors, ignored file patterns, and trunk branches were four separate panels. They're one Filters card now. Inherited values show as locked chips linking to the scope that set them, and the built-in defaults sit above the rows so you can see what's always applied.

The decision reviewer returns structured output instead of prose that had to be parsed, so comments render the same way every time. When a run does fail, the message names the real reason — an API error, a budget limit — instead of blaming the format.

The per-review spend cap went from $0.60 to $1.00. A third of pull requests over 5,000 lines were hitting the old cap and posting a grey check with no verdict, which reads like a hang. They finish now.

Push a fix and the re-review still looks at files carrying an unresolved finding, even when those files didn't change. The reviewer never saw them before, so a finding could be neither confirmed nor retracted and stayed open forever.

“Code Review”, “code-review”, and “code_review” are one term now, not three. Plus signs, hashes, and asterisks are preserved, so C++, LoRA+, and workspace:* stay distinct. Existing duplicates were merged.

An import run reports how many statements, terms, and topics the security filter dropped, instead of an empty result that looked like nothing was found. The filter also stopped catching ordinary product copy — a doc that quotes a jailbreak phrase, a heading called “Output format”.

Importing the same document again records another sighting of a statement you already have and refreshes its expiry, rather than minting a duplicate. Accepted statements are now unique per project by construction.

An accepted statement whose last live source is deleted goes back to pending. One that still has other sources stays accepted and swaps its evidence excerpt to a surviving source, with a history entry saying which.

Statement provenance returns one entry per time a claim was seen — source, date, verbatim excerpt, attribution, and whether that source still exists — plus a count of how many live sources back it. Existing statements were backfilled.

Comment @prelint on a pull request and Prelint reviews it at the current commit. No verb, no arguments. Mentions inside code blocks, quotes, URLs, and email addresses are ignored, so talking about Prelint doesn't set it off. Tag a draft PR and it gets reviewed.

A new trigger mode: Automatic, or Tag only. In tag-only mode nothing runs until someone comments @prelint or presses Run review. Set it per organization, project, or repository, or pick it during onboarding.

When Prelint declines to review — excluded author, trunk merge, tag-only mode — it posts a neutral check naming the reason. Repositories that make the Prelint check required no longer sit at “waiting for status to be reported”.

The decision-review prompt told the model to re-read and revise everything it had written, which on a single-turn call only bought extra tokens. About one review in three was dying on the budget or the timeout. That instruction is gone, and no review rule went with it.

An allowlist, alongside the existing exclude list. Set it at organization, project, or repository level and Prelint skips everyone else — on webhooks, on tags, and on the backfill when you enable a repo. Affected repositories carry an Allowlist badge.

When a diff is too large for the budget, Prelint used to hand the reviewer a count of what it dropped and tell it every unlisted file was unchanged. On about one review in ten the model then reported files as missing or unpatched. The omitted paths are listed by name now.

An import that finished but lost its topic structure used to look identical to a clean one. It carries a degraded badge with a reason now — on the source list, the import history, and the source page — and project health counts it.

The docs scan asked GitHub for a whole repository tree in one request, which large repos answer with a 5xx or a silent truncation, so big monorepos either never indexed or cached a slice. It walks the tree adaptively now, and refuses to act on a partial answer.

The Notion browser shows your workspace as a tree you can expand, collapse, and search, and it opens instantly from cache. Each page shows when it last synced, and re-importing a page you already have supersedes the old version instead of duplicating it.

Embedding moved to a cross-region inference profile, doubling the token ceiling that had been throttling indexing every day. Large repositories finish their doc scan without stalling, and a throttle no longer counts against a document's failure budget.

Prelint reviews each PR against the branch it targets, not just your default branch. Stacked and release branches get accurate reviews.

A re-review adds a “Since the last review” section. Every earlier concern gets a status — addressed, still open, or no longer applicable — with a link to the commit, comment, or change behind it.

New Project and Connect GitHub open the same guided setup, and you can run it again for your next project. Back works, a trip to GitHub returns you where you started, and repos already used by another project are marked.

Choose which repos to index for docs, separately from reviews — during onboarding or under Ideas → Sources. A docs-only repo re-indexes on every push, with review monitoring off.

Re-indexing a repo's docs after a push is much faster, especially on big repos.

Archived GitHub repos are hidden from the repo pickers, behind a Show archived toggle.

Edit a PR's title, body, or base branch and Prelint updates immediately.

Prelint starts only as many paid reviews as your balance covers, so you can never overdraft. Decision reviews are free and never capped.

New commands: statement confirm, statement provenance, statement location, contradictions resolve, glossary events, topic events, and ingestions delete. Lists take --page and --page-size, and stale statements are marked.

Decision reviews use plain language: short sentences, active voice, no filler. Code, file paths, and error strings stay verbatim.

Reviews read your newest statements first and rank settled ones ahead of assumed and open ones. The glossary always gets its own share of the context, and when there's too much to include, the reviewer is told how much it's seeing.

A failed document import tells you the fix: split a document that's too large, or re-import one that timed out.

Two statements that differ on a number, a date, or a qualifier — “30 days” vs “90 days” — stay separate instead of merging as duplicates.

Skipped and cancelled reviews explain themselves in plain sentences. A review cancelled because the PR closed says exactly that.

The Buy Credits card lives on Settings → Billing. Pick $10 to $250 or a custom amount up to $10,000 — each tile shows how many reviews it buys. With a card on file, one click charges it. Apple Pay, Google Pay, and Link work too, and every method is saved for auto-recharge.

If every changed file in a PR matches your ignore patterns, no review runs and you're not charged. The check says how many files matched.

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

When someone you referred runs their first review, your org gets $20 in credit and an email. The reward doesn't expire while you wait.

In comment approval mode, a clean PR gets “All clear - no findings” instead of silence.

A re-review knows about every file in the PR — including ones unchanged since the last round — so its findings stay accurate.

Pushing a new commit cancels the review still running for the old one. Re-pushing a commit Prelint already reviewed never runs or charges a second review.

Prelint can bill your organization with a Stripe invoice on net terms instead of a card charge. The invoice arrives with a payment link, shows in your history, and credits land when it's paid.

Billing settings has a Re-verify VAT ID button that checks and reports the verdict. If verification fails for good, your billing contact gets an email.

Settings → Billing has a Redeem Code button. Any member can enter a code and the credit lands right away, with the amount and expiry shown.

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.

Paging through API lists is stable — every row shows up exactly once.

Onboarding suggests the repos that belong with your most active one as your first project, and explains what a project is. Repos you leave out are simply ignored.

Saved filters load before the first data fetch — no flash of the wrong view.

The reviewer gets a list of changed files excluded from review — lockfiles, generated code, your ignore patterns — so it never guesses about changes it wasn't shown.

Each decision gets its own collapsible block with a verdict badge: Agree, Agree with concerns, Disagree, or Discuss first. The overall call sits on the title line — Ship it, Ship with changes — and disagreements start expanded.

Prelint approves a PR only when every finding has been cleared.

When your organization is out of credits, the GitHub check posts as neutral, not a red failure. Your PR doesn't look broken, and merge queues don't block.

The usage breakdown on the billing page groups reviews by who wrote the PR, so you see actual teammates. Tables say so when the 25-row cap cuts a list short.

Out of credits or between subscriptions, you can still adjust how Prelint reviews your PRs.

Export everything Prelint knows about you as JSON from profile settings — profile, memberships, preferences, and sign-in metadata. Available even while your account is pending deletion.

Org admins can retry any member's import, not just their own.

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 when permissions change.

Prelint can label your PRs with the outcome of a decision review — “ship-it” when it's clean. Toggle, rename, and recolor the labels per project or per repository.

Approval mode and draft-PR handling at the project level have an “Inherit from organization” option that shows the value you're inheriting.

Delete your account from profile settings. Type your email to confirm, get a grace window to cancel — from the app or an emailed link — and after the window, everything is purged for good.

The billing.credits_added event fires for every way credits reach your balance — purchases and auto-recharge included. Each event carries the source, transaction id, and your new balance.

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 permissions and Prelint tells you immediately.

Import an empty file or a template stub and it shows a Skipped badge with “Nothing to extract”.

Your billing contact gets an email when an auto-recharge is declined — one per decline streak, not one per attempt.

The organization switcher is an inline submenu of the account dropdown — one fewer click. In a single org, you just see its name.

Near-duplicate topics — “Auth” next to “Authentication” — merge right after each import. Topic names are three words max and describe what your product does, not which vendor it uses.

The CLI prints its version up front, shows it's still waiting while you finish in the browser, and on timeout tells you what to do.

The Sources page probes Notion, Google Workspace, and Read.ai for real: a revoked token asks you to reconnect, and a platform blip doesn't.

The Notion connector imports databases and their rows, not just pages. Databases show up labeled — “Database · 40 entries” — and import status updates live.

The webhook endpoint dialog explains signature verification right there — everything you need to build a working verifier without leaving the screen.

Change the email on your account from profile settings. The verification email carries a link that completes the change.

Referral rewards go straight onto your org's credit balance and show in the ledger with their own transaction type — real credits you can spend on reviews.

Notion imports skip unreachable sub-pages — moved, deleted, or unshared — and import everything else.

The per-repository cap on scanned documentation went from 50 files to 1,000, so reviews draw on your whole docs directory.

When the same mistake shows up in several files, Prelint flags it once — where the fix belongs — and names the other affected files in that comment. Re-reviews carry still-open findings forward and drop the ones your push fixed.

Reviews weigh a change against the surrounding code, not just the lines in the diff. That catches a helper used the wrong way, an assumption that no longer holds, or a change that breaks something elsewhere.

The projects page loads fast and shows repo and open-PR counts on every card. A project's repositories load when you expand it.

The reviewer checks your stated intent against what the diff actually does — and won't re-flag something you already explained there.

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

Every new organization starts with $10 in credits. Reviews are $1 each — ten before you pay anything. No card required.

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

A new review triggers the top-up first, so you're never blocked at $0.

Hit an hourly review limit and your PR gets a check run naming the limit, and the review detail page says so in plain words.

The members page loads fast, even for big teams.

Every member sees the org's projects, dashboard, and rollup analytics. Repo file contents and reviews still gate on GitHub access, and curation stays admin-only.

Join a second Prelint org and it offers to reuse your GitHub access — or connect a different account. Useful for consultants juggling client orgs.

Delete an ingestion, re-paste the same content, and Prelint reuses the existing row instead of stacking copies.

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

Paste “April 2” and it stays a date — no invented times — across the meeting list, ingestion history, and statement detail.

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

`prelint login` waits as long as your auth code is valid, so slow SSO still completes.

Install the Prelint GitHub App on exactly one repository and reviews turn on the moment it lands — no detour through the dashboard.

Repos left behind by a deleted project reconnect automatically. Cross-org collisions still surface for admin attention.

When Notion, Google Docs, or Read.ai fails to refresh a connection, the Sources panel flags it with a Reconnect button.

Browsing folders on /ideas now loads in a snap, even on large results.

Connecting a GitHub installation tells you exactly what was assigned to your project, what was reclaimed, and what is still in someone else's.

Reviews kick off noticeably faster on busy GitHub orgs.

Pick another organization from the profile dropdown and the session swaps in place.

If a Notion, Google, or Read.ai connection expires, the browse page tells you and gives you a one-click Reconnect.

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

Extraction picks up end dates in your content (“valid until Q2”), and expired statements drop out of review grounding automatically. Re-attest with one click if it's still true.

Attendee lists and meeting duration are kept alongside each ingestion.

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 splits into Meetings, Documents, and History — time-grouped meeting cards, a flat document list with provider metadata, and unified ingestion history with filters.

Side-by-side boxes for the new claim and the one it contradicts. Resolve, and the losing side fades out. Statement cards got tighter typography and instant Accept/Reject feedback.

Each statement card shows how often reviews cite it. Two bars means real repeat use; three means it's load-bearing.

The `prelint` CLI refreshes its OAuth token in the background, so you stay logged in.

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

Click any statement to see the source excerpt next to the extracted claim, how often reviews cite it, how it relates to other statements, where it came from, and its history.

One page per project surfacing what needs attention — failed reviews, pending triage, setup gaps, tips — grouped by severity.

Code Review and Decision Review for the same PR share one row. Status is a colored dot, and repo and org names link out to GitHub.

Reply to a Prelint comment and fix the issue — Prelint reacts with 👍 so you know it registered. Re-reviews 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.

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

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

One concise lead sentence, then optional detail.

Dedup also catches duplicates within one import, so a single ingestion can't produce five near-identical rules.

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

The header balance pill shows only when reviews are paused, or when the balance drops below $20 with auto-recharge off.

Recurring meetings with identical titles 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`.

GitHub check runs and the dashboard explain a failed review in plain words — what went wrong and what to do.

Failed reviews email you too, not just successful ones.

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

The “add a passkey” prompt 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.

Enabling code review on a repo auto-enables document tracking. Disabling it turns tracking off too.

README files, ADRs, and architecture docs get extracted into Prelint's knowledge base automatically — same dedup, contradiction detection, and review context as Notion or Google Docs. Nothing to configure; 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. Search as you type; import one at a time or in bulk.

Project pages live at /projects/<slug>/… Bookmark any view, and share links that open in the right project every time.

Rename a project's slug and every URL updates.

If Prelint can't see a private repo 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 drops statements that already exist in your knowledge base, even when worded differently. Borderline cases get a second-pass check.

New content that refines an existing topic updates it in place. Renames auto-apply; merges and archives surface for review.

Sprint plans, demo dates, and deadlines get a “time-sensitive” badge — visible, but out of the pile of durable product rules.

Extraction filters out market stats and strategy prose, so your knowledge base holds things a reviewer can act on.

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

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

Rename a term in your glossary and Prelint rewrites it 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 counts as one, so a PR gets one comment instead of many.

A second AI review that checks whether your PR matches your product's stated decisions, and flags how hard each change will be to undo — schema migrations, public API shape, payment flows. Engineers see what they're locking in. Product managers see what's being built, in plain language, without reading the diff.

Pick which review kinds must pass before Prelint approves — or set comment-only or silent mode if you don't want auto-approval at all.

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

A dropdown on PRs triggers 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 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).

Charts for issues over time and by type.

Magic links are gone. A 6-digit code works across devices.

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.

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

Each repo page shows its recent reviews inline.

Click a review, land on the GitHub PR.

Emails at key trial milestones, so a trial never expires silently.

If your payment method fails, the dashboard shows an 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.

Summaries use GitHub's native alert formatting, 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 later push, the stale approval is dismissed automatically.

Our GitHub App requests read-only access to user profile data.

A review with no active findings approves the pull request — one less manual step before you can merge.

Rename a repository on GitHub and Prelint picks up the new name automatically.

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

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

Inline comments use GitHub's native alert formatting. Warnings, notes, and tips each get their own visual style.

Everything across the app 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 docs are reviewed against the new docs, not a cached version.

Prelint skips AI tool plumbing — hooks, skills, MCP configs. Instruction files like .cursorrules and CLAUDE.md are still reviewed.

Refreshing repositories is now way faster.

The reviewer 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 cascade down four levels. Set a rule once at the org and it flows to every repo underneath. Override at any layer.

Retry a failed review directly from the Reviews page.

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, no repeated findings on unchanged files.

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

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

Drag files into the upload dropzone instead of clicking through a file picker.

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

We're working toward SOC 2 Type II certification.

Connect more than one GitHub account or installation to a single organization — useful when your codebase spans multiple GitHub orgs or you're migrating between accounts.

Admins can scope member access to specific repositories. Handy for agencies or teams with contractors who should only see certain repos.

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

Draft pull requests aren't reviewed. Reviews kick in when you mark the PR as ready.

When a review is skipped — expired subscription, draft PR, repo not enabled — the Reviews page tells you why.

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 faster, so your first review starts sooner.

Every team member can browse projects, repositories, and review history — no admin role required.

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 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 double-checked before posting — is the claim true, is the severity right. Fewer false positives.

Review validation 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.

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

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

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

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

Webhooks retry automatically, so a brief outage on your end won't lose your events.

Large review lists and settings tables scroll and render faster.

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 rows showing the full output.

PR review status shows as a rich GitHub Check Run with detailed summaries, not a simple status dot.

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

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

Install as a proper GitHub App in one click, 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 opens, so you always know a review is on its way.

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