🤖 AI

Agentic Synthesis against Counterexample-Supplemented Sketches

Dit artikel introduceert "Agentic Synthesis against Counterexample-Supplemented Sketches", een repository-native methode waarbij door mensen goedgekeurde beleidscorrecties worden geïntegreerd in een evoluerende codeschets in plaats van geaccumuleerde voorbeelden, wat aantoont dat deze aanpak de inspanning van ontwikkelaars vermindert en de transfer van geleerde regels naar ongeziene gevallen verbetert vergeleken met traditionele replay-gebaseerde regeneratie.

Oorspronkelijke auteurs: Muness Castle, Eric Rubeck

Gepubliceerd 2026-07-20

📖 8 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Muness Castle, Eric Rubeck

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 een wereld voor waarin je een super-slimme robotassistent hebt die computercode voor je kan schrijven. Het is alsof je een geniale leerling hebt die sneller kan typen dan wie dan ook en miljoenen programmeertrucs kent. Maar hier is de crux: deze robot is een beetje een "pleaser". Als je zegt: "Fix deze kapotte knop," zal hij die knop met plezier repareren. Maar als de knop kapot was omdat er een geheime regel bestond die je hem nooit hebt verteld (zoals "laat de knop op dinsdagen nooit rood worden"), kan de robot de knop weliswaar repareren, maar daarbij per ongeluk die geheime regel overtreden. Als je het niet doorhebt, maakt de robot de volgende keer precies dezelfde fout, omdat hij alleen de specifieke fix onthoudt, niet de reden erachter. Dit is het probleem van "coding agents" in de echte wereld: ze zijn geweldig in het dichten van gaten, maar slecht in het begrijpen van de diepe, ongeschreven wetten van hoe een systeem moet functioneren, tenzij iemand hen dat expliciet leert.

Dit artikel, geschreven door Muness Castle en Eric Rubeck, pakt exact dat probleem aan. Het introduceert een nieuwe manier van werken die "Agentic Synthesis against Counterexample-Supplemented Sketches" wordt genoemd. Denk aan dit als een rigoureuze trainingskamp voor AI-programmeurs. In plaats van de AI gewoon te laten gokken en controleren, dwingt deze methode een mens om als een strenge coach op te treden. Wanneer de AI een fout maakt die een verborgen regel breekt, zegt een mens niet alleen "fix het." Ze zeggen: "Hier is de fout, hier is het juiste antwoord, en hier is de regel die je hebt overtreden." De AI moet vervolgens zijn eigen "instructiehandleiding" (een zogenaamde "sketch") herschrijven om die nieuwe regel op te nemen voordat hij opnieuw mag proberen. Het artikel test dit idee met een nep browser-app genaamd "CatSynth" en stelt vast dat deze methode de AI helpt de regels beter te leren dan wanneer men simpelweg een lijst met eerdere fouten laat zien, hoewel de auteurs voorzichtig zijn om te vermelden dat dit gebaseerd is op één specifieke experiment, en niet een wondermiddel is voor elke situatie.

Het Verhaal van de Sketch en het Regelboek

Stel je voor dat je probeert een robot te bouwen die de perfecte kat voor een familie uitkiest. Je geeft de robot een "Sketch". In dit verhaal is een Sketch geen tekening; het is een ruwe, halfgeschreven instructiehandleiding. Er staat zoiets als: "De kat moet pluizig zijn," en "De kat moet vriendelijk zijn." Maar het mist het belangrijkste deel: "De kat mag geen Perzische kat zijn, omdat de familie een allergie heeft."

In het begin kijkt de robot (de coding agent) naar de Sketch en zegt: "Oké, Perzische katten zijn pluizig en vriendelijk! Ik kies een Perzische kat!" De robot schrijft de code om dit te doen. Maar dan kijkt een menselijke expert (de Subject-Matter Expert) naar het resultaat en zegt: "Wacht even, stop! Dat is een ramp. De familie heeft een allergie. Je hebt de verkeerde kat gekozen."

Op de oude manier van doen zou de mens misschien alleen zeggen: "Oké, fix het, kies een andere kat." De robot zou dan een andere kat kiezen, misschien een Siamese. Maar de robot zou de regel over allergieën niet echt leren. Hij zou alleen onthouden: "Kies geen Perzische katen voor deze specifieke familie." De volgende keer, als de familie van mening verandert over de allergie of als er een nieuwe familie met een allergie langskomt, zou de robot dezelfde fout kunnen maken.

Dit artikel stelt een andere, striktere lus voor. Wanneer de menselijke expert zegt: "Verkeerde kat!", corrigeren ze niet alleen de output. Ze treden op als een rechter in een rechtszaal. Ze zeggen:

De Fout: "Je koos een Perzische kat."
De Correctie: "De juiste kat is een Siberische kat."
De Regel: "De regel die je hebt overtreden is: 'Harde regels (zoals allergieën) moeten altijd winnen van zachte voorkeuren (zoals pluizigheid).'"

Vervolgens moet een menselijke "Operator" (de baas) dit expliciet goedkeuren. Zij zeggen: "Ja, dit is nu een echte regel." Zodra dit is ondertekend, moet de robot zijn Sketch herschrijven om deze nieuwe regel op te nemen. De robot kan niet alleen de code patchen; hij moet de handleiding bijwerken.

De Twee-Stappen Controle: De Replay en De Compare

Om te controleren of de robot de les echt heeft geleerd, gebruikt het artikel een slimme twee-stappen test, zoals een beveiliger die een bezoeker bij een poort controleert.

De Replay (De "Heb je de puinhoop opgelost?" check): Dit controleert of het nieuwe antwoord van de robot het onmiddellijke probleem daadwerkelijk oplost. Heeft de robot een kat gekozen die pluizig en vriendelijk is? Zo ja, dan slaagt de "Replay".
De Compare (De "Heb je de regels gevolgd?" check): Dit is het lastige gedeelte. Het controleert of de robot de juiste kat heeft gekozen op basis van de nieuwe regel. Heeft de robot een Siberische in plaats van een Perzische kat gekozen? Heeft hij de allergie onthouden? Als de robot een pluizige Perzische kat koos die het "pluizigheid"-probleem oploste maar de "allergie"-regel brak, dan faalt de "Compare".

Het artikel noemt dit de "Gate" (de poort). Als de robot beide doorstaat, gaat hij verder. Als hij de Compare niet haalt, betekent dit dat de robot het oppervlkkige probleem heeft opgelost maar de diepere regel heeft genegeerd. De robot moet dan teruggaan om zijn Sketch opnieuw aan te passen.

Het CatSynth Experiment

De auteurs testten dit met een nep project genaamd CatSynth. Ze creëerden een scenario waarin een robot een kat moest kiezen op basis van een lijst met voorkeuren (groot, pluizig, aanhankelijk) en een harde regel (geen katten die allergieën veroorzaken).

Ze draaiden een simulatie waarbij de robot probeerde 14 verschillende "bevroren" gevallen op te lossen (scenario's die vóór het experiment vaststonden).

Het Resultaat: In 8 van de 14 gevallen zat de eerste gok van de robot fout omdat hij een regel had gemist. Deze 8 gevallen werden "counterexamples" (tegenvoorbeelden).
Het Proces: Voor elk van deze 8 fouten keurde een mens de correctie goed, de robot update de Sketch, en de robot probeert het opnieuw.
De Test: Nadat de robot klaar was met leren, testten de auteurs hem op 21 nieuwe, verborgen gevallen (gevallen die hij nog nooit eerder had gezien).

Dit is wat ze ontdekten:

Toen ze de code van de robot vanaf nul opbouwden met behulp van alleen de uiteindelijke, geëvolueerde Sketch (de versie die was bijgewerkt met alle regels), kreeg de robot 19 van de 21 nieuwe gevallen goed.
Toen ze probeerden de robot te reconstrueren door hem de originele Sketch te tonen plus een lange lijst van alle eerdere voorbeelden (de "replay-all" methode), kreeg de robot slechts 15 van de 21 goed.

Dit suggereert dat het voor de robot effectiever was om de regels te leren en deze in zijn Sketch te schrijven, dan simpelweg een geschiedenis van fouten te tonen. De robot die de regels leerde, generaliseerde beter naar nieuwe situaties.

Wat Dit Betekent (en Wat Het Niet Betekent)

Het artikel is zeer voorzichtig om de resultaten niet te overschatten. Ze beweren niet dat dit de "perfecte" manier is om alle AI-coderingsproblemen voor altijd op te lossen. Ze geven toe dat dit een simulatie was met één specifiek model (GPT-5.4-mini) en één specifieke volgorde van problemen. Ze weten niet of het precies hetzelfde zou werken met een andere robot of een andere set regels.

Het experiment toont echter iets belangrijks aan: Het is beter om een AI de "Waarom" (de regel) te leren dan alleen de "Wat" (het voorbeeld).

Als je een AI alleen een lijst laat zien van "Doe niet X", kan de AI de lijst misschien uit het hoofd leren, maar mist hij het patroon. Maar als je de AI dwingt om zijn eigen instructiehandleiding (de Sketch) bij te werken telkens wanneer hij een regel breekt, en je hem vervolgens test door zijn oude code weg te gooien en hem opnieuw op te bouwen vanuit die handleiding, krijg je een slimmere en betrouwbaardere AI.

De auteurs wijzen er ook op dat deze methode veel menselijke inspanning vereist. Je hebt een menselijke expert nodig om de fout te spotten, een menselijke operator om de nieuwe regel goed te keuren, en een mens om de lijst met tests te beheren. Het is geen "instellen en vergeten"-systeem. Het is een partnerschap waarbij de mens de leraar is en de AI de leerling die aantekeningen moet maken en zijn eigen tekstboek moet herschrijven.

De Kernboodschap

Uiteindelijk is dit artikel een gids over hoe je voorkomt dat AI een "geloofwaardige maar onjuiste" fixer is. Het betoogt dat wanneer een AI een fout maakt, we niet alleen de code moeten patchen. We moeten de fout behandelen als een les die het fundamentele begrip van de AI van de wereld verandert. Door een "Sketch" te gebruiken om de regels vast te houden, een "Gate" om het werk te controleren en een mens om de lessen te keuren, kunnen we AI bouwen die niet alleen het juiste antwoord raadt, maar ook echt begrijpt waarom het juist is.

De auteurs concluderen dat hoewel deze methode niet elk probleem in hun simulatie oploste (de robot maakte nog steeds 2 van de 21 verborgen gevallen fout), het bewezen heeft dat de "geëvolueerde Sketch" de kennis beter overdraagt dan een eenvoudige geschiedenis van voorbeelden. Het is een stap richting het maken van AI-codering die meer lijkt op een gedisciplineerd meester-gezel traject en minder op een gelukkige gok.

Technisch Samenvatting: Agentic Synthesis tegenover Counterexample-Supplemented Sketches

Probleemstelling

Coding-agents kunnen plausibele patches genereren die voldoen aan onmiddellijke signalen (bijv. falende tests, staat-delta's of prompt-instructies), terwijl ze de onderliggende domeinregels schenden die nog niet in de repository zijn gecodeerd. Wanneer een Subject-Matter Expert (SME) een reparatie afwijst vanwege een beleidschending, blijft die regel vaak in het menselijk geheugen of in chattranscripten hangen in plaats van in de codebase. Gevolgaand kan een opeenvolgende agent-run dezelfde "plausibele fout" herhalen. Het kernprobleem is dat standaard reparatielussen een mechanisme missen om een enkele afgewezen reparatie om te zetten in een duurzame, repository-native sturende beleid die herhaling van die specifieke foutmodus voorkomt.

Methodologie: De Sketch-CE Loop

Het artikel stelt Agentic Synthesis against Counterexample-Supplemented Sketches (Sketch-CE) voor, een repository-native workflow ontworpen om een sturend beleid (de "sketch") te evolueren door middel van expliciete goedkeuring van tegenvoorbeelden (counterexamples) door een operator. De methode steunt op zes specifieke artefacten en een strikte rolenscheiding.

Kernartefacten

Sketch ( $S$ ): Een controleerbaar, door de agent bewerkbaar artefact dat bestaat uit proza, codestructuren en beleidsregels. Het definieert de strategieruimte, de prioriteitsvolgorde en de gaten die ingevuld moeten worden. Cruciaal is dat de sketch evolueert; elk geaccepteerd tegenvoorbeeld moet de sketch herzien om de nieuwe regel te coderen.
Accepted-Counterexample Archive ( $A$ ): De volledige provenance van goedgekeurde fouten. Elk record bevat de input, de gezaghebbende gecorrigeerde output, de "verleidelijke" foute output, de onderscheidende regel en de goedkeuring van de operator.
Regression Set ( $R \subseteq A$ ): Een gecureerde subset van uitvoerbare gevallen, geselecteerd om bekende foutieve implementaties af te wijzen en specifieke beleidsgrenzen te beschermen.
Known-Code Anchors ( $K$ ): Bestaande repository-vormen (API's, conventies, fixtures) die de agent moet behouden om de uitvinding van parallelle lokale conventies te voorkomen.
Implementation Surface: De versiebeheerde code (Oracle A) of prompttekst (Oracle B) die de sketch-regels toepast. Deze zijn vervangbaar; een verse implementatie moet regenereerbaar zijn vanuit de geëvolueerde sketch en anchors zonder de volledige archief te herafspelen.
Gate ( $G$ ): Een uitvoerbare validatiebundel met twee duidelijke lagen:
- Replay: Controleert of de kandidaat-output de gecodeerde staat-gap herstelt (bijv. werkt de wiskunde?).
- Semantic Compare: Controleert of de output overeenkomt met de goedgekeurde verwachting op beleidsgevoelige velden (bijv. werd de juiste operatie geselecteerd?).

Rollen en Workflow

De loop betrekt verschillende actoren om zelfrechtvaardiging te voorkomen:

SME: Beoordeelt concrete outputs en voorziet in correcties met verklaringen.
Operator: Keurt expliciet tegenvoorbeelden goed die in strijd zijn met de huidige sketch. Deze goedkeuring verleent de casus "specificatie-autoriteit" en vereist een revisie van de sketch.
Maintainer: Cureert de regressieset en onderhoudt de machinekamer.
Coding Agent: Repareert implementatie-oppervlakken (code of prompts) onder de beperkingen van de huidige sketch, anchors en de enkele actieve fout.

De Loop-sequentie:

Een geobserveerde casus faalt de huidige implementatie.
Als de fout de sketch tegenspreekt, voorziet de SME in een correctie.
De Operator keurt het tegenvoorbeeld expliciet goed.
De Developer (agent) herziet de sketch om de nieuwe regel te coderen en repareert de implementatie-surface voor die specifieke fout.
De Gate draait de actieve casus en de regressieset ( $R$ ).
Als de gate slaagt, wordt de casus gecureerd in $R$ (indien nog niet gedekt), en wordt de volgende casus onthuld. Als deze faalt, repareert de agent de specifieke regressie.
Periodieke Schone Regeneratie: Om te verifiëren dat de sketch het geleerde beleid draagt, wordt de implementatie weggegooid en opnieuw gegenereerd vanuit de geëvolueerde sketch en anchors alleen. Als dit faalt, heeft de sketch de beleid niet voldoende gesynthetiseerd.

Belangrijkste Bijdragen

Repository-Native Artefact: De introductie van de "counterexample-supplemented sketch" als centraal artefact dat beslissingen van de operator, archiefrecords en gereviewde beleidsclausules aan elkaar bindt.
Procesmodel: Een workflow die operator-goedgekeurde correcties transformeert naar een geëvolueerde sketch, een volledig archief en een gecureerde regressieset, waarbij het sturende model wordt gescheiden van de implementatiegeschiedenis.
Dual-Oracle Implementatie: Een hybride aanpak die deterministische code (Oracle A) gebruikt voor codeerbare regels en prompt-gemedieerde voltooiing (Oracle B) voor narratieve of minder gecodeerde beleid, beide beperkt door dezelfde sketch en gate.
Finite-Regression Theorem: Een formalisering van de "Gate Pass"-conditie, die bewijst dat een passerende gate $R$ -correctheid garandeert (voldoen aan staat-reparatie en beleidsvelden) voor de specifieke regressieset, begrensd door de huidige checkers en goedgekeurde rijen.
Empirische Validatie (CatSynth): Een synthetische browser-applicatie experiment die de mechanica van de methode demonstreert en deze vergelijkt met controlecondities.

Experimentele Resultaten (CatSynth)

De auteurs evalueerden de methode met behulp van CatSynth, een synthetische applicatie met huisdierselectie met harde beleidsregels (bijv. allergieën) en zachte voorkeuren. Het experiment gebruikte GPT-5.4-mini als Developer.

Setup: Een open-world run waarbij de agent regels ontdekte via tegenvoorbeelden, vergeleken met twee controles:
- Replay-All: Opnieuw opbouwen vanaf de initiële sketch en alle geaccepteerde voorbeelden als context herafspelen.
- Evolved-Sketch Rebuild: Opnieuw opbouwen vanaf de geëvolueerde sketch en anchors alleen (schone regeneratie).
Bevindingen:
- Beleidsretentie: De "Evolved-Sketch Rebuild" slaagde voor 19 van de 21 achtergehouden gevallen, wat beter presteerde dan "Replay-All" dat 15 van de 21 slaagde. Dit suggereert dat de geëvolueerde sketch de geleerde beleid beter heeft gesynthetiseerd dan het model de regels opnieuw ontdekt uit ruwe voorbeelden.
- Efficiëntie: Het behouden van code over tegenvoorbeelden heen (Sketch-CE) vereiste 9 Developer-calls en 719 regels aan artefact-churn, vergeleken met 15 calls en 2.394 regels voor de Replay-All benadering.
- Counterexample Density: In de open-world run werden 8 van de 14 bevroren kandidaat-gevallen tegenvoorbeelden. Alle drie de paden (Sketch-CE, Replay-All, Evolved-Sketch) slaagden voor de 8 geaccepteerde gevallen.
- Tokengebruik: De Sketch-CE benadering verbruikte meer tokens tijdens de zichtbare acceptatiefase (1.021.822) vergeleken met de controles, grotendeels door de kosten van het evalueren van externe kandidaten en het voorstellen van algemene regels, in plaats van het genereren ervan.

Claims en Betekenis

Het artikel maakt bescheiden, begrensde claims met betrekking tot de betekenis ervan:

Inspecteerbaarheid: De primaire bijdrage is een inspecteerbare workflow waarbij elk geaccepteerd tegenvoorbeeld een verbinding legt tussen een beslissing van de operator, een archiefrecord en een gereviewde sketch-clausule. Dit voorkomt dat "plausibele foute reparaties" verdwijnen in de chatgeschiedenis.
Beleid vs. Implementatie: De methode laat zien dat een repository-native sketch de "geleerde beleid" kan dragen, zodat een verse implementatie kan worden geregenereerd zonder de volledige geschiedenis van voorbeelden te herafspelen.
Vermindering van Rework: In de specifieke CatSynth-run verminderde het behouden van code over tegenvoorbeelden heen de implementatie-churn en de aantal developer-calls vergeleken met het herafspelen van alle voorbeelden.
Begrensde Correctheid: De auteurs stellen expliciet dat een passerende gate niet algemene correctheid of superioriteit bewijst. De claim is begrensd tot de huidige regressieset, de gecodeerde replay/compare predicaten en de goedgekeurde verwachte rijen. De resultaten vestigen geen algemene modelsuperioriteit of correctheid buiten de gecodeerde checks.
Beperkingen: Het artikel erkent dat de bewijslast beperkt is tot één model, één onthullingsvolgorde en synthetische data. Het beweert geen het probleem van formele verificatie op te lossen of menselijk oordeel bij de definitie van beleid te vervangen.

Samenvattend betoogt het artikel dat voor beleid-zware reparaties de repository de sketch moet behandelen als het duurzame sturende model en het counterexample archive als de bron van beleidsontwikkeling, in plaats van te vertrouwen op de accumulatie van prompt-geschiedenis of testcases alleen.