# Per-stoel facturatie verandert een code review van 60 cent in $4

> Je wordt gefactureerd per ontwikkelaar en je verbruikt reviews per pull request. Hier is de verdeling, plus de beoordeelde pull request waar onze AI-reviewer één defect van de zes heeft gevonden.

- Source: https://jays.fyi/nl/blog/per-stoel-facturatie-60-cent
- Author: Jay Derinbogaz
- Published: 2026-08-08
- Language: nl
- Tags: tooling, code-review, pricing
- Reading time: 10 min
- Machine translated: yes — original: https://jays.fyi/blog/how-i-removed-greptile

---

<figure>
  <img src="/images/greptile-receipt-august-2026.png" alt="Ontvangstbewijs van Greptile voor $861,00, betaald op 3 augustus 2026." width="1012" height="783" decoding="async" fetchpriority="high" />
  <figcaption>Eén maand Greptile, augustus 2026. Op de prijspagina staat $30.</figcaption>
</figure>

Doe de deling op je AI-code-review-rekening. Niet de adviesprijs, 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 alleen gekocht zoals het aan mij werd verkocht in plaats van zoals wij het gebruiken.

Hier is de stelling, en alles hierna is 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 waarvoor we 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 uit laten zien.

## 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, plaatste twee opmerkingen en ging verder.

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

Autosave herstelde zichzelf voor altijd na het normaliseren van waarden. Een mislukte opslag probeerde het opnieuw in een oneindige lus. Autosave overschreef wat de gebruiker actief typte in een ander tabblad. Een opslagpromise werd onafgehandeld weggegooid. Het verlaten van de pagina liet alles hangende vallen. De opslagknop werd alleen weergegeven wanneer de stap *niet* kon worden opgeslagen.

Eén 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 ontdekt omdat een mens de diff las. Niet omdat de reviewer ze tegenhield. We betaalden voor een vangnet dat één van de zes ving, en wat 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 model betekent één blinde vlek, en je zult nooit de vorm ervan leren

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

Elk frontier-model heeft blinde vlekken en het 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, 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 harness, 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 | Found | Precision | Cost | Time |
| --- | --- | --- | --- | --- |
| Greptile | 1 of 6 | 50% | niet bekendgemaakt | niet bekendgemaakt |
| Juror | **4 of 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 tools vond de oneindige herpogingslus. Zet beide reviewers samen en je krijgt vijf van de zes, wat beter is dan wat elk afzonderlijk presteerde, en ik ga dat niet onder de bovenstaande tabel begraven.

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 concurrent's model die iets vindt wat wij misten is de beste demonstratie die er is dat het draaien van één 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 petten op.

## Je betaalt niet voor reviews. Je betaalt voor stoelen.

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

[Greptile's Pro plan](https://www.greptile.com/pricing) is **$30 per seat per month**, as of August 2026. That includes 50 credits per seat, where one credit buys a standard review and three buy a deeper one, and further credits are $1 each.

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

Niemand verbruikt zijn tegoed volledig.

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 wil zeggen: onmiddellijk, 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 kostte 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 fout-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 als `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 in ons voordeel af.

Kijk nu nog eens naar de twee cellen in die tabel die 'niet bekendgemaakt' zeggen. Dat is geen hiaat in mijn onderzoek. De tool vertelt je niet wat een review kost, omdat 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](https://github.com/juror-ai/juror/blob/main/docs/benchmarking.md) 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. Wij 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 schenden 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 het 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 beiden een merge blokkeert. Neem dan elke bevinding, verwijder de labels zodat niemand weet welke tool wat zei, en laat een senior engineer ze koud tegen de code beoordelen. 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:

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

Het rapporteert recall, precisie, duplicate rate, kosten en latentie voor elke reviewer die je erin stopt, en het vermeldt elke misser bij naam. De onze inbegrepen.

Ik denk niet dat het seat-model het overleeft in contact met iemand die de deling doet. Het overleeft nu omdat de deling licht irritant is en de prijspagina zo is ingericht dat je er geen moeite voor doet. Iemand in jouw 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-gelicentieerd: [github.com/juror-ai/juror](https://github.com/juror-ai/juror). Greptile-prijzen geciteerd van [greptile.com/pricing](https://www.greptile.com/pricing) per augustus 2026.*
