💻 computer science

DryRUN: On the Role of Public Tests in LLM-Driven Code Generation

Het artikel introduceert DryRUN, een framework dat de afhankelijkheid van handmatig opgestelde publieke testgevallen voor LLM-gestuurde codegeneratie elimineert door modellen in staat te stellen zelf inputs te genereren en uitvoeringstraces te simuleren voor zelfcorrectie, wat resulteert in vergelijkbare prestaties met state-of-the-art methoden maar met minder tokenverbruik.

Oorspronkelijke auteurs: Kaushitha Silva, Srinath Perera

Gepubliceerd 2026-04-24

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Kaushitha Silva, Srinath Perera

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een kok bent die een nieuw recept moet bedenken voor een gerecht dat nog nooit eerder is gemaakt. Je krijgt een beschrijving van het gerecht, maar geen foto's van hoe het eruit moet zien en geen proefporties om te smaken.

De oude manier (zoals CodeSIM):
In de huidige wereld van kunstmatige intelligentie (AI) die code schrijft, werkt het vaak zo: de AI krijgt een recept, maar ook een paar voorbeelden van hoe het gerecht eruit moet zien (bijvoorbeeld: "dit is een proefportie van de soep, het moet zout zijn").
De AI kookt, proeft aan die ene proefportie, en als het smaakt, denkt hij: "Perfect, klaar!" en serveert het op.
Het probleem: Die proefporties zijn vaak heel simpel. De AI kan zich zo goed aanpassen aan die simpele proefportie dat hij vergeet dat het gerecht misschien ook voor iemand met een andere smaak moet werken. Hij wordt te zelfverzekerd. Hij denkt dat hij een meesterkok is, maar als de echte klant (de "verborgen test") komt, valt het gerecht tegen. Dit noemen de auteurs de "Overconfidence Gap" (het zelfvertrouwensgat).

De nieuwe manier: DryRUN
De auteurs van dit papier, Kaushitha en Srinath, hebben een nieuwe methode bedacht die ze DryRUN noemen. Het woord betekent letterlijk "droog lopen" of "proefdraaien zonder water".

Hier is hoe het werkt, vertaald naar een alledaags verhaal:

Geen proefporties: De AI krijgt geen voorbeelden van hoe het gerecht eruit moet zien. Geen foto's, geen smaaktesten. Alleen de beschrijving van het recept.
Eigen proefporties bedenken: In plaats van te wachten op een proefportie van de chef, denkt de AI zelf na: "Oké, als ik dit recept maak, wat zou er dan gebeuren als ik heel veel peper doe? Of als ik de pan te heet maak?" De AI verzonnt zelf moeilijke situaties.
Mentaal proefdraaien: De AI doet alsof hij kookt in zijn hoofd. Hij loopt stap voor stap door het proces: "Als ik peper doe, wordt het te zout. Oké, dan pas ik het recept aan." Hij doet dit zonder het gerecht daadwerkelijk te koken of te proeven. Hij simuleert het in zijn gedachten.
Zelf corrigeren: Als hij in zijn hoofd merkt dat het misgaat, past hij het plan direct aan. Hij herhaalt dit een paar keer tot hij zeker is dat het recept werkt voor elke situatie, niet alleen voor de simpele proefportie.

Waarom is dit beter?

Geen valkuilen: Omdat de AI niet afhankelijk is van simpele voorbeelden, wordt hij niet "verleerd" om alleen op die simpele voorbeelden te reageren. Hij leert echt begrijpen hoe het recept werkt.
Minder werk: Het is goedkoper en sneller. De oude manier vereist dat je het gerecht daadwerkelijk kookt en proeft (wat tijd kost en computerkracht vraagt). DryRUN doet het allemaal in het hoofd van de AI.
Realistisch: In het echte leven hebben programmeurs vaak geen proefporties (geen voorbeelden) voordat ze beginnen. DryRUN traint de AI om te werken zoals echte mensen: op basis van logica en eigen inzicht, niet op basis van voorbeelden.

De conclusie in één zin:
Deze studie laat zien dat we kunstmatige intelligentie niet hoeven te "kweken" met simpele voorbeelden om goede code te krijgen. Als we ze juist de ruimte geven om zelf na te denken en hun eigen moeilijke situaties te bedenken, worden ze zelfs slimmer, zelfverzekerder (in de goede zin) en betrouwbaarder.

Het is alsof je een kind leert fietsen: de oude methode gaf het kind een wielrijstokje (de voorbeelden) en liet het alleen op een vlakke weg rijden. DryRUN haalt de wielrijstokjes weg, laat het kind zelf een hobbelige weg bedenken in zijn hoofd, en zorgt dat het kind echt leren balanceren voordat het de weg op gaat.

Titel: DryRUN: Over de Rol van Publieke Tests in LLM-gedreven Codegeneratie

Auteurs: Kaushitha Silva en Srinath Perera (WSO2)
Publicatie: arXiv, 2026

1. Het Probleem

Huidige state-of-the-art methoden voor het genereren van code met Large Language Models (LLM's) zijn sterk afhankelijk van publieke testcases (handmatig geschreven voorbeelden van invoer en uitvoer) die in de probleemspecificatie worden verstrekt. Deze afhankelijkheid leidt tot twee fundamentele problemen:

Realiteitsverlies: In echte softwareontwikkeling zijn grondwaarheid-invoer/uitvoer-voorbeelden zelden beschikbaar voordat code is geïmplementeerd. Benchmarks zoals HumanEval en LiveCodeBench bevatten echter vaak deze voorbeelden, wat de methoden beperkt tot gecureerde competitieve programmeringsopgaven en niet representatief is voor de praktijk.
De "Overconfidence Gap" (Overmoedigheidsgat): Het paper identificeert een kritieke kwetsbaarheid. Omdat publieke tests vaak triviaal zijn en complexe edge-cases missen, leren modellen om zich aan te passen aan deze simpele voorbeelden. Hierdoor worden ze "overmoedig": ze slagen voor de publieke tests maar falen op de verborgen, privé-testreeksen. Dit fenomeen wordt de Overconfidence Gap genoemd. Het handmatig schrijven van uitgebreide publieke tests is bovendien arbeidsintensief en onpraktisch.

De centrale vraag van het paper is: Zijn publieke testcases echt noodzakelijk voor correcte codegeneratie?

2. Methodologie: Het DryRUN Framework

DryRUN (Debugging and Refinement Under Non-execution) is een nieuw framework dat de noodzaak van publieke tests en externe uitvoeringssandboxes volledig elimineert. In plaats daarvan vertrouwt het uitsluitend op de interne simulatiecapaciteiten van het LLM.

Het framework werkt volgens een iteratieve cyclus (zie Algorithm 1 in het paper):

Zero-Example Specificatie: Het proces begint met een gestandaardiseerde probleemspecificatie waarbij alle menselijke voorbeelden zijn verwijderd en vervangen door een algemene beschrijving van het invoer- en uitvoerformaat.
Fase 1: Initieel Plannen & Verfijnen:
- Het LLM formuleert een implementatieplan op basis van de specificatie.
- Dit plan ondergaat $N_{plan}$ iteraties van autonome verfijning zonder externe feedback. Het model wordt gevraagd om logica te verbeteren, meer stappen toe te voegen en edge-cases te overwegen.
Fase 2: Code Synthese & Mentale Simulatie:
- Het model genereert een eerste codeversie op basis van het verfijnde plan.
- Vervolgens voert het model $N_{sim}$ $N_{s im}$ iteraties van mentale simulatie uit:
  - Autonome Invoergeneratie: Het LLM synthetiseert zelf een geldige, niet-triviale invoer (sample input) op basis van de probleemconstraints.
  - Mentale Trace: Het model simuleert de uitvoering van de code regel voor regel tegen deze gegenereerde invoer, waarbij het variabele staten bijhoudt om logische fouten bloot te leggen.
  - Zelfcorrectie: De gegenereerde trace wordt gebruikt om het plan te updaten en de code opnieuw te genereren om de geïdentificeerde bugs te verhelpen.
Fase 3: Final Polishing: Een laatste fase waarin de code wordt gepolijst om syntactische fouten te corrigeren die mogelijk zijn ontstaan tijdens de iteratieve correctieprocessen.

Belangrijk onderscheid met bestaande methoden (zoals CodeSIM):

Geen externe uitvoering: Code wordt nooit uitgevoerd in een sandbox.
Zelf gegenereerde inputs: In plaats van te wachten op een falende publieke test, creëert het model zelf complexe, maar traceerbare inputs.
Proactief vs. Reactief: DryRUN verfijnt het plan proactief en simuleert onvoorwaardelijk, terwijl methoden zoals CodeSIM reactief werken (alleen debuggen als een publieke test faalt).

3. Belangrijkste Bijdragen

Uitdaging van de Dominantie van Publieke Tests: Het paper betoogt dat publieke tests een "kruk" zijn in plaats van een noodzaak. Het demonstreert dat moderne LLM's in staat zijn om zonder menselijke voorbeelden te werken.
Het DryRUN Framework: Een volledig autonoom systeem dat code genereert, valideert en corrigeert puur via mentale simulatie en zelfgegenereerde inputs.
Identificatie van de Overconfidence Gap: Het paper kwantificeert hoe afhankelijkheid van triviaal publieke tests leidt tot overfitting en falen op privé-tests, en toont aan dat DryRUN dit gat aanzienlijk verkleint.
Efficiëntie: DryRUN verbruikt aanzienlijk minder tokens dan bestaande multi-agent frameworks die afhankelijk zijn van uitgebreide simulaties en sandbox-executies.

4. Resultaten

De evaluatie vond plaats op de LiveCodeBench v6 dataset (problemen gepubliceerd na maart 2025) om data-contaminatie te voorkomen. Er werden twee modellen getest: gpt-5-mini en gemini-3-flash.

Prestatievergelijking: DryRUN bereikte een vergelijkbare prestatie (Pass@1) als CodeSIM (de huidige state-of-the-art methode die afhankelijk is van publieke tests).
- Met gpt-5-mini presteerde DryRUN zelfs 3,3% beter dan CodeSIM.
- Met gemini-3-flash was CodeSIM 5,0% beter, maar binnen de marge van de standaarddeviatie.
- Cruciaal: DryRUN deed dit zonder enige publieke test of externe uitvoering.
Token-efficiëntie: DryRUN is aanzienlijk efficiënter. Het verbruikt slechts 70% van het totale aantal tokens van CodeSIM en slechts 50% van de output-tokens. Dit komt doordat DryRUN strikt beperkt is tot 2 simulatie-rondes, terwijl CodeSIM tot 25 geneste simulaties kan uitvoeren.
Overconfidence Gap: De analyse toonde aan dat CodeSIM een groot "overconfidence gap" vertoonde (code die publieke tests haalde maar privé-tests faalde). DryRUN had een veel kleiner gat, wat aantoont dat het model minder overfitte op simpele voorbeelden en robuuster was.
Ablatiestudies:
- Het toevoegen van een planningsfase verbeterde de prestaties aanzienlijk (+15% t.o.v. directe generatie).
- Mentale simulatie stabiliseerde de prestaties en verlaagde de variantie.
- Een finale "polishing"-fase was essentieel om syntactische fouten te corrigeren die tijdens de iteraties waren ingebracht.
SLM's: Het framework faalde bij Small Language Models (zoals qwen2.5-coder:7b) vanwege hun beperkte redeneercapaciteit voor complexe multi-stap simulaties.

5. Betekenis en Conclusie

Het paper concludeert dat de rol van publieke testcases in het garanderen van correctheid veel kleiner is dan de gemeenschap tot nu toe heeft aangenomen.

Paradigmaverschuiving: Het succes van DryRUN suggereert dat we de afhankelijkheid van menselijke voorbeelden kunnen loslaten. Dit maakt codegeneratie meer vergelijkbaar met de realiteit van softwareontwikkeling, waar dergelijke voorbeelden vaak ontbreken.
Kwaliteit van Tests: De "Overconfidence Gap" wijst erop dat het gebruik van simpele publieke tests in benchmarks modellen kan misleiden. Benchmarks zouden mogelijk moeten worden heroverwogen of publieke tests moeten worden verwijderd om eerlijkere evaluaties te bieden.
Toekomstperspectief: Hoewel DryRUN momenteel alleen werkt met krachtige LLM's, opent het de weg voor toekomstig onderzoek naar het toepassen van mentale simulatie op repository-niveau (SWE-bench) en het verbeteren van Small Language Models voor deze taak.

Kortom, DryRUN bewijst dat execution-free self-correction via mentale simulatie een krachtig en efficiënt alternatief is voor traditionele, testgedreven methoden.