Specification-first convergence with an AI coding agent: a case study of dismantling a core architectural invariant across 189 files in a 717k-line codebase with no test oracle and no human code review

Stel je voor dat je een superintelligente robot probeert te leren hoe hij een huis moet bouwen. Meestal is de robot geweldig in het leggen van een enkele baksteen of het schilderen van één muur, maar als je hem vraagt om het hele fundament te ontwerpen terwijl er al in het huis wordt gewoond, raakt hij in de war. Hij kan per ongeluk een dragende muur afbreken of vergeten dat de keuken verbonden moet blijven met de eetkamer. In de wereld van computerwetenschappen wordt dit "refactoring" genoemd van een enorme codebase. De grote vraag waar onderzoekers nu aan stellen is: Kan een AI-agent dit enorme, gevaarlijke werk helemaal zelf doen, zonder een menselijke baas die elke regel code controleert?

Om de uitdaging te begrijpen, kun je een computerprogramma zien als een gigantische, ingewikkelde klokmachine. Binnenin zitten "invarianten"—dit zijn de onbreekbare regels die de tandwielen draaiende houden, zoals "de hoofdveer moet altijd opgewonden zijn" of "de wijzers mogen nooit achteruit springen." De meeste AI-coderingstools zijn als leerlingen die geweldig zijn in het vastdraaien van een los schroefje, maar vreselijk in het volledig herbedraden van de klok zonder de tijdmeting te verstoren. Ze hebben meestal een mens nodig die over hun schouder meekijkt en zegt: "Wacht, dat kun je niet doen!" Maar mensen worden moe, en ze kunnen niet de volledige kaart van een gigantische klok tegelijkertijd in hun hoofd houden. Dit artikel onderzoekt een nieuwe manier van werken: in plaats van het werk van de robot te controleren nadat hij klaar is, dwingen we de robot om eerst een perfect, gedetailleerde instructiehandleiding te schrijven voordat hij ook maar één tandwiel aanraakt. Vervolgens laten we de robot zijn eigen werk controleren tegen die handleiding, keer op keer, totdat de handleiding en de machine perfect met elkaar overeenstemmen.

Het Verhaal van het "Ghost" Paneel

Dit artikel vertelt het verhaal van één specifere, hoogwaardige experiment waarbij een enkele AI-agent werd gevraagd een "magische truc" uit te voeren op een massief softwareprogramma. Het programma was een applicatie van 717.725 regels (stel je een bibliotheek voor met bijna 720.000 pagina's aan instructies) die fungeerde als een AI-coderingsassistent. De taak was om een fundamentele regel te doorbreken die de software sinds de eerste dag had gevolgd: de regel die zei: "Als je het venster dat het werk van de AI laat zien sluit, moet de AI stoppen met denken."

Het doel was om dit te veranderen zodat de AI, wanneer je het venster sluit, op de achtergrond zou blijven werken, als een geest. Wanneer je het venster weer opent, zou de AI onmiddellijk weer "aan te sluiten" bij het gesprek, en precies daar oppakken waar het gebleven was zonder een enkel woord te verliezen of zichzelf te herhalen. De auteur van het artikel, een menselijke ontwikkelaar, geloofde dat dit zo complex en riskant was dat de enige veilige manier om dit te doen, het weggooien van de oude code en het volledig herschrijven ervan van de grond af aan zou zijn.

Het "Specification-First" Protocol

In plaats van alles te herschrijven, gebruikte de auteur een methode genaamd "Specification-First Convergence." Denk aan het als een spelletje "Telefoontje" gespeeld met een zeer strikte scheidsrechter, maar de scheidsrechter is de AI zelf.

1. Het Plan: De mens gaf de AI een eenvoudige opdracht in gewone taal: "Zorg dat de AI blijft werken, zelfs als het venster gesloten is."
2. Het Blauwdruk: De AI begon niet direct met coderen. In plaats daarvan schreef het een enorme, 55-pagina tellende formele "specificatie"—een gedetailleerde blauwdruk van precies hoe de verandering zou werken, tot in de kleinste details.
3. De Audit (Verfijning): Dit is waar de magie gebeurde. De AI werd gevraagd om zijn eigen blauwdruk 14 keer te vergelijken met de bestaande, echte code. In elke ronde vond hij fouten in zijn eigen plan. "O, ik ben vergeten dat het achtergrondproces een nieuwe knop nodig heeft om het te stoppen," of "Ik heb geen rekening gehouden met wat er gebeurt als het venster sluit terwijl de AI aan het nadenken is." De AI schreef de blauwdruk 14 keer opnieuw en corrigeerde ongeveer 85 fouten in het plan voordat er ook maar één regel nieuwe code werd geschreven.
4. De Bouw: Zodra de blauwdruk "bevroren" was (wat betekende dat deze perfect was en niet meer zou veranderen), begon de AI met coderen. Het schreef niet alleen bestanden; het creëerde patches (kleine updates) voor 189 verschillende bestanden.
5. De Dubbelcheck (Verificatie): Dit was het meest cruciale deel. De AI werd gevraagd om zijn eigen nieuwe code te lezen en deze 17 keer te vergelijken met de bevroren blauwdruk. Het vond 116 extra fouten—kleine architecturale imperfecties of logische gaten—en loste deze op. Het bleef dit doen totdat twee rondes achter elkaar nul fouten vonden.

De Resultaten: Een Geest die Niet Spookt

Het hele proces duurde drie dagen en kostte $2.430 aan computerverwerkingskosten. Het resultaat? De AI slaagde erin om een kernregel van de software over 189 bestanden heen te ontmantelen zonder dat een mens ooit naar de gegenereerde code heeft gekeken.

Toen de mens het programma voor de eerste keer draaide, werkte het perfect. Je kon het venster sluiten, de AI op de achtergrond zien doorwerken, en het venster weer openen om te zien hoe het gesprek direct werd hervat, zonder verloren woorden of duplicaten. De software gedroeg zich precies zoals de blauwdruk beloofde. De auteur merkte op dat de code zo schoon was dat toen er later een kleine aanpassing aan de interface nodig was, dit slechts één enkel bestand vereiste, wat suggereert dat de AI zijn werk goed had gedaan om de structuur georganiseerd te houden.

Wat Dit Betekent (en Wat Het Niet Betekent)

Dit artikel suggereert dat we voor zeer moeilijke, risicovolle softwarewijzigingen misschien niet hoeven te vertrouwen op menselijke beoordelaars om elke fout op te merken. In plaats daarvan kunnen we de AI gebruiken om zijn eigen plannen en zijn eigen code herhaaldelijk te controleren tegen een bevroren standaard, totdat het convergeert naar perfectie.

Het artikel is echter zeer voorzichtig in de claims die het maakt. Het geeft toe dat dit slechts één specifieke taak op één specifieke codebase was. Het bewijst niet dat dit voor elke AI of voor elk type softwareprobleem zal werken. Het merkt ook op dat, omdat de code privé is, niemand anders exact hetzelfde experiment kan uitvoeren om te zien of zij hetzelfde resultaat behalen. Maar als bewijs van concept laat het zien dat een AI, wanneer deze wordt gedwongen om minutieus te plannen en zichzelf herhaaldelijk te auditeren, een "chirurgische" operatie kan uitvoeren op een gigantisch softwaresysteem dat mensen normaal gesproken te gevaarlijk vinden om aan te raken zonder een volledige rewrite.