GPT-5.6 Luna vs GPT-6 Astra: Is een model van $1,20 goed genoeg voor code reviews?

GPT-5.6 Luna kost $0,20 per miljoen inputtokens en $1,20 per miljoen outputtokens. GPT-6 Astra kost $10 en $50. Bij dezelfde pull requests kostte één Luna-review $0,0041 en één Astra-review $0,113, een verschil van 28x.

In ons vorige bericht vergeleken we Astra met GPT-5.6 Sol. Deze keer wilden we weten wat je inlevert als elke pull request door het goedkoopste model gaat.

De korte samenvatting

Luna vond 69 geverifieerde bugs in 50 pull requests. Astra vond er 92. Luna kostte $0,20 voor de hele run en Astra kostte $5,66. Luna zat vaker ernaast: 24 van de 93 bevindingen faalden bij verificatie, tegenover 4 van de 96 bij Astra. Daarnaast vond Luna 9 van de 24 security-bugs, terwijl Astra er 19 vond.

Onze conclusie: Luna is voor deze prijs goed genoeg voor alledaagse correctheidsbugs, maar we zouden het niet alleen laten reviewen op authenticatie- of permissiecode.

Hoe we het onderzoek hebben uitgevoerd

We hebben de opzet uit het Astra vs Sol-onderzoek hergebruikt, zodat de cijfers vergelijkbaar blijven.

De pull requests (PR's) zijn de 50 publieke benchmark-PR's in de AI-Code-Review-Evals organisatie, met telkens tien stuks van Cal.com, Sentry, Discourse, Keycloak en Grafana. Elke PR introduceert defecten ten opzichte van een schone basisbranch.

Luna en Astra kregen dezelfde prompt bij dezelfde diffs. De prompt vraagt om bugs op het gebied van correctheid, security, concurrency, resources en error-handling, en sluit suggesties voor stijl, naamgeving, documentatie en tests uit. Elk model leverde gestructureerde bevindingen aan.

De verificatie werkt als volgt: voor elke pull request gaan de bevindingen van Astra, Sol, Luna en de publieke Entelligence-reviewer-commentaren in één geanonimiseerde lijst. GPT-6 Astra en GPT-5.6 Sol beoordelen deze lijst elk afzonderlijk tegen de diff, groeperen duplicaten en bepalen of een issue een echte bug is. Een issue wordt pas als 'geverifieerd' beschouwd wanneer beide juryleden het hiermee eens zijn. Ze waren het in 91% van de gevallen eens, en 143 unieke bugs werden door beiden goedgekeurd.

Omdat het toevoegen van de bevindingen van Luna de pool veranderde die de juryleden zagen, is alles opnieuw beoordeeld. Het aantal geverifieerde bugs voor Astra verschoof van 91 (in het vorige bericht) naar 92, en voor Sol van 107 naar 108. Aangezien Astra een van de twee juryleden is, kan dit een licht voordeel geven; dit wordt verder toegelicht in de sectie over beperkingen.

De resultaten

Metriek	GPT-5.6 Luna	GPT-6 Astra
Geverifieerde bugs	69	92
Totaal aantal bevindingen	93	96
Precisie	74%	96%
Totale kosten (50 PR's)	$0,20	$5,66
Kosten per geverifieerde bug	$0,0030	$0,061
Gemiddelde tijd per review	23s	36s
Gemiddelde outputtokens per review	2.104	688

Luna vond 75% van de geverifieerde bugs die Astra vond, voor slechts 3,6% van de kosten. Per geverifieerde bug was Astra 20x duurder.

Luna produceerde 3,1x zoveel outputtokens per review als Astra, maar bleef toch veel goedkoper omdat de outputprijs 42x lager ligt. Ook was het sneller, met 23 seconden per review tegenover 36 seconden.

Het team zou echter het eerst het verschil in precisie merken. Ongeveer één op de vier comments van Luna was onjuist, terwijl Astra slechts 4 van de 96 fouten maakte. Ontwikkelaars die AI-reviews al oppervlakkig scannen, zullen dat nog sneller doen als een kwart van de meldingen ruis is.

Waar Luna tekortschiet

Om te voorkomen dat een algemene score maskeert dat een model goed presteert op de ene repository en slecht op de andere, hebben we de resultaten gesplitst per codebase en bugtype.

In Sentry, Discourse en Grafana zat Luna binnen twee geverifieerde bugs van Astra. Bij Cal.com was het gat groter (21 tegenover 30). Keycloak vertoonde het grootste verschil: Luna vond 6 geverifieerde bugs tegenover 14 bij Astra, en slechts 50% van de bevindingen van Luna voor Keycloak bleek correct, tegenover 93% voor Astra.

Keycloak is een identity- en access management-server, en de meeste benchmark-PR's daarvan wijzigen de authenticatie- en permissielogica. De split per bugklasse bevestigt dit.

We hebben elke geverifieerde bug gelabeld op basis van de bronoorzaak (met behulp van GPT-5.6 Sol).

• Data- en logica-bugs (grootste groep): Luna vond er 39, Astra 47.
• Concurrency: Luna vond er 10, Astra 13.
• Security: Luna vond 9 van de 24, Astra vond er 19.

Twee voorbeelden van Keycloak-bugs die Astra wel en Luna niet vond:

1. Federated recovery-codes werden nooit als 'gebruikt' gemarkeerd, waardoor een code meerdere keren kon worden gebruikt.
2. Een globale view-permissie overrulde weigeringen (denials) die op individuele clients waren ingesteld.

Geen van deze fouten is zichtbaar op één enkele regel code; ze worden alleen ontdekt door uit te rekenen wat het permissiemodel toestaat na de wijziging.

Wat Luna wel vindt en Astra mist

Luna vond ook bugs die Astra miste. Van de 143 geverifieerde bugs werden er 44 door beide modellen gevonden, 48 alleen door Astra en 25 alleen door Luna.

Van de 25 'Luna-only' bugs waren er 16 data- en logica-bugs en 4 concurrency-bugs. In Discourse zorgde het herhalen van een unsubscribe-verzoek ervoor dat het notificatieniveau van een gebruiker bleef dalen. In Sentry verving een concurrency-bug ongezonde worker-threads zonder de oude threads te stoppen.

Het draaien van beide modellen op elke pull request zou 117 van de 143 geverifieerde bugs hebben gevonden (82%) voor een totaalbedrag van $5,86 ($0,20 van Luna bovenop de $5,66 van Astra), wat 25 extra geverifieerde bugs oplevert.

Antwoorden op vragen van lezers

Hebben de modellen de fixes simpelweg onthouden?

Een lezer merkte op dat deze repositories publiek zijn en dat de fixes voor de benchmark-bugs in de geschiedenis kunnen staan. Een model dat getraind is na deze fixes, zou een patch kunnen reproduceren. De suggestie was om PR's op datum te splitsen.

Dit is niet mogelijk met deze benchmark. De commit-dates variëren van 2013 tot 25 juli 2025. Geen van de PR's is recent genoeg om na de trainingscutoff van de modellen te vallen. Het risico is echter beperkt, omdat de defecten specifiek voor deze benchmark aan de PR's zijn toegevoegd; de exacte bug in elke diff is dus geen commit waarop een model getraind kan zijn. De omringende code is echter oud en publiek, wat een model dat de correcte versie kent, een voordeel geeft.

Vinden de modellen dezelfde bugs vaker?

We hebben twee PR's per codebase drie keer gedraaid met identieke instellingen.

• Astra: Had 15 geverifieerde bugs in de eerste run. 10 kwamen in beide herhalingen terug, en 14 in ten minste één.
• Luna: Had ook 15 geverifieerde bugs. 7 kwamen in beide herhalingen terug, en 12 in ten minste één.

Een model kan een bug in de ene run vinden en in de volgende missen; dit gold voor beide modellen, maar gebeurde vaker bij Luna.

Hoe zit het met bugs die niemand heeft gevonden?

Om 'false negatives' te meten, is een volledige lijst van alle bugs in elke PR nodig, wat de benchmark niet publiceert. We kunnen wel een ondergrens geven: 26 geverifieerde bugs werden gemist door zowel Luna als Astra en alleen gevonden door Sol of de Entelligence-reviewer. Twee daarvan waren de Discourse security-bugs uit ons vorige bericht.

Beperkingen van deze vergelijking

• Behalve de tien herhaalde PR's heeft elk model elke PR slechts één keer gereviewd.
• Astra is zowel deelnemer als een van de twee juryleden. Het feit dat Sol moet instemmen vermindert de bias, maar verwijdert deze niet volledig.
• Elke PR stamt van vóór de trainingscutoff van beide modellen.
• Beide modellen zagen alleen de diff; ze hadden geen toegang tot repository-geschiedenis, call graphs of productiedata.
• De geverifieerde aantallen zijn een ondergrens; er is geen volledige buglijst om tegen af te zetten.

Wat een diff het model niet vertelt

In deze benchmark presteerde een goedkoop model goed op de meeste wijzigingen, maar slecht op authenticatie- en permissiecode. Een diff alleen vertelt het model niet om wat voor soort wijziging het gaat.

Weten dat een bestand zich op een autorisatiepad bevindt, dat een functie wordt aangeroepen vanuit een login-flow, of dat een soortgelijke wijziging in het vorige kwartaal een incident veroorzaakte, bepaalt hoe zorgvuldig een wijziging moet worden gereviewd. Entelligence code review analyseert pull requests met volledige repository-context en koppelt productiegedrag terug naar latere reviews.

Voor coding agents stuurt de Entelligence Model Router routinestappen naar goedkopere modellen en complexere stappen naar sterkere modellen.

Dit zelf testen op je eigen code

1. Verzamel 30 tot 50 gemergde pull requests uit je repositories die later een fix nodig hadden.
2. Draai een goedkoop model en een duur model met dezelfde prompt.
3. Verifieer de bevindingen met een jury die niet een van de twee modellen is, of laat zowel een jury als een persoon een steekproef controleren.
4. Splits de resultaten per repository en per bugklasse, omdat een gemiddelde de zwakke plekken maskeert.
5. Draai een handvol PR's opnieuw om te zien hoeveel de resultaten variëren.
6. Vergelijk de kosten per geverifieerde bug en kijk apart naar de klassen waarbij een misser kostbaar is.

Veelgestelde vragen (FAQ)

Is GPT-5.6 Luna goed genoeg voor code reviews? Voor algemene correctheidsbugs kwam het in deze benchmark dicht bij Astra. Luna vond 39 data- en logica-bugs tegenover 47 van Astra voor een fractie van de kosten. Voor security-gevoelige code bleef het echter ver achter (9 van de 24 security-bugs versus 19 voor Astra).

Hoeveel goedkoper is Luna dan Astra per review? In deze test kostte een Luna-review $0,0041 en een Astra-review $0,113, ongeveer 28x minder. Per geverifieerde bug kostte Luna $0,0030 en Astra $0,061.

Is Luna onbetrouwbaarder (ruiziger) dan Astra? Ja. 74% van de bevindingen van Luna werd geverifieerd, tegenover 96% bij Astra. Ongeveer één op de vier comments van Luna was dus onjuist.

Moet je beide modellen draaien? Het draaien van beide modellen vond 117 van de 143 geverifieerde bugs voor $5,86 over 50 pull requests, vergeleken met 92 voor Astra alleen. Of de extra bugs de extra ruis waard zijn, hangt af van hoe je team omgaat met review-comments.

Kan ik dit reproduceren? Ja. De pull requests zijn publiek. De prompts, ruwe modeloutputs, jury-verdicten, bug-klasse labels, herhaalde runs en scoring-scripts zijn toegevoegd aan dit artikel.

Samenvatting

Luna vond driekwart van de geverifieerde bugs van Astra voor minder dan 4% van de kosten. Het bleef het meest achter bij authenticatie- en permissiecode, waar een gemiste bug vaak het duurst is. Een opzet die de meeste wijzigingen goedkoop reviewt en security-gevoelige wijzigingen strenger controleert, kan gebruikmaken van deze afweging, mits het systeem weet welke wijzigingen in welke categorie vallen.

***

Methodologie: 50 publieke pull requests van AI-Code-Review-Evals, gereviewd door GPT-5.6 Luna en GPT-6 Astra met een identieke, op bugs gerichte prompt, september 2026. Bevindingen van Luna, Astra, GPT-5.6 Sol en de publieke Entelligence-reviewer-commentaren werden per pull request gepoold en afzonderlijk beoordeeld door GPT-6 Astra en GPT-5.6 Sol; een bug telt alleen als beide juryleden het eens zijn. Bug-klassen werden gelabeld door GPT-5.6 Sol. Tien pull requests werden drie keer per model gereviewd. Prijzen zijn $0,20/$1,20 per miljoen tokens voor Luna en $10/$50 voor Astra.