Het /loop-commando van Claude Code: zo gebruik je het voor slimmere programmeerworkflows in 2026

Heb je Claude Code in meer dan een paar sessies gebruikt, dan heb je vast een moment gehad waarop je wilde dat de AI gewoon doorging (een build in de gaten houden, op een wijziging wachten, iets om de paar minuten opnieuw draaien) zonder dat jij erop hoefde te passen. Precies daarvoor is /loop.

Deze gids legt uit hoe /loop werkt, wanneer het zinvol is om het te gebruiken en hoe je het in echte ontwikkelworkflows inbouwt: van CI-runs bewaken tot iteratieve refactors in een grote codebase.

Wat is /loop in Claude Code?

/loop is een ingebouwd slash-commando in Claude Code dat de agent vertelt een taak volgens een schema te herhalen, of zijn eigen tempo voor iteraties te bepalen, in plaats van na één beurt te stoppen. Het is bedoeld voor situaties waarin iets herhaaldelijk moet gebeuren: een status controleren, een lange refactor voortzetten, een extern systeem pollen of wachten tot een voorwaarde waar wordt.

In de eenvoudigste vorm ziet het commando er zo uit:

/loop <interval_in_seconds> <your prompt here>

Bijvoorbeeld om elke 60 seconden de status van een CI-run te controleren:

/loop 60 Check if the GitHub Actions workflow has finished. Report the status and stop looping if it passed or failed.

Claude draait die prompt elke 60 seconden opnieuw, met al zijn beschikbare tools (Bash, bestanden lezen, webverzoeken), totdat de voorwaarde is vervuld of jij hem onderbreekt.

De twee modi: vast interval vs. eigen tempo

Je kunt /loop op twee manieren gebruiken, en het verschil begrijpen is belangrijk voor hoe je je prompts formuleert.

Lus met vast interval

Geef een aantal seconden mee als eerste argument. Claude wordt op dat interval wakker, draait je prompt en gaat weer slapen. Dit is de juiste modus voor het pollen van externe systemen (CI-pipelines, deploystatussen, health-endpoints van een API), waar een klok uit de echte wereld bepaalt wanneer dingen veranderen.

/loop 120 Run npm test and report which tests are failing. Stop if all tests pass.

Lus op eigen tempo (dynamisch)

Laat het interval weg, dan bepaalt Claude zijn eigen ritme op basis van de context: hoeveel werk er nog over is, hoe lang elke iteratie duurt en wat zinvol is voor de taak. Dat is handig voor open agentisch werk waarbij Claude moet doorgaan zonder vaste klok, bijvoorbeeld een lijst bestanden één voor één refactoren of een backlog van issues afwerken.

/loop Go through each file in src/components/ and add missing TypeScript types. Work through them one at a time, commit after each file, and stop when all are done.

5 echte ontwikkelscenario's waarin /loop uitblinkt

1. Een CI-run bewaken

Je pusht een branch en wilt weten wanneer de pipeline klaar is, zonder elke vijf minuten naar GitHub te wisselen. Stel een lus in met een verstandig interval (CI-runs veranderen zelden sneller dan om de 2–3 minuten) en laat Claude het resultaat melden en automatisch stoppen.

/loop 90 Run: gh run list --branch my-feature --limit 1 --json status,conclusion,url
Report the status. If conclusion is "success" or "failure", report the full result and stop looping.

2. Iteratief refactoren in een grote codebase

Als 40 bestanden dezelfde behandeling nodig hebben (prop-types toevoegen, migreren naar een nieuwe API, een constante hernoemen), is dat met de hand een saaie klus. Met een lus op eigen tempo werkt Claude de lijst op volgorde af, commit na elk bestand en meldt de voortgang, zodat jij het kunt oppakken als er iets misgaat.

/loop Find all .tsx files that still use the old useAuth hook from @/hooks/auth-v1.
Migrate them one at a time to the new useSession hook from @/hooks/session.
Run TypeScript after each file to confirm no errors, then commit. Stop when none remain.

3. Een deploy bewaken

Productiedeploys kunnen 5–15 minuten duren en hebben de gewoonte te mislukken op manieren die duidelijk zijn als je kijkt, maar makkelijk te missen als je even wegloopt. Laat Claude in een lus je health-endpoint of deploy-CLI controleren terwijl jij koffie haalt.

/loop 60 Run: curl -s https://myapp.example.com/api/health | jq '.status'
If status is "ok", tell me the deploy succeeded and stop.
If you see errors three times in a row, stop and show me the last response.

4. Tests stap voor stap repareren

Je hebt een reeks falende tests en wilt dat Claude ze geleidelijk repareert, één fout tegelijk, in plaats van alles in één keer te willen oplossen en een warboel van tegenstrijdige wijzigingen te veroorzaken.

/loop Run the test suite with: npm test -- --bail 1
Pick the first failing test, read the error, fix it, and run again.
Commit after each passing test. Stop when the full suite is green.

5. Wachten op een wijziging in een bestand of log

Tijdens het ontwikkelen wil je soms weten wanneer een bepaalde logregel verschijnt, wanneer een seedbestand klaar is met schrijven of wanneer een build-artefact is aangemaakt, zonder een echt file-watcher-script op te zetten.

/loop 30 Check if the file dist/bundle.js exists and is larger than 10kb.
If yes, run a quick size report (ls -lh dist/) and stop looping.
If not, tell me it is not ready yet.

Hoe /loop past in een agentische workflow

/loop is geen magie: het is een planningslaag bovenop dezelfde Claude-sessie. Elke iteratie heeft volledige toegang tot je projectbestanden, bash-commando's en webtools. Het belangrijkste architectuurinzicht is dat Claude ook de context van eerdere iteraties binnen dezelfde lus meeneemt: hij weet nog wat hij de vorige keer vond, welke bestanden hij al heeft verwerkt en wat de huidige stand is.

Daardoor zijn lussen te combineren met andere patronen in Claude Code:

• Met CLAUDE.md: de regels in je CLAUDE.md-bestand gelden automatisch in elke iteratie van de lus. Heb je commitconventies of bestandsbeperkingen vastgelegd, dan blijven die gelden.
• Met subagents: je kunt Claude vragen binnen een lus subagents te starten voor parallel werk, bijvoorbeeld om in elke iteratie meerdere bestanden tegelijk te verwerken.
• Met hooks: hooks van Claude Code worden bij elke toolaanroep uitgevoerd, dus veiligheidscontroles op toolniveau gelden binnen lussen net zo goed als in normale sessies.

Cache warm houden en waarom de keuze van het interval telt

Er is een praktische prestatieoverweging die verandert hoe je je interval kiest: de promptcache van Anthropic heeft een TTL van 5 minuten. Slaapt je lus langer dan 5 minuten (300 seconden), dan leest de volgende keer wakker worden de volledige gesprekscontext zonder cache in, wat trager is en meer tokens kost.

Een handig denkmodel voor het kiezen van een interval:

• 60–270 seconden: de cache blijft warm. Geschikt voor het pollen van CI-runs, health-endpoints of andere externe status die snel verandert.
• 300+ seconden: een cache-miss bij elke keer wakker worden. Alleen de moeite waard als datgene waarop je wacht echt zo lang nodig heeft om te veranderen. Een deploy van 12 minuten is twee keer 270 s slapen waard, niet 12 polls van een minuut.
• Vermijd precies 300 s: dat is het slechtste van twee werelden; je betaalt de cache-miss zonder een wezenlijk langere wachttijd te krijgen.

Wanneer je /loop NIET moet gebruiken

/loop is krachtig gereedschap en heeft de faalwijzen van krachtig gereedschap. Een paar dingen om op te letten:

• Oneindige lussen zonder stopvoorwaarde: vertel Claude altijd expliciet wanneer hij moet stoppen. "Stop als de tests slagen" of "Stop als je drie keer achter elkaar een fout ziet"; zonder voorwaarde draait een lus door tot de sessiecontext vol is.
• Destructieve operaties: lussen die bestanden wijzigen of commits pushen, vergroten fouten. Vraag Claude eerst om een dry-run, of beperk het werk tot één eenheid per iteratie met een handmatig bevestigingsmoment.
• Achtergrondwerk dat de harness al kan volgen: start je een achtergrondtaak via de Agent-tool, dan krijgt Claude Code automatisch een melding als die klaar is; een polling-lus is dan niet nodig. Gebruik /loop alleen voor externe systemen die de harness niet kan waarnemen.
• Taken waarbij jouw input tussen de stappen nodig is: moet je wijzigingen beoordelen en goedkeuren voordat de volgende iteratie draait, dan is een lus de verkeerde structuur. Gebruik dan een normaal gesprek met handmatige vervolgstappen.

Goede lusprompts schrijven

De kwaliteit van je lus hangt bijna volledig af van hoe precies je de stopvoorwaarde en de actie per iteratie beschrijft. Een zwakke lusprompt levert een agent op die elke N seconden iets doet tot jij hem onderbreekt. Een sterke lusprompt levert een agent op die het probleem oplost en daarna uit de weg gaat.

Het grotere plaatje: patronen voor autonoom ontwikkelen

/loop is één onderdeel van een bredere verschuiving in hoe software in 2026 wordt geschreven. Het denkmodel verschuift van "ik schrijf code, AI helpt" naar "AI werkt, ik review en stuur". Lussen maken de versie met een langere horizon daarvan mogelijk: in plaats van Claude bij elke stap aan te sturen, beschrijf je de uitkomst en laat je hem daar autonoom naartoe itereren.

Dat werkt alleen veilig als je controlemomenten inbouwt: expliciete stopvoorwaarden, commits per iteratie en voortgangsmeldingen die je zicht geven zonder dat je erbovenop hoeft te zitten. De founders en developers die het meest uit agentische AI halen, zijn niet degene die de meest gedetailleerde instructies geven. Het zijn degene die strakke stopvoorwaarden schrijven en erop vertrouwen dat de AI het middenstuk invult.

Het juiste gebruik van /loop is niet alles automatiseren. Het is de saaie wachttijden en de repetitieve rondes automatiseren, zodat je aandacht blijft bij de onderdelen die echt een mens in de lus nodig hebben.

Snel aan de slag: probeer /loop 60 Run npm test. Report how many tests pass and fail. Stop when the full suite passes. in een project met een onbetrouwbare test. Kijk hoe Claude hem diagnosticeert en repareert zonder dat je nog een prompt hoeft te schrijven.

Related Posts

Claude Code in de praktijk: de krachtigste AI-programmeertool van 202624 juni 2026

Waarom AI moeilijk is: de echte problemen waar founders tegenaan lopen als de demo eenmaal werkt1 juli 2026

Small Language Models (SLMs): Why Smaller AI Is Winning in 2026June 23, 2026