AI Agent Lussen: Hoe Zelfcorrigerende Codingsagenten de Taak Voltooien

De manier waarop de meeste mensen nog steeds een AI-coderingsagent gebruiken, lijkt op pingpong. Je geeft een prompt, het antwoordt, je ziet wat er mis is, je geeft opnieuw een prompt. Jij bent de correctiemachine en je zit in de lus bij elke beurt.

Een loop draait dat om. Je beschrijft wat je wilt, de agent gaat aan de slag, schrijft zijn eigen checklist, vindt zijn eigen zwakke punten en draait opnieuw totdat het resultaat standhoudt. Jij stopt met het zijn van de persoon die fouten opvangt. De agent vangt zijn eigen fouten op.

Die verschuiving is geen hype. De mensen die deze tools hebben gebouwd, leunen erop. Boris Cherny en Cat Wu, de makers van Claude Code, praten over coderen in agent loops. Geoffrey Huntley, die de "Ralph loop" benoemde, laat agents draaien in een eenvoudige while loop gedurende de nacht. Het patroon heeft nu een naam en het is de moeite waard om te begrijpen voordat je drie prompts van Instagram kopieert.

Van prompt pingpong naar een loop

Een enkele prompt is een eenmalige actie. Je vraagt, je krijgt een antwoord, de transactie eindigt. Om het te verbeteren, moet je de kloof opmerken en opnieuw een prompt geven. Schaal dat naar een echte functie en je doet tientallen micro-correcties met de hand.

Een AI-agent loop sluit die kloof binnen de agent. Je stelt een doel, de agent plant, handelt, kijkt naar het resultaat en corrigeert, keer op keer, totdat het doel is bereikt. Je bent niet weg, je beoordeelt aan het einde. Maar je bent niet langer de bottleneck bij elke iteratie.

Prompt pingpong plaatst je in de loop bij elke beurt. Een echte loop plaatst de agent erin.

Wat een AI-agent loop eigenlijk is

Elke agentische loop doorloopt dezelfde vier stappen: plannen, handelen, observeren, corrigeren. De agent beslist de volgende stap, voert deze uit (schrijft code, voert een commando uit, leest een bestand), leest wat er is gebeurd en past aan. Claude schrijft code, voert de tests uit, ziet een fout, repareert het, voert de tests opnieuw uit. Die feedback is de hele truc. Het is wat de loop zelfcorrigerend maakt in plaats van alleen repetitief.

De sterkste versie van de loop verdeelt die stappen over drie rollen: een die plant, een die bouwt, een die beoordeelt. Ze gescheiden houden is wat voorkomt dat de agent zijn eigen huiswerk beoordeelt terwijl hij het schrijft.

De drie-commando loop die je vandaag kunt kopiëren

Hier is de opzet die momenteel rondgaat, opnieuw opgebouwd als drie Claude Code slash-commando's. Plak elk een keer, de agent maakt het commando aan, en dan voer je ze in volgorde uit.

De planner, /spec:

Interview me één vraag tegelijk totdat je volledig begrijpt wat ik wil.
Schrijf dan een nauwkeurig plan naar specs/project.md: het doel, de exacte
vereisten, de randgevallen, en wat binnen en buiten de scope valt.
Houd het kort en krachtig, geen roman.

De bouwer, /build:

Lees specs/project.md en bouw precies wat het beschrijft, niets meer.
Als je klaar bent, lijst dan elke eis uit het plan op en markeer welke
je hebt gedekt.

De beoordelaar, /review:

Vergelijk wat is gebouwd met specs/project.md, eis voor eis.
Voor elke eis, zeg of deze is gedekt. Schrijf de nodige correcties op en
geef ze terug aan /build. Keur pas goed als het hele plan is gedekt.

Drie commando's, één loop: spec schrijft het plan, build implementeert het, review controleert het tegen het plan en stuurt correcties terug naar build. Het blijft cycleren totdat aan elke eis is voldaan.

Het plan is de bron van waarheid. Review meet de build eraan, niet aan een gevoel.

Dit is spec-gedreven coderen onder de motorkap: de geschreven spec, niet de chatgeschiedenis, is waar de agent aan wordt gehouden. GitHub's open-source Spec Kit formaliseert hetzelfde idee met /specify, /plan, /tasks en /implement, en het werkt op Claude Code, Copilot, Cursor, Codex CLI en Antigravity CLI.

Waarom een frisse context de loop laat werken: de Ralph loop

Geoffrey Huntley benoemde de meest directe versie hiervan in midden 2025: de Ralph loop. Het idee is een eenvoudige shell loop die de agent dezelfde prompt tegen een geschreven spec voert, hem een taak laat kiezen en verzenden, en dan een gloednieuwe agent met een schone context start en dezelfde prompt opnieuw voert.

while has_more_todos; do
  agent --prompt "Werk aan de volgende taak uit todo.md" --non-interactive
done

Het niet voor de hand liggende deel is de context reset. Een lange sessie rot: het venster vult zich met oude redeneringen, doodlopende wegen en verouderde bestandsinhoud, en het model begint stilletjes instructies te laten vallen. Elke Ralph-iteratie is een nieuwe agent die de huidige repo en takenlijst van de schijf leest, één eenheid werk doet, commit en schoon afsluit. Huntley noemde het met opzet naar het Simpsons-personage, het lijkt te dom om te werken, en het werkt. Als je een lange sessie hebt zien hallucineren, weet je al waarom een fris venster een opgeblazen venster verslaat.

Claude Code's /loop en /goal

Claude Code levert loop-primitieven direct. /goal stelt een persistent einddoel in, hoe "klaar" eruitziet, en Claude evalueert de voortgang ertegen na elke beurt in plaats van alleen de volgende stap uit te voeren. /loop herhaalt een taak op een ritme of totdat een voorwaarde geldt, met vormen zoals /loop every 10m of /loop until: <condition>. Samen gebruikt creëren ze een zelfsturende, zelfbeëindigende loop: Claude werkt het verschil tussen de huidige staat en het doel, en stopt wanneer het doel is bereikt of je Ctrl+C indrukt.

Het detail dat ertoe doet: een loop houdt continuïteit. Het onthoudt wat het heeft geprobeerd en waarom het is mislukt, zodat elke beurt voortbouwt op de vorige in plaats van dezelfde doodlopende weg te herhalen. Dat is de tegenovergestelde afweging van Ralph's schone-context reset, en beide zijn geldig. Continuïteit voor strakke zelfcorrectie, frisse context wanneer het venster rot. Weten welke je moet kiezen is de echte vaardigheid.

Dezelfde loop, elke provider

Loops zijn geen Claude-functie, ze zijn waar het hele veld naartoe gaat. De namen verschillen, de vorm niet.

Codex CLI heeft de loop het verst in het openbaar gebracht. OpenAI's team kaderde zijn /goal als hun versie van de Ralph loop, en a16z's Andrew Chen liet het 14 uur lang zonder tussenkomst draaien op een apparaatstuurprogramma. Hij merkte ook op dat het "10.000x tokengebruik" zou zijn, wat de eerlijke kosten zijn van een agent een halve dag laten malen.

De catch: een loop versterkt alles

Een loop versterkt niet alleen goede output, het versterkt ook een slecht plan. Richt een zelfcorrigerende agent op een vage spec en hij zal vol vertrouwen het verkeerde bouwen, het beoordelen tegen dezelfde vage spec en goedkeuren. Het plan is de hefboom. Een scherpe spec bespaart tien prompts, een vage verspilt er honderd.

Twee faalmodi om op te letten. Kosten lopen uit de hand, elke iteratie verbrandt tokens, en een onbegrensde loop op een onduidelijk doel kan veel verbranden. En de loop kan voor altijd doorgaan, overwinning verklaren of een doel nastreven dat het nooit kan bevredigen. Beperk het: een duidelijke until-voorwaarde, een tokenlimiet, of een menselijke controlepost voor de merge. Een loop zonder stop is geen autonomie, het is een runaway.

Die menselijke controlepost roept de vraag op waar elk team uiteindelijk over discussieert: moet je de code van je AI-agent nog steeds beoordelen, en op welke criteria beslis je dat de agent het fout heeft?

Loops draaien over een vloot

Eén zelfcorrigerende agent is gemakkelijk te begeleiden. De hefboomwerking verschijnt wanneer je er meerdere tegelijk laat draaien, elk in zijn eigen taak loopend, en dat is precies waar het kijken naar een terminal niet meer schaalbaar is.

Daar is AgentsRoom voor gebouwd. Het is een multi-agent cockpit: elke agent heeft een rol, een live statuspunt en zijn eigen kleur, en je houdt toezicht op de hele vloot vanuit één venster. Laat een ticket vallen op de backlog en een agent pakt het op, voert zijn plan-build-review loop uit, en levert je een schone diff. Dat is spec-gedreven AI-codering in de praktijk: het ticket is de spec, de agent voert de loop uit, jij beoordeelt het resultaat.

Omdat lange loops context laten rotten, houdt AgentsRoom daar rekening mee. Elke agent schrijft een statusregel aan het einde van elke beurt, en wanneer een agent stopt met updaten voor twee beurten op rij, verschijnt er een waarschuwing met een een-klik herstart op een schone context, dezelfde frisse-venster reset waar de Ralph loop op vertrouwt. Lees hoe dat werkt op de context drift detection pagina.

En omdat de loop provider-onafhankelijk is, ben je niet gebonden aan één. Laat één ticket draaien op Claude Code, de volgende op Codex, een andere op Antigravity CLI, allemaal in hetzelfde dashboard, elk in zijn eigen git worktree zodat parallelle agents nooit botsen. Zet ze aan voordat je uitlogt en beoordeel de diffs in de ochtend, dat is het hele punt van achtergrond coderingsagents en de nachtploeg.

Stel het doel eenmaal in, laat de loop het sluiten, beoordeel aan het einde. Download AgentsRoom, bekijk de provider compatibiliteitsmatrix, en lees meer over per-agent beoordeling en multi-provider ondersteuning.