Parallel werken met Claude Code: worktree, agents en workflows

Praktische materialen over parallel werken met agents: Ailoot-documentatie.

Deze gids brengt praktische ervaring samen met een overzicht van waar de tools van pas komen. De vier officiële Claude Code-primitieven, een overzicht van hun toepassingsgebied en een kader om de hype te doorprikken en te bepalen hoeveel parallelle agents een vibe coder echt nodig heeft. Alle cijfers en citaten verwijzen naar primaire bronnen van Anthropic.

Wat is multi-agent in Claude Code, en waarom zijn het geen “1000 agents”#

Een multi-agent-opstelling verdeelt een taak in verschillende onafhankelijke werkstromen. Elke stroom behandelt een eigen onderdeel en levert een resultaat op. Het eenvoudigste voorbeeld: je schrijft de frontend in het ene Claude Code-venster en de backend in een ander venster op dezelfde machine, met een gedeelde git-repository. Dat is al multi-agent, ook al is “orkestratie” daarvoor een onnodig groot woord.

Een uitgebreidere opstelling: binnen één Claude Code-sessie start je vijf subagents met verschillende rollen (frontendontwikkelaar, backendontwikkelaar, beveiligingsreviewer, tester, documentatieschrijver). Elk levert zijn deel van het resultaat terug aan het gedeelde gesprek. Het is dezelfde multi-agent-aanpak, maar met één besturingspunt.

Nog uitgebreider: je zegt tegen Claude: “voer wekelijks een beveiligingsaudit uit van alle 500 bestanden in mijn project”, waarna Claude een JavaScript-orchestratorscript schrijft. De runtime start enkele tientallen agents op de achtergrond. Elk controleert een eigen deel; daarna controleren onafhankelijke agents elkaars bevindingen en krijg je één rapport terug. Dit zijn Dynamic Workflows, uitgebracht door Anthropic op 28 mei 2026. Een gedetailleerde uitleg van de functie staat in de aparte gids over Dynamic Workflows.

Het verschil tussen deze drie scenario's zit niet in het aantal agents. Het verschil is wie bepaalt wat de volgende agent doet. In het eerste scenario ben jij dat. In het tweede beslist Claude terwijl het gesprek vordert. In het derde is het een JavaScript-script dat Claude heeft geschreven.

“1000 agents” is overigens een echt getal. Het is de bovengrens voor één Dynamic Workflow in Claude Code. De officiële documentatie van Anthropic vermeldt:

Met andere woorden: dit is een technische beveiliging tegen gedrag dat op hol slaat, geen aanbevolen werklast. In de praktijk zijn 2–8 parallelle werkstromen genoeg voor 95% van de taken. Als je er meer wilt plannen, vraag jezelf dan eerst af wat ze gaan doen.

4 Claude Code-primitieven: subagents, skills, agentteams en workflows#

Claude Code heeft vier officiële primitieven om één taak over meerdere agents te verdelen. Anthropic heeft ze samengebracht in een vergelijkingstabel in de documentatie over Dynamic Workflows. Hier is de vergelijking in gewone taal:

Elk van deze primitieven lost een ander probleem op. Subagents zijn bedoeld om 2–3 controles binnen één taak uit te besteden. Skills zijn handig wanneer je kant-en-klare instructies hebt die Claude moet volgen (zoals “voer een PR-review uit met deze checklist”). Agentteams zijn geschikt wanneer verschillende productonderdelen in afzonderlijke vensters staan en je één coördinator nodig hebt. Workflows zijn bedoeld voor taken die te groot zijn voor één contextvenster.

Subagents worden uitgebreid behandeld in de Claude Code Subagents 2026-gids. De beslisboom voor “wat gebruik je voor een bepaalde taak” staat in de gids Skills, Subagents, MCP, Plugins. Deze gids gaat over het samenstellen van een multi-agent-opstelling op basis van git worktree.

Niveau 1: subagents in één sessie — de makkelijkste plek om te beginnen#

Een subagent is de eenvoudigste manier om een taak te verdelen. Het hoofdgesprek is de coördinator. De hoofdagent start tijdelijke medewerkers terwijl het werk vordert.

Een concreet voorbeeld uit het beschreven project. Na de eerste versie van een gids wordt de review als volgt ingericht: Claude krijgt het verzoek: “start zes subagents parallel — één controleert op AI-signalen, de tweede op juridische woordenschat, de derde op stem en toon, de vierde controleert feiten met WebFetch, de vijfde beoordeelt de SEO-structuur en de zesde controleert de nauwkeurigheid van interne links.” Elk levert een rapport op, waarna de aanpassingen worden doorgevoerd.

Technisch gebeurt dit met bestanden in .claude/agents/[subagent-name].md waarin de rol en tools worden beschreven. De aanroep gaat via de Agent-tool in het hoofdgesprek. Claude bepaalt wanneer het een verzoek naar een subagent stuurt.

Waar het werkt. Taken met 3–7 parallelle controles van één artefact (code, tekst, ontwerp). Elke controle is onafhankelijk. De resultaten passen in het hoofdvenster.

Waar het vastloopt. Met meer dan 50 bestanden of wanneer elke controle een eigen context van 50K tokens nodig heeft, loopt het hoofdvenster vol. Dan heb je workflows of agentteams nodig.

Belangrijkste risico. Elke subagent verbruikt apart tokens. Als je er zes start voor een project met 200 bestanden en ze alle 200 opnieuw lezen, betaal je 6× zoveel. Je MOET dus precies aangeven welke bestanden de subagent moet inspecteren. Zie de gids Waar de tokens naartoe gaan in Claude Code voor meer informatie.

Niveau 2: git worktree — bestanden isoleren tussen parallelle sessies#

Wanneer subagents niet genoeg zijn en je twee volwaardige Claude Code-instanties in verschillende terminals aan dezelfde repository wilt laten werken, doet zich een bekend probleem voor. Ze beginnen hetzelfde bestand te bewerken; de een slaat het eerst op en de ander overschrijft het. Een klant vroeg het supportteam vorige week: “5 overschrijven elkaar tegelijkertijd.”

De oplossing is git worktree. Dit is een ingebouwde git-functie waarmee je meerdere werkkopieën van dezelfde repository kunt hebben, elk op een eigen branch en met een gedeelde .git-repository. Eén bron, verschillende mappen op schijf en geen overlap tussen de bestanden. Het mechanisme wordt uitgebreid beschreven in de gids Git worktree in Claude Code.

Commando's voor een installatie van vijf minuten:

# Vanuit de hoofdmap van het project
cd ~/projects/my-app

# Maak een worktree voor feature/auth
git worktree add ../my-app-auth feature/auth

# Maak een worktree voor feature/billing
git worktree add ../my-app-billing feature/billing

# Open twee terminalvensters
cd ~/projects/my-app-auth && claude   # eerste Claude Code
cd ~/projects/my-app-billing && claude # tweede Claude Code

Elke kopie staat op een eigen branch. Elke Claude Code-instantie schrijft naar een eigen map. Voer na afloop van de taak git push uit vanuit de branch en daarna git worktree remove ../my-app-auth.

Wat je moet weten. Een worktree dupliceert geen node_modules, .venv of andere bestanden in .gitignore. Heb je onafhankelijke dependencies nodig (bijvoorbeeld een andere bibliotheekversie op elke branch), voer dan na worktree add afzonderlijk npm install uit in de nieuwe map.

Hoeveel worktrees per persoon. Volgens teamenquêtes uit 2026 ligt de praktische bovengrens op 4–8 parallelle worktrees per ontwikkelaar. De beperkende factor is niet Claude, maar het vermogen van een persoon om de resultaten te beoordelen en te accepteren. Met 10 worktrees staan er resultaten op review te wachten.

In de beschreven praktijk gebruiken mensen doorgaans 2–3 parallelle worktrees. Eén primaire worktree voor actief werk, één reserve voor urgente hotfixes en één voor een experiment (een nieuwe functie waarover je twijfelt). Meer zijn niet nodig.

Niveau 3: agentteams — meerdere vensters, één leidende agent#

Agentteams zijn een relatief nieuw primitief. Het idee: één leidende agent bewaart het gedeelde plan als takenlijst en meerdere gelijkwaardige sessies in afzonderlijke vensters nemen taken op zich die de leider toewijst. Ze werken allemaal in hetzelfde bestandssysteem en kunnen elkaars tussentijdse artefacten zien.

Dit is nuttig wanneer een taak uiteenvalt in 3–5 grote werkstromen die elk uren duren (een grote module migreren, een subsysteem herschrijven, een volledige beveiligingsaudit uitvoeren). De leidende agent bewaart het plan in één gedeeld taakbestand op een absoluut pad buiten de worktrees. Uitvoerders lezen dat pad en rapporteren resultaten; alleen de leider werkt statussen bij, zodat niet meerdere schrijvers aan het coördinatiebestand werken.

Technisch gezien zijn agentteams meerdere vensters boven op git worktree met één gedeeld planningspunt. In de praktijk beheert 80% van de mensen agentteams handmatig (zoals hierboven beschreven met worktree) en gebruiken ze geen speciaal “teams-framework”. Dat is prima.

Als je twijfelt of je überhaupt een framework nodig hebt, is het antwoord vrijwel zeker nee. Gebruik handmatig worktree en één leidende agent in de hoofdmap.

Niveau 4: Dynamic Workflows — Claude schrijft een JS-orkestratiescript#

In de drie bovenstaande niveaus blijft het plan in een gesprek: in het hoofd van de hoofdagent of in de takenlijst van de leidende agent. Dynamic Workflows verplaatsen het plan naar code. Claude drukt de taak uit als JavaScript-script, de runtime voert het uit in een geïsoleerde omgeving, tussentijdse resultaten staan in scriptvariabelen in plaats van in je context en de sessie blijft responsief terwijl agents op de achtergrond werken.

Een concreet voorbeeld uit de officiële documentatie. Je zegt:

ultracode: voer een audit uit van elk API-endpoint onder src/routes/ op ontbrekende auth-controles

Claude schrijft een JavaScript-script met ongeveer deze logica: neem alle bestanden uit src/routes/, verdeel ze in groepen van 30 endpoints, start voor elke groep een agent met dezelfde controle, laat daarna twee onafhankelijke beoordelaarsagents hun bevindingen controleren en bundel de resultaten in een eindrapport. Het script wordt uitgevoerd. Je krijgt een tabel met resultaten en een lijst met endpoints die beslist beoordeeld moeten worden.

Waar het werkt.

• Een volledig project controleren op één probleem (beveiliging, typing, verouderde API's).
• Grote migraties (500+ bestanden waarop dezelfde regel van toepassing is).
• Onderzoeksvragen die vanuit meerdere onafhankelijke invalshoeken moeten worden gecontroleerd (Anthropic doet dit met het ingebouwde commando /deep-research).

Een uitgebreide analyse van Dynamic Workflows, de limieten en de werking van ultracode staat in de aparte gids over Dynamic Workflows in Claude Code.

Wanneer je het NIET moet gebruiken. Wanneer de taak lineair en duidelijk is. Een workflow is niet nodig voor een taak als “rond deze component af”. Een workflow is zinvol wanneer een taak uiteenvalt in 10+ onafhankelijke subtaken die je onderling moet controleren.

Belangrijkste beperking. Een workflow verbruikt aanzienlijk meer tokens dan een gewone sessie. Anthropic raadt in de documentatie het volgende aan:

Met andere woorden: voer je eerste workflow uit op één map, niet op het hele project. Kijk wat het kost en beslis daarna of opschalen de moeite waard is.

Outcomes: een rubric met criteria en een onafhankelijke reviewer#

Het gevaarlijkste aan multi-agent-werk is de uitvoer van agents vertrouwen. Elke agent levert tekst op die eruitziet als afgerond werk. Een citaat lijkt waar, een rapport lijkt volledig, een migratie lijkt klaar. Met één agent kun je het zelf controleren. Met 10 lukt dat niet — je hebt er geen tijd voor.

Anthropic pakt dit probleem aan met Outcomes, een functie van Managed Agents die op 6 mei 2026 werd uitgebracht. Het idee is eenvoudig: de sessie krijgt een TWEEDE agent (een beoordelaar) die uitsluitend het werk van de eerste agent controleert aan de hand van een strikte rubric.

Zo werkt het technisch. Je schrijft een rubric — een markdown-document met een gedetailleerde lijst van wat “klaar” betekent, welke bronnen gecontroleerd moeten worden en welke labels je moet gebruiken. Het platform maakt automatisch een beoordelaarsagent aan in een vers contextvenster. Die ontvangt alleen de rubric en het resultaat, verder niets. Na elke poging van de hoofdagent (de schrijver) leest de beoordelaar het resultaat opnieuw en keurt het goed of geeft een puntsgewijze lijst terug van wat nog niet af is.

Een citaat uit de Anthropic Cookbook:

Concrete impactcijfers: nadat Outcomes werd geïntegreerd in Claude Managed Agents, steeg het voltooiingspercentage van taken bij AI-bedrijf Harvey met ongeveer 6×. Bij Wisedocs (medische documentatie) daalde de tijd die nodig was om een document te controleren met 50%. Deze cijfers komen uit de officiële aankondiging van de functie.

Wat relevant is voor een vibe coder, in plaats van een onderneming: Outcomes is een werkwijze, niet alleen een specifieke functie. Je kunt je eigen beoordelaarsagent maken door dezelfde criteria te beschrijven in .claude/agents/grader.md en de hoofdagent te vragen die na elke poging uit te voeren. Dit werkt met elke multi-agent-opstelling, niet alleen met Managed Agents.

De belangrijkste regel voor het schrijven van rubrics uit de Cookbook is iets verifieerbaars te specificeren, geen algemene opdracht. Niet “controleer of de briefing facturering behandelt”, maar “open de briefing, zoek het gedeelte over facturering en controleer of er een bedrag in $ of een percentage van de omzet staat”. Bij de eerste instructie kan de beoordelaar er vluchtig naar kijken en een vakje aanvinken. De tweede dwingt de beoordelaar het document te openen en een specifiek getal te vinden.

Antipatroon: “50 agents die onzin doen”#

Dit is het centrale multi-agent-antipatroon. Iemand ontdekt dat Claude Code 16 agents tegelijk kan draaien en Dynamic Workflows 1000 per run aankan, gaat zitten en start ze op. Het effect: nul. Tokenverbruik: 10× dat van een gewone sessie.

Een eenvoudige test. Pak een vel papier en teken voor elke agent een vak. Schrijf in elk vak:

1. Wat die precies doet (één zin).
2. Welke bestanden die aanraakt.
3. Wat die oplevert.
4. Wie het controleert.

Kun je ook maar één van deze vragen niet binnen 30 seconden beantwoorden, dan heb je die agent niet nodig. Deze regel geldt op elk niveau: subagents, agentteams en Dynamic Workflows.

Het tweede antipatroon is werk parallel uitvoeren dat sequentieel moet gebeuren. Als de frontend eerst de backend nodig heeft omdat die het API-schema leest, voer ze dan niet parallel uit. Doe eerst de backend en daarna de frontend. Taken mogen alleen parallel worden uitgevoerd als ze onafhankelijk zijn.

Het derde antipatroon is multi-agent gebruiken voor snelheid. Dat werkt maar tot op zekere hoogte. Als je een taak in vier onafhankelijke werkstromen verdeelt, zijn ze ongeveer klaar in de tijd die één stroom nodig zou hebben (met minimale extra coördinatie). Maar als er 50 stromen op één machine draaien, werkt elke stroom langzamer omdat ze de CPU delen. De praktische bovengrens op een laptop is 4–6 gelijktijdige Claude Code-instanties; daarna begint throttling.

Wat kost het, en hoe voorkom je dat je je limieten opgebruikt?#

In mei–juni 2026 kreeg de sector te maken met de realiteit dat AI-programmeren duurder was dan verwacht.

Eén gewone Claude Code-chatsessie kost relatief weinig. Zet Dynamic Workflows in voor een hele repository en je rekening wordt 20× zo hoog. De officiële documentatie van Anthropic zegt:

Wat doe je in de praktijk? De besparingsregels uit de beschreven praktijk:

1. Geef elke agent nauwkeurig op welke bestanden die moet bekijken. Niet “bekijk het project en zoek problemen”, maar “bekijk src/auth/*.ts en controleer of elke functie userId valideert”. Met de tweede prompt weet je precies voor welk werk je betaalt.

2. Probeer een workflow altijd eerst op één map. Niet op heel src/. Begin met src/auth/. Bevalt het resultaat en begrijp je de kosten, breid het dan uit.

3. Gebruik standaard /effort high en zet ultracode alleen bewust in. /effort ultracode betekent xhigh plus automatische orkestratie. Dat is erg duur. Gebruik het wanneer een taak echt meerdere parallelle werkstromen vereist.

4. Schakel waar mogelijk over op een kleiner model voor subagents. Als zes subagents één gids beoordelen, hebben noch de QA-agent die op AI controleert, noch de controleur van interne links Opus nodig. Sonnet volstaat. Dat verlaagt het gebruik met 3–5×.

Een uitgebreide blik op tokenbesparing vind je in de gidsen Waar de tokens naartoe gaan in Claude Code en Hoe je Claude Code-limieten niet opgebruikt.

Waar je vandaag begint: een checklist van 30 minuten#

1. Werk Claude Code bij naar v2.1.154+

   Dit is de minimumversie die Dynamic Workflows ondersteunt. Voer claude update uit in de terminal.

2. Schakel Dynamic Workflows in via /config

   Standaard zijn ze uitgeschakeld op het Pro-abonnement. Open /config, zoek de regel “Dynamic workflows” en schakel die in. Op Max, Team en Enterprise zijn ze al ingeschakeld.

3. Maak je eerste worktree

   Voer in de hoofdmap van het project git worktree add ../<project>-experiment <branch> uit. Open een tweede terminalvenster in die map. Voer claude uit.

4. Voeg een gedeelde takenlijst toe

   Gebruik één absoluut pad buiten alle worktrees. Een tasks.md in elke worktree is een apart bestand en synchroniseert niet vanzelf. Laat alleen de leidende sessie schrijven; uitvoerders lezen de gedeelde lijst en rapporteren resultaten aan de leider.

   Maak coördinatiemap en takenlijst één keer:

   mkdir -p "$HOME/projects/my-app-coordination"
   printf '%s\n' '# Tasks' '- Auth: assigned to the auth worktree' '- Billing: assigned to the billing worktree' > "$HOME/projects/my-app-coordination/tasks.md"
   

   In de eerste terminal:

   cd "$HOME/projects/my-app-auth"
   printf 'Shared task list: %s\n' "$HOME/projects/my-app-coordination/tasks.md"
   claude
   

   In de tweede terminal:

   cd "$HOME/projects/my-app-billing"
   printf 'Shared task list: %s\n' "$HOME/projects/my-app-coordination/tasks.md"
   claude
   

   Geef in beide sessies hetzelfde hierboven afgedrukte uitgewerkte absolute pad: “Lees deze gedeelde takenlijst. Werk alleen aan jouw toegewezen taak en bestanden. Bewerk de lijst niet; meld voltooiing en blokkades aan de leider die de updates beheert.” Controleer vóór de start dat beide agents exact dat bestand kunnen lezen; een toestemmingsvraag voor dat pad moet worden opgelost. De lijst coördineert status, terwijl codewijzigingen in afzonderlijke worktrees blijven.

5. Werk een week op deze manier

   Installeer niet meteen een GUI-wrapper. Werk een week handmatig met twee worktrees. Je ziet wat ontbreekt; kies daarna een tool voor een specifiek knelpunt.

6. Schakel pas daarna `/effort ultracode` in

   Kies één taak, zoals “zoek alle API-endpoints zonder auth-controles in src/routes/”. Schakel /effort ultracode in. Kijk welke workflow Claude schrijft, hoeveel die kost en welk resultaat die oplevert. Dat is je eerste Dynamic Workflow.

Hoe je verdergaat: geheugen tussen sessies, Code Review en Multi-Agent v2#

Wat is er in mei–juni 2026 verschenen, en waar gaat multi-agent in Claude Code naartoe?

Managed Agents met Dreaming. Uitgebracht op 6 mei 2026 tijdens Code with Claude. Een geplande verwerking leest tussen sessies door de eerdere transcripten van een agent, herkent terugkerende patronen en werkt het geheugen bij. De taakvoltooiing bij het AI-juridische bedrijf Harvey steeg specifiek na Dreaming zesvoudig. Nog steeds in research preview.

Outcomes als functie van Managed Agents. Hierboven beschreven. Beschikbaar via de Claude Agent SDK, niet rechtstreeks via de Claude Code CLI. Je kunt hetzelfde patroon nu handmatig toepassen met een beoordelaarsubagent.

Multi-Agent Orchestration v2 in de Claude Agent SDK. Een leidende agent delegeert zelf taken aan subagents met behulp van een gedeeld bestandssysteem. Dit is de overgang van “N subagents handmatig starten” naar “een taak beschrijven, waarna de leider zelf bepaalt aan wie en hoe die delegeert”. Ben je net subagents aan het leren, maak je dan nog geen zorgen over v2. Leer eerst het klassieke patroon — “één hoofdagent + 3–5 subagents met rollen” — en stap over 3–6 maanden vanzelf over op v2.

Code Review door een team agents. Anthropic kondigde tijdens Code with Claude een functie aan voor automatische code-review wanneer een PR wordt geopend. Een team AI-agents controleert de diff parallel, zoekt bugs, verifieert bevindingen onderling en rangschikt ze op ernst. Beschikbaar voor Team en Enterprise, nog niet voor Pro.

Plugin Marketplace. Gelanceerd op 23 mei 2026 in v2.1.128-136. Sommige marketplace-plugins zijn kant-en-klare multi-agent-opstellingen (parallel-review, security-audit, migration-helper). Je kunt ze installeren met /plugin install <name>@claude-plugins-official en bekijken hoe ze zijn opgebouwd — een goede manier om te leren hoe je je eigen plugins schrijft.

Multi-agent in Claude Code is nog altijd een verzameling primitieven met uiteenlopende volwassenheidsniveaus. Subagents en git worktree zijn stabiel, bewezen en overal bruikbaar. Agentteams zijn deels geautomatiseerd en deels handmatig. Dynamic Workflows zijn in research preview en veranderen snel. Managed Agents v2 is alleen voor bedrijven. Dat betekent dat de optimale opstelling voor een vibe coder het komende jaar niet de nieuwste release is, maar de minimale opstelling die de specifieke taak nodig heeft. Twee worktrees en één beoordelaarsubagent volstaan voor een maand actief werk. Voeg pas complexiteit toe wanneer je beperkingen begint te voelen.

Een werkende opstelling voor vibe coding#

Praktische materialen: Ailoot-documentatie.

Meer materialen en tools: Ailoot.