# Git worktree in Claude Code: parallelle sessies > Hoe je --worktree, .worktreeinclude, worktree.baseRef en subagent-isolatie gebruikt. Verschillen met branches, worktrees opruimen en veelgemaakte fouten. Source: https://ailoot.ai/blog/nl/claude-code-git-worktree/ Canonical: https://ailoot.ai/blog/nl/claude-code-git-worktree/ Language: nl Publisher: Ailoot (https://ailoot.ai/) Translation: guide-045 Revision: sha256-4b40335a4c322490e4e6817777e50095e5e7c3bd6267e3f97a24e939ada76a1b [Praktische informatie over werken met Ailoot vind je in de documentatie](https://ailoot.ai/docs/). ## Wat is een git worktree in Claude Code
Belangrijkste inzicht Een Git worktree is een aparte werkmap voor een andere branch van dezelfde repository. De opdracht `claude --worktree ` maakt automatisch een worktree aan in `.claude/worktrees//` en start Claude Code daarin. Twee terminals → twee sessies → verschillende bestanden op schijf, zonder elkaar in de weg te zitten. Standaard beschikbaar in Claude Code v2.0+, configureerbaar met `.worktreeinclude` voor geheimen en `worktree.baseRef` om de basisbranch te kiezen.
Meerdere agents parallel in dezelfde map starten is het voornaamste pijnpunt van vibe-coden op het tempo van 2026. AI-agents schrijven code sneller dan iemand kan bijhouden wie waarmee bezig is. Zonder bestandsisolatie eindigt het parallel starten van twee Claude Code-sessies in één map ermee dat de ene sessie het werk van de andere overschrijft. Git worktree lost dit op bestandsysteemniveau op. Je hebt één hoofdmap waarin je werkt. De opdracht `claude --worktree feature-auth` maakt de map `.claude/worktrees/feature-auth/` aan op een aparte branch en start Claude Code daar. De bestanden zijn geïsoleerd. Wijzigingen in de ene sessie zijn niet zichtbaar voor de andere totdat je ze expliciet samenvoegt. De officiële documentatie van Anthropic beschrijft het als volgt:

Als elke Claude Code-sessie in een eigen worktree draait, hebben bewerkingen in de ene sessie nooit invloed op bestanden in een andere. Je kunt in de ene terminal een functie bouwen en in een andere een bug oplossen.

— Anthropic Docs, https://code.claude.com/docs/en/worktrees
Een tip om zelf te controleren: als je ooit een commit hebt gekregen waarvan de helft van de bestanden door iemand anders was gemaakt, heb je een worktree nodig. ## Hoe git worktree verschilt van een gewone branch
Belangrijkste inzicht Een gewone `git checkout` wisselt de werkmap in dezelfde map om — de oude bestanden verdwijnen van schijf totdat je terugkeert naar de branch. `git worktree add` maakt een **tweede map** aan voor een andere branch, naast de eerste. Beide branches staan tegelijkertijd op schijf; je wisselt ertussen met een eenvoudige `cd`. Onder de motorkap is er één `.git`-repository, met gedeelde geschiedenis en een gedeelde remote. Alleen meerdere werkkopieën.
De standaard Git-werkwijze: je zit op de branch `main` en voert `git checkout feature-x` uit — Git overschrijft de bestanden in de werkkopie. Een draaiende `npm run dev` loopt vast omdat `package.json` onder het proces is gewijzigd. Je stash’t je niet-gecommitte wijzigingen en wacht tot de IDE opnieuw heeft geïndexeerd. Je schakelt terug en alles wordt weer overschreven, dus je moet opnieuw stashen en poppen. Git worktree biedt een andere mogelijkheid: in plaats van **één** map tussen branches te wisselen, maak je een **tweede** map aan voor een andere branch. De opdracht `git worktree add ../project-feature-x feature-x` maakt de map `../project-feature-x/` aan met de bestanden van branch `feature-x`. Je `main` blijft in de oorspronkelijke map en de dev-server blijft draaien. | Parameter | `git checkout`-branch | `git worktree add` | |----|----|----| | Bestanden in de werkkopie | Worden overschreven | Verschijnen in een nieuwe map | | Parallel werken aan twee branches | Nee | Ja | | Niet-gecommitte wijzigingen | `git stash` nodig | Niets nodig | | Wisselsnelheid | Hangt af van de omvang van de verschillen | Gewoon `cd` | | Schijfruimte | 1× | N× (één kopie van de bestanden per branch) | Eerder moest je de worktree-modus in Claude Code handmatig instellen: `git worktree add`, daarna `cd`, daarna `claude` — en dit in elke terminal opnieuw. De vlag `--worktree` (ook `-w`) doet alle drie in één opdracht. ## De eerste parallelle sessie starten: de vlag `--worktree`
Belangrijkste inzicht De opdracht `claude --worktree feature-auth` maakt een worktree aan in `.claude/worktrees/feature-auth/`, maakt de branch `worktree-feature-auth` aan vanaf `origin/HEAD` en start Claude Code daar. Je hoeft niet handmatig `git worktree add` of `cd` uit te voeren. Herhaal dit in de naastgelegen terminal met een andere naam om twee onafhankelijke sessies te krijgen. Als je de naam weglaat (`claude --worktree`), genereert Claude een willekeurige naam, zoals `bright-running-fox`.
Minimaal voorbeeld. Open de eerste terminal in de hoofdmap van het project: ```bash claude --worktree feature-auth ``` Claude Code doet drie dingen: 1. Maakt `.claude/worktrees/feature-auth/` aan met een momentopname van `origin/HEAD` (meestal je standaardbranch). 2. Maakt een nieuwe branch `worktree-feature-auth` aan. 3. Start de sessie in deze map. Open een tweede terminal in dezelfde hoofdmap van de repository: ```bash claude --worktree bugfix-123 ``` Klaar. Twee Claude Code-sessies, verschillende bestanden op schijf, verschillende Git-branches. Als je in de eerste authenticatie schrijft en in de tweede een falende test oplost, kunnen ze elkaar fysiek niet in de weg zitten. Als je geen naam wilt typen, bedenkt Claude er een: ```bash claude --worktree # → maakt iets aan als .claude/worktrees/bright-running-fox/ ``` Een tip voor beginners met Git: voeg `.claude/worktrees/` toe aan `.gitignore`. Anders zie je bij `git status` in de hoofdmap de inhoud van alle worktrees als niet-gevolgde bestanden: ``` # .gitignore .claude/worktrees/ ``` Valkuil om te vermijden: open vóór de eerste start met `--worktree` in een nieuwe map eerst de gewone `claude` (zonder de vlag) en accepteer de dialoog voor vertrouwen in de werkruimte. Zo niet, dan mislukt de vlag met de foutmelding “trust not accepted” — ook als je die combineert met `-p` voor de headless-modus. ## Waar worktrees staan en hoe je ze vindt
Belangrijkste inzicht Standaard staan alle worktrees in `.claude/worktrees//`, naast de hoofdmap van je repository. Voer `git worktree list` uit om de lijst te bekijken. Gebruik `cd .claude/worktrees/feature-auth` om handmatig een worktree te openen. Als je binnen een Claude-sessie wilt wisselen, vraag je om “naar een andere worktree te schakelen”; Claude gebruikt dan de ingebouwde tool EnterWorktree. De oude worktree blijft onaangeroerd op schijf staan.
De standaardlocatie staat vast: `.claude/worktrees//` in de hoofdmap van de repository. Staat je project in `~/dev/my-app/`, dan staat de `feature-auth`-worktree in `~/dev/my-app/.claude/worktrees/feature-auth/`. Voor afwijkende indelingen (bijvoorbeeld als je de worktree buiten de repository wilt plaatsen) is er de hook `WorktreeCreate` — daarover verderop meer in het gedeelte over SVN en Mercurial. Binnen één Claude-sessie kun je naar een andere bestaande worktree schakelen. Zeg in de chat gewoon: “schakel over naar `.claude/worktrees/bugfix-123`,” en Claude roept de tool `EnterWorktree` aan. De huidige map blijft onaangeroerd — je kunt op dezelfde manier teruggaan. De standaard Git-opdracht toont een lijst van alle worktrees, inclusief de hoofdworktree en handmatig aangemaakte worktrees: ```bash git worktree list ``` De uitvoer ziet er ongeveer zo uit: ``` /home/user/dev/my-app abc1234 [main] /home/user/dev/my-app/.claude/worktrees/feature-auth def5678 [worktree-feature-auth] /home/user/dev/my-app/.claude/worktrees/bugfix-123 9876fed [worktree-bugfix-123] ``` ## `.env` en geheimen kopiëren: het bestand `.worktreeinclude`
Belangrijkste inzicht Een worktree is een verse checkout. Bestanden uit `.gitignore` (`.env`, `.env.local`, lokale configuraties) ontbreken in de nieuwe map. Zonder die bestanden werken `npm run dev` of `prisma db push` niet. Het bestand `.worktreeinclude` in de hoofdmap van het project gebruikt de syntaxis van `.gitignore` en geeft Claude Code aan welke bestanden automatisch naar elke nieuwe worktree moeten worden gekopieerd. Het wordt gebruikt voor `--worktree`, worktrees van subagents en sessies in de desktop-app.
Wanneer `--worktree` een nieuwe map aanmaakt, bevat die alleen wat in Git is gecommit. `.env` met API-sleutels en `.env.local` met lokale configuratie staan in `.gitignore`, dus ze zitten niet in de worktree. De allereerste `npm run dev` mislukt dan met “MISSING DATABASE_URL”. De zelfgemaakte oplossing is om `.env` na elke `--worktree` handmatig te kopiëren. Dat werkt één keer en wordt daarna vergeten. De oplossing van Anthropic is een bestand `.worktreeinclude` in de hoofdmap van het project, met daarin de door Git genegeerde bestanden die automatisch naar elke nieuwe worktree worden gekopieerd. Maak in de hoofdmap van de repository een bestand `.worktreeinclude` aan: ``` .env .env.local config/secrets.json ``` De syntaxis is hetzelfde als die van `.gitignore`. Je kunt globpatronen gebruiken: ``` .env* *.local config/*.json .vscode/settings.json ``` Anthropic geeft een duidelijke regel om ongelukken te voorkomen:

Het bestand gebruikt de syntaxis van gitignore. Alleen bestanden die aan het patroon voldoen én ook door Git worden genegeerd, worden gekopieerd. Bestanden die door Git worden bijgehouden, worden nooit gedupliceerd.

— Anthropic Docs, https://code.claude.com/docs/en/worktrees
Met andere woorden: je kunt `package.json` niet per ongeluk via `.worktreeinclude` kopiëren — het staat niet in `.gitignore`. Je kunt daar dus veilig alle patronen opnemen. Dezelfde `.worktreeinclude` werkt in drie modi: handmatige `--worktree`, automatische worktrees voor subagents (zie hieronder) en sessies vanuit de Claude-desktopapp. ## Een worktree vanuit een pull request voor codebeoordeling
Belangrijkste inzicht De opdracht `claude --worktree "#1234"` haalt pull request \#1234 op van origin en maakt een worktree met de PR-branch aan in `.claude/worktrees/pr-1234/`. Je kunt de volledige URL meegeven: `claude --worktree https://github.com/OWNER/REPO/pull/1234`. Handig voor codebeoordeling: open de PR in een eigen map; Claude kan tests uitvoeren, logs lezen en een opmerking schrijven, terwijl de hoofdrepository onaangeroerd blijft.
Een gebruikelijk scenario voor codebeoordeling: een collega heeft een PR gestuurd; je moet de code inspecteren, tests uitvoeren en een opmerking achterlaten. Met een gewone `git checkout pull/1234/head` wissel je de werkkopie opnieuw om en breek je je actieve sessie. Met de vlag `--worktree` doe je dit met één opdracht: ```bash claude --worktree "#1234" ``` Wat er gebeurt: Claude Code voert `git fetch origin pull/1234/head` uit, maakt een worktree aan in `.claude/worktrees/pr-1234/` en checkt de PR-branch uit. De sessie start. Je kunt meteen vragen: “lees de diff, voer de tests uit en zoek logische fouten” — terwijl Claude werkt, blijft je hoofdsessie op `main` draaien. De alternatieve syntaxis is de volledige URL van de pull request: ```bash claude --worktree https://github.com/OWNER/REPO/pull/1234 ``` Gebruik in een echt project: als je `claude --worktree "#N"` combineert met je eigen subagent voor codebeoordeling, krijg je binnen een minuut of twee een automatische beoordeling. Start die op de achtergrond, werk verder in het hoofdvenster en bekijk het resultaat via `claude agents`. ## Basisbranch: `worktree.baseRef` voor `fresh` of `head`
Belangrijkste inzicht Standaard vertakt een worktree vanaf `origin/HEAD` — de meest recent met de remote gesynchroniseerde commit. Dat is een veilige, “schone” start. Wil je lokale nog niet gepushte commits in de worktree, stel dan `worktree.baseRef: "head"` in. HEAD identificeert een commit; ongecommitte gevolgde bewerkingen blijven in de oorspronkelijke werkkopie en vereisen een aparte expliciete overdracht. Handig wanneer een subagent verder moet werken op je huidige functie zonder naar main over te schakelen. Alleen `fresh` of `head` worden geaccepteerd; willekeurige refs worden niet ondersteund.
De standaardinstelling is als volgt: elke nieuwe worktree begint vanaf `origin/HEAD`. Het voordeel is een schone start waarvan gegarandeerd is dat die overeenkomt met wat CI te zien krijgt. Het nadeel is dat niet-gecommitte wijzigingen of meerdere lokale commits boven op de remote in je huidige branch niet in de nieuwe worktree worden opgenomen. Voeg dit aan `.claude/settings.json` (of globale instellingen) toe om een worktree vanaf je huidige lokale HEAD-commit te starten: ```json { "worktree": { "baseRef": "head" } } ``` Nu begint `claude --worktree experimental-feature` vanaf de huidige lokale `HEAD`. Dit helpt wanneer je functie al lokale commits heeft die niet zijn gepusht. Gevolgde bewerkingen die nog niet zijn gecommit ontbreken. Heeft de subagent die nodig, bewaar en verplaats vereiste wijzigingen dan expliciet en bekijk de bestemmingsdiff; verwar dat niet met `.worktreeinclude`, dat genegeerde lokale bestanden behandelt. De instelling accepteert precies twee waarden: `"fresh"` (= `origin/HEAD`) en `"head"` (= lokale HEAD). Willekeurige refs zoals `"feature-branch"` of een commit-hash worden niet ondersteund — een bewuste beperking om een combinatorische explosie aan opties te voorkomen. ## Subagents automatisch isoleren: `isolation: worktree`
Belangrijkste inzicht Een subagent in Claude Code is een gespecialiseerde agent die één taak uitvoert (codebeoordeling, refactoring, onderzoek). Als je vanuit één sessie meerdere subagents parallel start, werken ze standaard in dezelfde map en kunnen ze elkaars bestanden overschrijven. Voeg `isolation: worktree` toe aan de frontmatter van de subagent om elke agent een tijdelijke worktree te geven; als die niets heeft gecommit, wordt de worktree aan het einde netjes verwijderd.
Wanneer je Claude vraagt: “start drie subagents: de ene leest de database, de tweede bekijkt de API en de derde controleert de tests”, werken ze standaard alle drie in je werkkopie. Als zelfs twee van hen tegelijkertijd naar hetzelfde bestand schrijven, ontstaat er een conflict. De oplossing is om elk automatisch een eigen worktree te geven. Methode 1: vraag het mondeling. Schrijf in het gesprek aan Claude: ``` Use worktrees for your agents. ``` Claude past de isolatie toe op alle volgende subagents in deze sessie. Methode 2: stel het expliciet in bij de subagent zelf. Voeg in het bestand van de subagent (bijvoorbeeld `.claude/agents/code-reviewer.md`) een veld toe aan de frontmatter: ```yaml --- name: code-reviewer description: Reads the diff and writes code review comments isolation: worktree --- You're a meticulous reviewer. Read the diff and look for logic errors... ``` Nu krijgt deze subagent bij elke start een tijdelijke worktree in `.claude/worktrees/`. Als de subagent niets heeft gewijzigd, wordt de map automatisch verwijderd wanneer die klaar is. Als er niet-gecommitte wijzigingen zijn, vraagt Claude of je die wilt behouden of verwijderen. De basisbranch voor worktrees van subagents is dezelfde als voor `--worktree`: standaard `origin/HEAD`; met `worktree.baseRef: head` wordt het de lokale `HEAD`. ## Beslismatrix: worktree, `/bg`, subagent of Agent View
Belangrijkste inzicht Vier Claude Code-mechanismen die vaak met elkaar worden verward. Worktree is **bestandsisolatie** (schijf). `/bg` is een **achtergrondsessie** (context en tokens). Subagent is een **gespecialiseerde eenmalige agent** (prompt en tools). Agent View is een **dashboard voor alle sessies** (UI). Je kunt ze combineren: `/bg` maakt automatisch een worktree aan, een subagent met `isolation: worktree` start in een tijdelijke worktree en Agent View toont ze alle drie als rijen in één lijst.
| Tool | Wat het isoleert | Wanneer je het gebruikt | |----|----|----| | `claude --worktree ` | Bestanden (aparte map + branch) | Je wilt handmatig N sessies parallel laten draaien in verschillende terminals | | `/bg` (of `Ctrl+B`) | Context en tijd | Een lange taak wanneer je het huidige venster niet wilt blokkeren. Onder de motorkap wordt een worktree aangemaakt | | Subagent met `isolation: worktree` | Bestanden binnen één sessie | Eén prompt wijst werk toe aan N agents en je wilt voorkomen dat ze elkaars bestanden overschrijven | | `claude agents` (Agent View) | Niets, het is een UI | Je wilt alle draaiende / gepauzeerde / voltooide sessies in één dashboard bekijken | | `/goal` | Autonomiebeheer | Je wilt Claude zonder prompts tussen beurten laten werken totdat aan een voorwaarde is voldaan | Typische combinaties: - **“2 functies handmatig parallel”** — twee terminals, elk met `claude --worktree`. Het eenvoudigste geval. - **“Start een nachtelijke refactor; ik sluit de app”** — `/bg` + `/goal` met een voltooiingsvoorwaarde. De sessie draait onafhankelijk van je venster. - **“Eén prompt, drie parallelle onderzoeken”** — drie subagents met `isolation: worktree`. Elk in een eigen sandbox. - **“Wat draait er nu?”** — `claude agents`. Een dashboard met filters voor “running”, “blocked” en “done” voor alle sessies. ## 5 valkuilen bij het werken met worktrees
Belangrijkste inzicht De meest voorkomende problemen: `.worktreeinclude` vergeten, waardoor de omgeving niet werkt; een worktree verwarren met een gewone branch en niet-gecommitte wijzigingen kwijtraken; 5+ parallelle sessies openhouden en vergeten wat waar staat; `cleanupPeriodDays` niet configureren, waardoor ongebruikte mappen zich opstapelen; en de vertrouwensdialoog in een nieuwe map vergeten, waardoor `--worktree` met een foutmelding mislukt.
**1. Een worktree gestart, `.env` ontbreekt, niets werkt.** Het meest voorkomende probleem. Een worktree is een verse checkout zonder bestanden die door Git worden genegeerd. De oplossing is om meteen bij het instellen van de worktree-modus een `.worktreeinclude`-bestand toe te voegen met `.env*` en de benodigde lokale configuraties. Controleer of het bestand in de hoofdmap van de repository staat, niet in `.claude/`. **2. Je wilt naar de main-branch schakelen, voert `cd` naar de hoofdmap uit en denkt dat je je niet-gecommitte wijzigingen in de worktree kwijt bent.** De hoofdmap en de worktree zijn **verschillende** werkkopieën. Je bent teruggegaan met `cd`; de wijzigingen in de worktree zijn blijven staan — ze zijn nergens heen gegaan. Maar als je in de war raakt en `git stash` uitvoert in de hoofdmap omdat je denkt dat je in de worktree zit, wordt de stash aangemaakt op de main-branch, niet op de branch die je verwachtte. **3. Je hebt 5 parallelle sessies gestart en weet niet meer wat elke sessie doet.** De documentatie van Anthropic waarschuwt uitdrukkelijk dat de meeste ontwikkelaars cognitief niet meer dan 2–3 sessies aankunnen. Een teken van overbelasting is dat je Agent View opent en niet meteen kunt zeggen wat elke agent doet. Beperk jezelf tot twee gelijktijdige sessies. Als de taak er meer vereist, moet die via `/goal` + subagents worden aangestuurd, niet handmatig. **4. Worktrees gestart met `-p` (headless) worden niet automatisch opgeruimd.** De opdracht `claude --worktree feature-x -p "do thing"` toont geen interactieve afsluitprompt, dus er is geen moment waarop Claude vraagt “de worktree verwijderen?”. Deze worktrees stapelen zich op. Ruim ze handmatig op: `git worktree remove .claude/worktrees/feature-x`. Of gebruik een cron-script dat alles ouder dan 7 dagen verwijdert. **5. Vertrouwensdialoog in een nieuwe map.** Als je de repository voor de eerste keer opent en meteen `claude --worktree` uitvoert, mislukt de opdracht. Voer `claude` uit zonder vlaggen, accepteer het vertrouwen in de werkruimte en sluit af — daarna werkt `--worktree`. Dit is bewust zo opgezet, zodat Claude zonder toestemming van de gebruiker geen toegang krijgt tot het project van iemand anders. ## Opruimen: wat automatisch wordt verwijderd
Belangrijkste inzicht Een worktree die met `--worktree` is aangemaakt en geen wijzigingen bevat (geen commits, niet-gevolgde bestanden of niet-gecommitte wijzigingen), wordt automatisch verwijderd wanneer je afsluit. Bij wijzigingen vraagt Claude het. Worktrees van subagents en `/bg` worden automatisch verwijderd door de time-out `cleanupPeriodDays` in de instellingen, als ze schoon zijn. Worktrees van `-p` worden helemaal niet opgeruimd — verwijder ze handmatig met `git worktree remove`.
De opruimlogica hangt af van wat je in de worktree hebt gedaan en hoe je de sessie bent gestart. De documentatie van Anthropic noemt drie scenario’s:

Als de worktree geen niet-gecommitte wijzigingen, niet-gevolgde bestanden of nieuwe commits bevat, worden de worktree en de branch automatisch verwijderd wanneer je de sessie afsluit. Als de sessie een naam heeft, vraagt Claude het in plaats van de worktree te verwijderen, zodat je die later kunt behouden.

— Anthropic Docs, https://code.claude.com/docs/en/worktrees
Scenario 1: je ging naar binnen, deed niets en sloot af — de worktree werd verwijderd. Scenario 2: je hebt wat werk gedaan en niets gecommit — Claude vraagt bij het afsluiten “behouden of verwijderen?”. “Behouden” slaat de map en branch op voor later. “Verwijderen” verwijdert de map **samen met** niet-gecommitte wijzigingen en nieuwe commits. Dat is destructief — klik niet uit gewoonte op “verwijderen”. Scenario 3: je bent gestart met `-p` (headless) en de opdracht is voltooid en afgesloten. De worktree blijft bestaan. Ruim die handmatig op: ```bash git worktree remove .claude/worktrees/feature-x ``` Bovendien worden worktrees van subagents en `/bg`-sessies automatisch verwijderd door de achtergrondopruiming als ze ouder zijn dan `cleanupPeriodDays` dagen (een instelling, doorgaans standaard 30 dagen) **en** geen niet-opgeslagen werk bevatten. Worktrees van `--worktree` worden niet door automatische opruiming verwijderd — daarvoor ben jij verantwoordelijk. ## Alternatieven voor SVN, Perforce en Mercurial: de hook `WorktreeCreate`
Belangrijkste inzicht De worktree-modus gebruikt standaard `git worktree`. Voor SVN, Perforce, Mercurial en andere VCS’en kun je via de hooks `WorktreeCreate` en `WorktreeRemove` in de instellingen van Claude Code je eigen mechanisme koppelen. De hook ontvangt de naam via stdin, moet het pad naar de aangemaakte map weergeven en eindigen met exitcode 0. Als je je eigen hook gebruikt, wordt `.worktreeinclude` niet verwerkt — je moet de lokale bestanden zelf in de hook kopiëren.
Als de repository Subversion of Mercurial gebruikt, werkt de vlag `--worktree` niet rechtstreeks. Anthropic biedt een uitbreidingspunt via twee hooks: `WorktreeCreate` (maakt een geïsoleerde kopie aan) en `WorktreeRemove` (verwijdert die). Voorbeeld van een SVN-hook uit de officiële documentatie: ```json { "hooks": { "WorktreeCreate": [ { "hooks": [ { "type": "command", "command": "bash -c 'NAME=$(jq -r .name); DIR=\"$HOME/.claude/worktrees/$NAME\"; svn checkout https://svn.example.com/repo/trunk \"$DIR\" >&2 && echo \"$DIR\"'" } ] } ] } } ``` De hook leest de worktree-naam van stdin (`{ "name": "feature-auth" }`), voert `svn checkout` uit naar een vooraf bepaalde map en schrijft het pad naar stdout — Claude Code gebruikt dat als werkmap voor de nieuwe sessie. Een belangrijke kanttekening: als je je eigen hook gebruikt, wordt `.worktreeinclude` niet gebruikt. Als je `.env` of andere door Git genegeerde bestanden in de nieuwe map nodig hebt, kopieer ze dan in het hook-script zelf. ## Hierna: drie verwante mechanismen voor parallel werken
Belangrijkste inzicht Worktree zorgt voor bestandsisolatie. `/bg` zorgt voor isolatie van context en tokens. Subagent zorgt voor isolatie van taken en tools. `/goal` zorgt voor autonomie totdat aan een voorwaarde is voldaan. Elk mechanisme lost op zichzelf één probleem op. Samen maken ze het mogelijk om 3–5 parallelle taken draaiende te houden zonder cognitief vast te lopen. Vervolgens ligt het voor de hand om via de onderstaande links de verwante gidsen over de autonome modus, aangepaste subagents en dynamische workflows te verkennen.
Worktree zorgt voor bestandsisolatie. `/bg` zorgt voor contextisolatie. Subagents zorgen voor taakisolatie. Elk mechanisme lost op zichzelf één probleem op. Samen bieden ze een manier om aan drie tot vijf parallelle taken te werken zonder cognitief vast te lopen. Dit is de vaardighedencombinatie achter geavanceerd vibe-coden in 2026. Dit onderwerp sluit vanzelf aan op drie verwante onderwerpen: [hoe je een autonome agent instelt met `/goal` en Agent View](https://ailoot.ai/blog/nl/claude-code-goal-agent-view/), [hoe je je eigen subagents voor je taken bouwt](https://ailoot.ai/blog/nl/claude-code-subagents/) en [hoe je honderden agents start via Dynamic Workflows](https://ailoot.ai/blog/nl/claude-code-dynamic-workflows/).
### Bronnen - [Parallelle sessies uitvoeren met worktrees - Claude Code Docs](https://code.claude.com/docs/en/worktrees) - [Aangepaste subagents maken - Claude Code Docs](https://code.claude.com/docs/en/sub-agents) - [Claude Code Changelog (mei-juni 2026)](https://code.claude.com/docs/en/changelog) - [Agents parallel uitvoeren - Claude Code Docs](https://code.claude.com/docs/en/agents) - [Agent View - Claude Code Docs](https://code.claude.com/docs/en/agent-view) - [man-pagina voor git worktree](https://git-scm.com/docs/git-worktree)
[Ailoot openen](https://ailoot.ai/). ## Vragen en antwoorden ### Kopieert baseRef head ongecommitte wijzigingen naar een nieuwe worktree? Nee. Die start vanaf de huidige lokale HEAD-commit, inclusief lokale commits die op de remote ontbreken. Nog niet gecommitte gevolgde bewerkingen blijven in de oorspronkelijke werkkopie; draag vereiste WIP expliciet over en bekijk de nieuwe worktree. ### Waarom ontbreekt mijn .env in een nieuwe worktree? Een worktree is een verse checkout, dus door Git genegeerde lokale bestanden ontbreken. Claude Code gebruikt .worktreeinclude voor genegeerde bestanden die gekopieerd moeten worden; een eigen WorktreeCreate-hook moet dat zelf afhandelen. Neem alleen bestanden op die de taak vereist. ## Ailoot · Het bedrijf en zijn projectenportefeuille Ailoot bouwt op opgebouwde operationele ervaring, een groot klantenbestand, een stabiele dienst en doorlopende KPI-controle. Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden. Ailoot gebruikt die operationele ervaring voor API-toegang tot AI-functies in klantproducten, agents, applicaties en automatiseringen.