Nib learns your standards and your voice from your own review history, drafts the review as a native GitHub pending review, and waits. You read it and hit submit. Or, once it has earned it, you hand it the pen and stop reading.
Three paragraphs where you'd have written six words. Your teammates learn the pattern in a week and start scrolling past it.
Formatting the linter already fixed. Style preferences. "Consider extracting this." Signal drowns, and you end up reading the PR yourself anyway.
The documented pattern: adopt a reviewer, hit false positives, tune it out within two weeks. After that the one comment that mattered scrolls by with the rest.
The value was never "AI finds bugs" — several tools do that well. It's that a review only lands if the person reading it hasn't already learned to skip your bot. So there is no bot: it writes as you, and nothing posts until you say so.
Nothing crosses the dashed line without a mandate — yours in the moment, or one you granted the repo in advance. Cyan is work Nib does on its own; amber is where control changes hands.
A poll every five minutes, or a webhook the moment someone asks you.
Secrets are scrubbed before anything leaves. Lockfiles, build output and far context are dropped — about 72% of the diff never reaches a model.
A free deterministic pass picks the cheapest model that can do the job, and steps up only on risky paths.
Docs-only, lockfile bumps, pure formatting. Skipped before any model runs, at zero cost.
One structured object, every anchor checked against the diff, written to GitHub where only you can see it.
Review, approve or comment yourself and that PR is yours. Per PR, reversible whenever you say.
Read the draft and send it as yourself. Or hand over the pen, per repo, and stop reading.
lanes = who owns the step · badges = ordered steps · amber = control passes to you · cyan = automatic
Real drafts, in the owner's voice. Where the fix is obvious it ships a one-click
suggestion block instead of describing it.
Most PRs end here. Approvals are one or two words; a specific compliment only when something in the diff earned it, never a template.
flex flex-row → flexHeld-back comments stay in the trace. That list is how you tune it: raise a threshold, or lower one.
Not a mock in our database — an actual pending review. Inspect it, edit it, discard it or submit it inside GitHub itself. The dashboard is a convenience, never the only path.
The moment you review, approve or comment yourself, that PR is yours. Nib stops. It re-engages only when you say so, per PR, and the dashboard shows you every PR it's stood off from.
Draft only — nothing posts until you submit. Auto-approve — clean PRs go out alone, anything with a comment still waits. Fully autonomous — reviews with comments post too.
Per repo, reversible in one click, and every level still gated at run time: confidence floor, inside your active hours, and never while a bug or security comment sits held back. A grant is permission, not a blank cheque.
Every draft carries its trace: model, prompt version, persona version, head SHA, tokens, cost, latency, and the comments it decided to hold back.
On posting as you. A GitHub App can only post as a bot, so reviews go out under your own account with a disclosure footer. Autonomous posting without that footer is blocked by policy — a product rule, not a setting.
Numbers from a 25-PR audit against a real repository. Run pnpm audit against your own and
get your own table — the settings page quotes your figures, not ours.
| Provider | Onboarding | Avg / review | Median |
|---|---|---|---|
| Local Ollama, LM Studio | One click if a runtime is up | free | free |
| OpenAI mini tier | Paste a key | $0.0027 | $0.0010 |
| Anthropic Haiku → Opus | Paste a key | $0.0084 | $0.0028 |
Keys are encrypted at rest and verified with a real round-trip when you save them. Neither Anthropic nor OpenAI issues API keys through an OAuth flow, so those two need a pasted key — we say so rather than pretending otherwise. A local model is free but misses more; the settings page reports the share of drafts you submitted unedited per provider, so the trade is visible instead of assumed.
Three signals: what you say explicitly ("shorter", "cite the convention"), what you silently cut before submitting, and what your teammates do with the comment afterwards. A nightly pass turns them into a proposed change to how you sound — as a diff you approve, reject or edit.
Versioned, so a regression is one click to revert. Every run records which version wrote it.
Not one hard review — nine easy ones, stacked, each costing a context switch. The tool that finds a subtle race condition in PR #4 hasn't helped if you still have to open all nine.
Docs-only, lockfile bumps, pure formatting — skipped before any model runs, at zero cost. 8% of PRs in our audit disappeared here.
Each one is already drafted in your voice with a verdict attached. An approve is a five-second read, not a five-minute one.
Clear the queue from a single screen instead of nine GitHub tabs. Submit, edit, or discard. Anything you take over yourself, it drops. Repos you trust, it can clear on its own.
The documented failure mode of AI review isn’t bad findings — it’s volume. Teams adopt a reviewer, hit false positives, and tune it out within two weeks. Once your team learns to scroll past the bot, the good comment goes past too.
Nib has no bot to tune out. Reviews go out under your name, in your words, only after you press submit. A teammate can’t learn to ignore you.
| Typical AI reviewer | Nib | |
|---|---|---|
| Who posts | A bot account, on its own schedule | You. Reading first is the default, not the ceiling — hand it the pen per repo when it has earned it |
| Voice | House style, same for every user | Yours, learned from your own past reviews |
| When it's wrong | Your teammate reads it and replies to a bot | You delete the line before it exists |
| Noise control | Server-side thresholds you can't see | Held-back comments shown to you, thresholds calibrated from what you dismiss |
| Price | $24–30 per developer per month | Free. Bring your own key, or run a local model for $0 |
| Model | Whatever the vendor picked | Anthropic, OpenAI, or local — you choose, per repo |
| Your code | Goes to their servers | Self-hosted. With a local model it never leaves the machine |
| Repo context | A paid tier, usually | Built mechanically from the GitHub API — costs nothing |
Pricing as published mid-2026: CodeRabbit Pro ≈$24/dev/mo annual, Greptile $30/seat, Qodo Teams $30/user. We’re not claiming they find fewer bugs — several are very good at that. The claim is narrower and, we think, more important: a comment only lands if the person reading it hasn’t already learned to skip your bot.
No seats, no trial clock, no per-review meter. Self-host it and point it at whichever model you want. The only bill is whatever your provider charges for the tokens — around $0.008 a review on Anthropic, $0.003 on OpenAI’s mini tier, and nothing at all on a local model.
At a team of ten, a per-seat reviewer runs $240–300 a month. The same ten people on Nib with a paid model land near $10, and on a local model, zero. That’s not a promotion — it’s what happens when you don’t resell someone else’s inference.
Not the pen, not the ink — the tip that meets the page and makes the line yours. It seemed the honest object for a tool that doesn't write for you in a voice of its own, but writes as you, in yours, and leaves you to decide whether the ink lands.
The category is full of creatures and minerals. A small thing you hold says something truer about what this actually does.