Je betaalt niet voor code reviews. Je betaalt voor stoelen.

Doe de deling op je AI-code-review-rekening. Niet de adviesprijs, maar de werkelijke deling: wat je vorige maand hebt betaald, gedeeld door het aantal pull requests dat het heeft beoordeeld. Ik deed het voor ons team en het getal was zoveel slechter dan het getal op de prijspagina dat ik dacht dat ik een fout had gemaakt.

Ik had geen fout gemaakt. Ik had het product gewoon gekocht zoals het aan mij werd verkocht, in plaats van zoals wij het gebruiken.

Hier is de stelling, en alles hierna is het bewijs ervoor. AI-code-review wordt verkocht per ontwikkelaar en verbruikt per pull request. Die twee getallen hebben niets met elkaar te maken, en de kloof ertussen is waar je geld naartoe gaat. Daarnaast, en erger nog, het hulpmiddel waar we voor betaalden las een diff met zes echte defecten en vond er één.

We vervingen het door iets dat we zelf bouwden. Ik ga je de bonnen laten zien voor beide beweringen, inclusief de delen die ons er slechter laten uitzien.

Zes defecten gingen erin. Eén kwam eruit.

De pull request was een autosave-refactor in ons platform. Gewoon, middelgroot, het soort dat op een dinsdag wordt geopend en waar niemand wakker van ligt. Greptile beoordeelde het, liet twee opmerkingen achter en ging verder.

Daarna ging een van onze engineers handmatig door de diff en beoordeelde het goed, waarbij hij elk echt defect noteerde zonder te kijken welk hulpmiddel wat had gemeld. Zes defecten. Vier daarvan P1, het soort dat gebruikersgegevens beschadigt in plaats van iemand te irriteren.

Autosave her-armed zichzelf voor altijd na het normaliseren van waarden. Een mislukte opslag probeerde het opnieuw in een oneindige lus. Autosave overschreef wat de gebruiker actief aan het typen was in een ander tabblad. Een opslagpromise werd weggegooid zonder afhandeling. Het verlaten van de pagina liet alles in behandeling vallen. De opslagknop werd alleen weergegeven wanneer de stap niet kon worden opgeslagen.

Een van die zes werd gemeld.

Geen van die zes bereikte de productie, en ik wil precies zijn over waarom, want de reden is het hele punt. Ze werden opgemerkt omdat een mens de diff las. Niet omdat de reviewer ze tegenhield. We betaalden voor een vangnet dat één ding uit zes ving, en het ding dat de andere vijf ving was een engineer die de code regel voor regel las, precies de activiteit die het product zou moeten verminderen.

Zelfverzekerd achterstevoren zijn is erger dan niets zeggen

Er was een zevende bevinding. Die was niet echt.

Er werd ons verteld ‘mislukte autosave heeft geen herpoging’. Het werkelijke defect, in dezelfde functie, was het tegenovergestelde: mislukte autosave probeerde het voor altijd opnieuw. Geen gemiste bug. Een omgekeerde.

Ik heb over die ene meer nagedacht dan over de vijf missers samen. Een misser is stilte, en stilte is overleefbaar, omdat je al aanneemt dat je reviewer niet alwetend is. Een omkering is erger dan stilte. Het stuurt een engineer naar het juiste bestand op zoek naar het verkeerde, en wanneer ze het ding dat er nooit was niet vinden, sluiten ze het bestand en markeren het als beoordeeld. Een vals rapport helpt je niet alleen niet. Het verbruikt je aandacht, en het verbruikt het op de exacte plek waar de echte bug zich verborg.

Eén echte bevinding. Één achterstevoren bevinding. Zes defecten in de diff.

Eén model betekent één blinde vlek, en je zult nooit de vorm ervan leren kennen

Mijn eerste reactie was dat we het verkeerde hulpmiddel hadden gekocht. Die reactie was verkeerd, en eroverheen komen duurde langer dan ik wil toegeven.

Elk frontier-model heeft blinde vlekken en dat zijn niet dezelfde blinde vlekken. Dat is geen defect in het product van een bepaalde leverancier, het is wat deze systemen zijn. Wat betekent dat als je je reviewproces op precies één model bouwt, je het hebt gebouwd op precies één patroon van blindheid, en je zult nooit de vorm van dat patroon leren kennen, omdat het enige instrument dat het je zou kunnen tonen het instrument is dat blind is.

Laat me dit uitleggen. Het probleem is niet dat je reviewer slecht is. Het probleem is dat je reviewer enkelvoudig is. Een tweede mening was nooit een luxe in code review, het was het hele mechanisme waarmee code review werkte, en we hebben het stilletjes laten vallen op het moment dat we het automatiseerden.

Dus bouwden we Juror. Verschillende frontier-modellen beoordelen dezelfde diff parallel, elk via zijn eigen native agent-harnas, elk vrij om je repository te doorzoeken zoals de leverancier het bedoeld heeft. Hun bevindingen worden samengevoegd, zodat drie bijna-identieke rapporten van één defect één bevinding worden in plaats van drie, en wat op de pull request terechtkomt is één enkele opmerking.

We draaiden het tegen dezelfde commit.

Reviewer	Gevonden	Precisie	Kosten	Tijd
Greptile	1 van 6	50%	niet bekendgemaakt	niet bekendgemaakt
Juror	4 van 6	100%	$1,08	8m22s

Hier is het deel waar we verliezen

Juror miste er twee.

Greptile ving de weggegooide opslagpromise en wij niet. Geen van beide hulpmiddelen vond de oneindige herpogingslus. Zet beide reviewers samen en je krijgt vijf van de zes, wat beter is dan elk afzonderlijk presteerde, en ik ga dat niet verbergen onder de tabel hierboven.

Ik had deze sectie kunnen weglaten. Ik houd hem omdat het het argument is. Verschillende modellen vangen verschillende dingen. Dat is geen ongemakkelijk voorbehoud dat aan onze pitch is geniet, het is de pitch, en een model van een concurrent dat iets vindt dat wij misten is de beste demonstratie die er is dat het draaien van één enkele reviewer de fout is. De dag dat dat stopt met gebeuren is de dag dat ik me begin zorgen te maken dat onze jury is ingestort tot één mening met vier hoeden.

Je betaalt niet voor reviews

Nu de rekening, waar dit ophoudt over één pull request te gaan.

Greptile’s Pro-plan is $30 per zetel per maand, per augustus 2026. Dat omvat 50 credits per zetel, waarbij één credit een standaardreview koopt en drie een diepere, en extra credits zijn $1 per stuk.

Per review is dat goedkoop. Ongeveer zestig cent, als je alle credits gebruikt die je krijgt. Ik wil hier volledig eerlijk zijn: op basis van eenheid is dat lager dan wat onze eigen tool kostte voor de bovenstaande pull request. Een klein team dat zijn tegoed volledig opmaakt, moet de seats kopen, en ik ga niet doen alsof dat niet zo is.

Niemand maakt zijn tegoed volledig op.

Je wordt gefactureerd per ontwikkelaar. Je verbruikt reviews per pull request. Die twee getallen houden elkaar niet meer bij zodra het aantal medewerkers sneller groeit dan de merge-snelheid, wat meteen het geval is, in elke engineeringorganisatie die ooit heeft bestaan. Twintig engineers op Pro is $600 per maand en duizend credits. Als dat team 150 pull requests merged, een volkomen normale maand, heb je $4 per review betaald en 850 credits laten verlopen.

De catalogusprijs is nooit veranderd. Jouw benutting wel. Zestig cent werd vier dollar en niemand stuurde je er een e-mail over.

Noem het de seat tax: geld uitgegeven aan een per-ontwikkelaarlicentie voor een product dat per artefact wordt verbruikt. Het is onzichtbaar op de prijspagina, het schaalt met werving in plaats van gebruik, en het is de grootste kostenpost in wat je daadwerkelijk betaalt.

Ik kan je vertellen wat dit kost omdat we de bon afdrukken

Juror heeft geen seats. Het draait in je eigen GitHub Actions-runner, roept de model-API’s aan met je eigen sleutels, en de rekening is de inferentie en niets anders. Die review van de autosave-PR, vier echte defecten en geen valse positieven, kostte $1.08 en duurde acht minuten en tweeëntwintig seconden.

Ik kan je dat tot op de cent vertellen omdat elke Juror-review eindigt met een tabel: elk model, zijn inputtokens, zijn gecachte tokens, zijn outputtokens, zijn dollars. Elk cijfer is gelabeld reported wanneer de provider het heeft berekend, of estimated wanneer we het hebben afgeleid van gepubliceerde catalogusprijzen. Wanneer een harness ons geen van beide geeft, print het unknown en wordt het totaal gemarkeerd als een ondergrens. We raden niet en we ronden niet naar onszelf toe.

Kijk nu nog eens naar de twee cellen in die tabel die “not disclosed” zeggen. Dat is geen gat in mijn onderzoek. De tool vertelt je niet wat een review kost, omdat het dat niet hoeft. Je hebt een seat gekocht. De eenheidseconomie is de zaak van de leverancier, en de leverancier wil liever dat je de vermenigvuldiging op hun manier blijft doen.

Dat was het ding dat ik eigenlijk wilde en voor geen prijs kon kopen. Geen goedkopere reviewer. Een reviewer die me vertelt wat het heeft uitgegeven.

Wat ik niet ga doen is dit een benchmark noemen

Dit is één pull request.

Ons eigen benchmarkingprotocol zegt dat een vervangingsbeslissing 20 tot 30 beoordeelde PR’s nodig heeft die frontend, backend, migraties, concurrency, beveiligingsgevoelige code, en zowel kleine als grote diffs omvatten. We hebben er één. Het staat in de repository met een waarschuwing erbij dat het niet mag worden gepresenteerd als statistisch voldoende bewijs dat de ene reviewer de andere kan vervangen, en ik ga onze eigen waarschuwing niet overtreden in een blogpost over hoe zorgvuldig we cijfers rapporteren.

Vier van de zes tegen één van de zes is geen benchmarkresultaat. Het is één beoordeelde casus die me bereid maakte om beide naast elkaar te laten draaien. Een andere pull request, die sterk leunt op repository-brede context waar een geïndexeerde reviewer het goed zou moeten doen, zou het plausibel kunnen omkeren. Als dat gebeurt, gaat die casus ook in de corpus.

Wat geen steekproef van één is, is de rekenkunde. Dertig dollar per seat maal twintig engineers is $600 of ik het nu leuk vind of niet, en 150 reviews tegen duizend credits is 15% benutting in elke maand die je wilt meten. We zijn overgestapt op de prijsstructuur, die ik met deling kan verdedigen, en op één veelbelovende casus. Niet op een prestatieclaim die we nog niet hebben verdiend.

Ga ons meten

Neem mijn woord niet aan voor dit alles. Ik heb een commercieel belang bij jouw conclusie en je moet alles hierboven dienovereenkomstig wegen.

Zet beide reviewers in shadow mode op je eigen repository. Laat ze een paar weken draaien zonder dat een van hen een merge blokkeert. Neem dan elke bevinding, verwijder de labels zodat niemand weet welke tool wat zei, en laat een senior engineer ze koud beoordelen tegen de code. Tel wat elke tool heeft gevonden. Tel wat elke tool heeft verzonnen.

We hebben de tooling precies hiervoor uitgebracht, omdat we het zelf nodig hadden:

npx juror-ai benchmark --file your-corpus.json

Het rapporteert recall, precision, duplicate rate, cost en latency voor elke reviewer die je erin stopt, en het vermeldt elke miss bij naam. De onze inbegrepen.

Ik denk niet dat het seat-model contact overleeft met iemand die de deling doet. Het overleeft nu omdat de deling licht vervelend is en de prijspagina zo is ingericht dat je er geen moeite mee doet. Iemand in je organisatie voert die berekening uiteindelijk uit. Wanneer ze dat doen, zal het antwoord geen zestig cent zijn.

Die autosave-pull request is vanmorgen gemerged, toevallig. Het kostte nog twee commits om daar te komen, één om navigatie-opslagen single-flight te maken en één om autosave te laten convergeren en de builder met rust te laten. Goede commits. Niets in brand.

Niemand zal ooit weten dat ze nodig waren, omdat bugs die voor de merge worden gevangen geen spoor achterlaten en geen incidentrapport genereren. Dat is het deel hiervan dat je zou moeten storen. De reviewer die er vijf miste, kost hetzelfde of hij er nu zes of nul vindt, en hij zal je nooit vertellen voor welke van die twee maanden je zojuist hebt betaald.

---

Juror is open source en MIT-licentie: github.com/juror-ai/juror. Greptile-prijzen geciteerd van greptile.com/pricing per augustus 2026.