co-maintainer,
an imitator of yours

Three pull requests, six months apart, three contributors. The same comment every time, worded a little differently every time. The rule is real and everyone knows it. It is just nowhere a machine can read it.

A reviewer reads the patch while quietly holding four years of this codebase. Here is what that is worth.

The types compile, because a branded number is still a number. The fee comes out fractional, ledger.post() asserts integers, and the refund throws on the first amount that does not divide evenly.

A missed finding is usually a missing input, not a weak model.

Handing the model a whole repository on every review is possible, and absurd. So the reading happens once, off to the side, and what comes out is small enough to carry.

The reason it happens once:

Models are rented. Whichever one is best this quarter will not be best next quarter. The context is the part you own.

Read them out loud and they sound like the person who has been merging into this repository for two years. That is where the title comes from. It is not trying to be a better reviewer than your team, it is trying to be a cheap imitation of the one you already have, awake at 2am, on the boring pull requests too.

A pull request opens. The guides are already on disk, so the reviewer starts from a repository it has read instead of a patch it has never seen.

Charge providers: percentage refund fee #312 northwind:feat/refund-fee Open

Review / co-maintainer reading guides and diff…2 findings, 1 blocking 24sDetails

co-maintainerbot reviewed just now

Reviewed against SKILL.md, CODEBASE.md and PR_REVIEW_GUIDE.md for this repository, with codegraph enabled.

1 blocking 1 non blocking 9,312 tokens 24.7s $0.0041

src/billing/refund.ts+3−0

3939export function refundFee(amount: Money) {

40 const fee = amount * 0.029;

41 return { fee, net: amount - fee };

4042}

P1 · blocking

refundFee() returns a fractional amount. ledger.post() asserts an integer count of minor units, so every refund whose fee does not divide evenly throws in production instead of rounding. CODEBASE.md puts rate math through mulRate for exactly this reason.

src/billing/refund.ts:41 · 3 call sites reach this

Suggested change

41 const fee = amount * 0.029;

41 const fee = mulRate(amount, 29, 1000);

Commit suggestion Add to batch

Without the guides there are two honest options here. Say nothing, because a percentage fee is a normal thing to write. Or say something vague about floating point, which everybody has learned to scroll past.

• Findings carry over. Push a fix, run it again, and the finding closes instead of being raised twice.
• A blocking finding exits non zero. That is all CI needs.
• --json on stdout, logs on stderr. Findings, counts, tokens, duration, codegraph state, one document.
• Codegraph is optional. On by default, and the binary is installed on request, not behind your back.

There are only three answers people actually want: the mess in my working tree, that pull request over there, and the first one without making every laptop pay for init.

Somebody joins on Monday and clones the repository. Local review wants guides, guides want init, and init wants minutes and money. Paying that once per laptop is how a tool dies in its third week.

The boring safety bits. Tokens are hashed at rest, and deactivating one cancels every review in flight for it. The CLI prints a one time notice per host the first time it uploads a diff, so nobody finds out by reading the source six months later.

co-maintainer serve is one process and one app.db. It carries the GitHub App webhook, a job worker, the dashboard, and the remote review API from the last act.

localhost:5000

Add a repository and init runs as a job you can watch. Flip auto review on and a pull request opening is enough to start one. The repo above has been connected for 8 days. Everything, init, remake and every review included, cost $1.20 in total.

Thirty pull requests on a repository of mine. Fourteen carry a deliberately seeded, hand verified defect. Sixteen are clean controls, which is the part most review benchmarks skip and the part that makes precision measurable.

Every defect that needed something outside the diff was caught. The two misses are on the axes where everything needed was already sitting in the patch, which is funny and slightly humbling: the context machinery works, ordinary close range reading is what still slips.

Thirty pull requests, no repeat runs, so variance is unmeasured. It raises about one unnecessary finding per clean pull request, and that number is what decides whether a team keeps a review bot or mutes it.

The question was never which model reviews best. Models change every few months and the answer expires with them. The question is what the model is holding when it starts. Giving it more context does not make the prediction more accurate.

1. 01less context
2. 02less hallucination
3. 03faster reviews
4. 04more accurate predictions