Hoe u Claude Code urenlang autonoom kunt uitvoeren zonder toezicht

Ik liet Claude Code de hele nacht draaien op een echte taak. Ik testte AIdaemon, mijn persoonlijke AI-agent, via de webinterface van Telegram. Ik keek er overdag naar, liet het de hele nacht doorgaan, en de volgende ochtend draaide het al meer dan 27 uur. 84 taken voltooid. Het vond bugs, repareerde de code, hertestte en ging door naar moeilijkere tests. Dit alles zonder dat ik iets aanraakte. Ik heb het Claude Code 20x-abonnement, wat je genoeg capaciteit geeft om sessies als deze daadwerkelijk uit te voeren.

De opzet die dit mogelijk maakte, bestaat uit drie vlaggen en een goed promptbestand.

Sla de toestemmingsprompts over

Claude Code vraagt normaal gesproken om bevestiging voordat het commando's uitvoert of bestanden bewerkt. Dat is prima als je erbij zit. Maar voor nachtelijke runs is elke toestemmingsprompt een doodlopende weg. De sessie blijft dan wachten tot je op "toestaan" klikt.

claude --dangerously-skip-permissions

De naam van de vlag is opzettelijk eng. Het betekent dat Claude Code elke tool-oproep uitvoert zonder te vragen. Ik zou dit niet gebruiken op een machine met productiegeheimen. Op een ontwikkelmachine met een afgebakende taak is het echter wat onbeheerde runs mogelijk maakt.

Geef het een browser

Ik wilde dat Claude Code kon interageren met een webapplicatie. Ik testte de Telegram-bot van AIdaemon via Telegram Web, en Claude Code alleen kan dat niet omdat het in de terminal leeft.

De vlag --chrome verbindt het met Chrome via de Claude in Chrome MCP-extensie. Het kan pagina's navigeren, op knoppen klikken, formulieren invullen, inhoud lezen, schermafbeeldingen maken. Combineer beide vlaggen en je krijgt iets dat code kan schrijven in de terminal en het in de browser kan testen.

claude --chrome --dangerously-skip-permissions

In mijn geval stuurde Claude Code een bericht naar AIdaemon via Telegram Web, las het antwoord, bepaalde of de agent het juiste deed, en ging de code repareren als dat niet zo was. Vervolgens probeerde het hetzelfde nogmaals om dit te bevestigen.

Houd het draaiende met Ralph Loop

Als je Claude Code alleen start met een grote prompt, is het klaar en stopt het. Of het denkt dat het klaar is en stopt. Dat is prima voor een snelle taak, maar nutteloos voor iets dat uren zou moeten duren.

Ralph Loop is een Claude Code-plugin die dit oplost. Het installeert een stop-hook. Wanneer Claude probeert af te sluiten, onderschept de hook dit en voert dezelfde prompt opnieuw in. Elke iteratie start een nieuw gesprek met dezelfde prompt, maar Claude kan de huidige status van de bestanden en de git-geschiedenis zien. Het bedenkt wat er gedaan is en beslist wat het vervolgens moet doen. De naam komt van de Ralph Wiggum-techniek van Geoffrey Huntley. Het oorspronkelijke idee was doodsimpel: een bash while true-loop die een promptbestand blijft invoeren in een AI-agent totdat deze het goed heeft. Brute kracht ontmoet doorzettingsvermogen, net als het Simpsons-personage dat gewoon doorgaat, wat er ook gebeurt. Anthropic vond het goed genoeg om een Ralph Wiggum-plugin uit te brengen als onderdeel van Claude Code.

/ralph-loop "uw taakprompt hier" --completion-promise "KLAAR"

De --completion-promise is de enige uitweg. Claude kan de lus alleen doorbreken door die exacte tekenreeks uit te voeren. Je kunt ook --max-iterations instellen als vangnet.

Schrijf een echte prompt

De bovenstaande tools zijn de machinerie. Maar de prompt bepaalt of je een uur nuttig werk krijgt of zevenentwintig. "Test mijn app en los bugs op" levert je misschien een uur op voordat Claude de overwinning uitroept na één fix.

Voor alles wat serieus is, schrijf ik een markdownbestand. Architectuur, doelen, beperkingen, wat "klaar" daadwerkelijk betekent. Vervolgens geef ik dit door aan ralph-loop.

/ralph-loop "$(cat task-prompt.md)" --completion-promise "KLAAR"

Mijn prompt voor de sessie van 27 uur zag er ongeveer zo uit.

# Taak. Test en verstevig de AIdaemon Telegram-agent

## Context
AIdaemon is een multifunctionele AI-agent toegankelijk via Telegram.
De webinterface is op https://web.telegram.org/k/#@aidaemon_coding_bot

## Doelen
- Daag de agent uit met progressief moeilijkere taken
- Test niet alleen de 'happy paths'. Probeer randgevallen, verkeerd gevormde invoer,
  complexe multi-staps operaties
- Wanneer iets breekt, repareer de onderliggende code
  (geen pleister voor dat specifieke geval)
- Hertest na elke reparatie om te bevestigen dat het werkt EN niets anders kapot is gegaan

## Architectuurnotities
(relevante bestandspaden, hoe de agent berichten verwerkt,
belangrijke modules, databaseschema, wat Claude ook nodig heeft)

## Succescriteria
- Alle basisoperaties werken betrouwbaar
- Randgevallen worden elegant afgehandeld
- Foutmeldingen zijn behulpzaam, niet cryptisch
- Geen regressies van eerdere reparaties
- Voer KLAAR uit wanneer aan al het bovenstaande is voldaan

Zonder architectuurnotities verspilt Claude iteraties aan het uitzoeken van de codebase. Zonder duidelijke succescriteria weet het niet wanneer het moet stoppen. Zonder de instructie om algemene reparaties uit te voeren, schrijft het een if-statement voor één specifieke invoer en gaat verder.

Wat er gebeurde gedurende 27 uur

Ik voerde het commando uit en ging naar bed.

Het eerste uur ging over de basisprincipes. Eenvoudige berichten naar de bot, antwoorden controleren. Daarna begon het op eigen initiatief te escaleren. Refactoringtaken over meerdere bestanden. Foutherstel met kapotte invoer. Het vond een prompt-injectiekwetsbaarheid, schreef een verdediging, en testte vervolgens een moeilijkere injectievariant om te controleren of de verdediging standhield.

Bij test 88 had de agent een JSON-parser vanaf nul gebouwd met 79 testgevallen. Eerder repareerde het achtergrondnotificatie-pinglimieten, loste het bugs in de resolutie van toolnamen op en ontdekte het een UX-probleem waarbij interne mechanismen zichtbaar werden in gebruikersgerichte berichten.

De reparaties waren echt, niet oppervlakkig. Het "goedkope profiel" gebruikte first_fallback in plaats van het standaardmodel, dus het repareerde de configuratielogica. De resolutie van toolnamen voor leesverzadiging werkte niet, dus het voegde cascade-fallback toe voor alle diepten, niet alleen de diepte die kapot was.

In totaal 84 taken. Tests, reparaties, hertests. Allemaal autonoom.

Wat ik zou delen met iemand die dit probeert

Ik voerde een paar sessies uit met one-liner prompts vóór deze. Die raakten na een uur of twee uitgeput. De sessie van 27 uur ging door omdat het promptbestand genoeg context bevatte voor Claude om op koers te blijven gedurende tientallen iteraties.

Claude vertellen om algemene reparaties uit te voeren in plaats van specifieke patches maakte een echt verschil. Zonder dat schrijft het de minimale code om de huidige test te laten slagen. Hiermee voorkwamen de reparaties ook gerelateerde bugs.

Toegang tot de browser ving dingen op die unit tests niet zouden vinden. UI-eigenaardigheden, timingproblemen, opmaakproblemen. --chrome liet Claude echte end-to-end testen uitvoeren in plaats van alleen code geïsoleerd uit te voeren.

Ik heb alle wijzigingen achteraf bekeken. De meeste waren goed. Een paar waren over-engineered, en één refactor raakte meer bestanden aan dan nodig was. Maar over het algemeen werden tientallen echte bugs gevonden en opgelost, elk bevestigd met een hertest.

Als je het wilt proberen, installeer dan de Ralph Loop-plugin, schrijf een fatsoenlijk promptbestand en begin klein. --max-iterations 10 op een afgebakende taak. Kijk hoe het gaat voordat je opschaalt.