# Git worktree i Claude Code: parallella sessioner
> Så använder du --worktree, .worktreeinclude, worktree.baseRef och isolering av subagenter. Skillnader jämfört med grenar, rensning av worktrees och vanliga misstag.
Source: https://ailoot.ai/blog/sv/claude-code-git-worktree/
Canonical: https://ailoot.ai/blog/sv/claude-code-git-worktree/
Language: sv
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-045
Revision: sha256-f3b9c2c33e455649da9189c623066136bd7bb89f78d5834484b02b2cbeda57de
[Praktisk information om att arbeta med Ailoot finns i dokumentationen](https://ailoot.ai/docs/).
## Vad är en git worktree i Claude Code
Det viktigaste
En Git worktree är en separat arbetskatalog för en annan gren i samma repository. Kommandot `claude --worktree ` skapar automatiskt en worktree i `.claude/worktrees//` och startar Claude Code där. Två terminaler → två sessioner → olika filer på disken, utan störningar. Funktionen finns direkt i Claude Code v2.0+, och kan konfigureras med `.worktreeinclude` för hemligheter och `worktree.baseRef` för att välja basgren.
Att starta flera agenter parallellt i samma mapp är den grundläggande smärtpunkten med vibe-kodning i 2026 års tempo. AI-agenter skriver kod snabbare än en person hinner hålla reda på vem som arbetar med vad. Utan filisolering slutar det med att en session skriver över den andras arbete när två Claude Code-sessioner körs parallellt i samma katalog.
Git worktree löser detta på filsystemnivå. Du har en huvudkatalog där du arbetar. Kommandot `claude --worktree feature-auth` skapar mappen `.claude/worktrees/feature-auth/` på en separat gren och startar Claude Code där. Filerna är isolerade. Ändringar i den ena sessionen syns inte i den andra förrän du uttryckligen sammanfogar dem.
Anthropics officiella dokumentation beskriver det så här:
När varje Claude Code-session körs i sin egen worktree påverkar redigeringar i en session aldrig filer i en annan. Du kan bygga en funktion i en terminal och åtgärda en bugg i en annan.
— Anthropic Docs, https://code.claude.com/docs/en/worktrees
Ett tips för självkontroll: om du någon gång har fått en commit där hälften av filerna var någon annans arbete behöver du en worktree.
## Hur git worktree skiljer sig från en vanlig gren
Det viktigaste
En vanlig `git checkout` byter arbetskopian i samma mapp—de gamla filerna försvinner från disken tills du går tillbaka till grenen. `git worktree add` skapar en **andra mapp** för en annan gren bredvid den första. Båda grenarna finns på disken samtidigt; du växlar mellan dem med ett enkelt `cd`. Under huven finns ett enda `.git`-repository med delad historik och en delad fjärrserver. Bara flera arbetskopior.
Det vanliga Git-flödet: du står på grenen `main` och kör `git checkout feature-x`—Git skriver över arbetskopians filer. En körande `npm run dev` slutar fungera eftersom `package.json` ändrades under den. Du stuvar undan dina ocommittade ändringar med stash och väntar på att IDE:n ska indexera om. Du byter tillbaka och allt skrivs över igen, så du måste göra stash och pop på nytt.
Git worktree ger dig ett annat alternativ: i stället för att växla **en** mapp mellan grenar skapar du en **andra** mapp för en annan gren. Kommandot `git worktree add ../project-feature-x feature-x` skapar katalogen `../project-feature-x/` med filerna från grenen `feature-x`. Din `main` ligger kvar i den ursprungliga mappen och utvecklingsservern fortsätter att köra.
| Parameter | Gren med `git checkout` | `git worktree add` |
|----|----|----|
| Arbetskopians filer | Skrivs över | Visas i en ny mapp |
| Parallellt arbete på två grenar | Nej | Ja |
| Ocommittade ändringar | Kräver `git stash` | Inget att göra |
| Växlingshastighet | Beror på skillnadens storlek | Bara `cd` |
| Diskutrymme | 1× | N× (en kopia av filerna per gren) |
Tidigare behövde worktree-läget i Claude Code konfigureras manuellt: `git worktree add`, sedan `cd`, sedan `claude`—och upprepa i varje terminal. Flaggan `--worktree` (även `-w`) gör allt detta med ett kommando.
## Starta den första parallella sessionen: flaggan `--worktree`
Det viktigaste
Kommandot `claude --worktree feature-auth` skapar en worktree i `.claude/worktrees/feature-auth/`, skapar grenen `worktree-feature-auth` från `origin/HEAD` och startar Claude Code där. Du behöver inte köra `git worktree add` eller `cd` manuellt. Upprepa kommandot i den intilliggande terminalen med ett annat namn för att få två oberoende sessioner. Om du utelämnar namnet (`claude --worktree`) genererar Claude ett slumpmässigt namn, som `bright-running-fox`.
Minimalt exempel. Öppna den första terminalen i projektets rot:
```bash
claude --worktree feature-auth
```
Claude Code gör tre saker:
1. Skapar `.claude/worktrees/feature-auth/` med en ögonblicksbild av `origin/HEAD` (vanligtvis din standardgren).
2. Skapar en ny gren, `worktree-feature-auth`.
3. Startar sessionen i den här mappen.
Öppna en andra terminal i samma repositorys rotmapp:
```bash
claude --worktree bugfix-123
```
Klart. Två Claude Code-sessioner, olika filer på disken, olika Git-grenar. Om du skriver autentisering i den första och åtgärdar ett misslyckat test i den andra kan de fysiskt inte komma i vägen för varandra.
Om du inte vill skriva in ett namn hittar Claude på ett:
```bash
claude --worktree
# → skapar något i stil med .claude/worktrees/bright-running-fox/
```
Ett tips för Git-nybörjare: lägg till `.claude/worktrees/` i `.gitignore`. Annars ser du innehållet i alla worktrees som ospårade filer när du kör `git status` i huvudmappen:
```
# .gitignore
.claude/worktrees/
```
Fallgrop att undvika: innan du startar `--worktree` för första gången i en ny katalog ska du öppna den med en vanlig `claude` (utan flaggan) och godkänna dialogrutan för arbetsytans förtroende. Om du inte gör det misslyckas flaggan med felet ”trust not accepted”—även om du kombinerar den med `-p` för headless-läge.
## Var worktrees finns och hur du hittar dem
Det viktigaste
Som standard ligger alla worktrees i `.claude/worktrees//` intill repositoryts rot. Kör `git worktree list` för att visa listan. Använd `cd .claude/worktrees/feature-auth` för att öppna en worktree manuellt. Om du vill byta inne i en Claude-session ber du den att ”byta till en annan worktree”; då använder den det inbyggda verktyget EnterWorktree. Den gamla worktreen lämnas orörd på disken.
Standardplatsen är fast: `.claude/worktrees//` vid repositoryts rot. Om projektet ligger i `~/dev/my-app/` finns worktreen `feature-auth` i `~/dev/my-app/.claude/worktrees/feature-auth/`.
För avvikande katalogstrukturer (till exempel om du vill ha worktreen utanför repositoryt) finns hooken `WorktreeCreate`—mer om den nedan i avsnittet om SVN och Mercurial.
I en Claude-session kan du byta till en annan befintlig worktree. Säg bara i chatten: ”byt till `.claude/worktrees/bugfix-123`”, så anropar Claude verktyget `EnterWorktree`. Den aktuella mappen förblir orörd—du kan återvända på samma sätt.
Standardkommandot i Git visar en lista över alla worktrees, inklusive huvudarbetskopian och de som skapats manuellt:
```bash
git worktree list
```
Utdata ser ut så här:
```
/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]
```
## Kopiera `.env` och hemligheter: filen `.worktreeinclude`
Det viktigaste
En worktree är en ny utcheckning. Filer från `.gitignore` (`.env`, `.env.local`, lokala konfigurationer) saknas i den nya mappen. Utan dem fungerar inte `npm run dev` eller `prisma db push`. Filen `.worktreeinclude` i projektroten använder syntax från `.gitignore` och talar om för Claude Code vilka filer som automatiskt ska kopieras till varje ny worktree. Den används för `--worktree`, subagent-worktrees och sessioner i skrivbordsappen.
När `--worktree` skapar en ny mapp får den bara det som är committat till Git. `.env` med API-nycklar och `.env.local` med lokal konfiguration finns i `.gitignore`, så de finns inte i worktreen. Därför misslyckas det allra första `npm run dev` med ”MISSING DATABASE_URL”.
En hemmasnickrad lösning är att kopiera `.env` manuellt efter varje `--worktree`. Det fungerar en gång och glöms sedan bort. Anthropics lösning är en fil som heter `.worktreeinclude` i projektroten, med en lista över de Git-ignorerade filer som automatiskt ska kopieras till varje ny worktree.
Skapa filen `.worktreeinclude` i repositoryts rot:
```
.env
.env.local
config/secrets.json
```
Syntaxen är densamma som i `.gitignore`. Du kan använda glob-mönster:
```
.env*
*.local
config/*.json
.vscode/settings.json
```
Anthropic ger en tydlig regel för att förhindra misstag:
Filen använder syntaxen från gitignore. Endast filer som matchar mönstret och samtidigt ignoreras av Git kopieras. Git-spårade filer dupliceras aldrig.
— Anthropic Docs, https://code.claude.com/docs/en/worktrees
Med andra ord kan du inte råka kopiera `package.json` via `.worktreeinclude`—den filen finns inte i `.gitignore`. Det är säkert att lägga in vilka mönster som helst där.
Samma `.worktreeinclude` fungerar i tre lägen: manuellt med `--worktree`, automatiska worktrees för subagenter (se nedan) och sessioner från Claude-skrivbordsappen.
## Worktree från en pull request för kodgranskning
Det viktigaste
Kommandot `claude --worktree "#1234"` hämtar pull request \#1234 från origin och skapar en worktree i `.claude/worktrees/pr-1234/` med PR-grenen. Du kan ange hela URL:en—`claude --worktree https://github.com/OWNER/REPO/pull/1234`. Praktiskt för kodgranskning: öppna PR:en i en egen mapp, så kan Claude köra tester, läsa loggar och skriva en kommentar medan huvudrepositoryt lämnas orört.
Ett vanligt scenario för kodgranskning: en kollega har skickat en PR; du behöver granska koden, köra tester och lämna en kommentar. Med en vanlig `git checkout pull/1234/head` växlar du arbetskopian igen och avbryter din aktiva session.
Med flaggan `--worktree` räcker ett kommando:
```bash
claude --worktree "#1234"
```
Det här händer: Claude Code kör `git fetch origin pull/1234/head`, skapar en worktree i `.claude/worktrees/pr-1234/` och checkar ut PR-grenen. Sessionen startar. Du kan genast be den att ”läsa diffen, köra testerna och hitta logiska fel”—medan Claude arbetar fortsätter din huvudsakliga session på `main` att köras.
Alternativ syntax med hela pull request-URL:en:
```bash
claude --worktree https://github.com/OWNER/REPO/pull/1234
```
I ett verkligt projekt kan du kombinera `claude --worktree "#N"` med en egen kodgranskar-subagent för att få en automatisk granskning på en minut eller två. Starta den i bakgrunden, fortsätt arbeta i huvudfönstret och gå tillbaka till resultatet via `claude agents`.
## Basgren: `worktree.baseRef` för `fresh` eller `head`
Det viktigaste
Som standard skapas en gren i en worktree från `origin/HEAD`—den senaste synkroniserade commiten från fjärrservern. Det ger en säker, ”ren” start. Om du vill att worktreen ska innehålla lokala opushade commits anger du `worktree.baseRef: "head"` i inställningarna. HEAD identifierar en commit; oincheckade spårade ändringar stannar i originalarbetskopian och kräver separat uttrycklig överföring. Det är användbart när en subagent behöver arbeta ovanpå din aktuella funktion utan att byta till main. Endast `fresh` eller `head` godtas; godtyckliga refs stöds inte.
Standardinställningen innebär att varje ny worktree startar från `origin/HEAD`. Fördelen är en ren start som med säkerhet motsvarar det CI kommer att se. Nackdelen är att ocommittade ändringar och lokala commits utöver fjärrserverns version av den aktuella grenen inte följer med till den nya worktreen.
För att starta worktree från aktuell lokal HEAD-commit lägger du till detta i `.claude/settings.json` (eller globala inställningar):
```json
{
"worktree": {
"baseRef": "head"
}
}
```
Nu utgår `claude --worktree experimental-feature` från aktuell lokal `HEAD`. Det är användbart när funktionen redan har lokala commits som inte pushats. Det inkluderar inte fortfarande oincheckade spårade ändringar. Om subagenten behöver dem bevarar och överför du nödvändiga ändringar uttryckligen och granskar sedan målets diff; förväxla inte överföringen med `.worktreeinclude` som hanterar ignorerade lokala filer.
Inställningen godtar exakt två värden: `"fresh"` (= `origin/HEAD`) och `"head"` (= lokal HEAD). Inga godtyckliga refs som `"feature-branch"` eller en commit-hash—det är en avsiktlig begränsning för att förhindra en kombinatorisk explosion av alternativ.
## Isolera subagenter automatiskt: `isolation: worktree`
Det viktigaste
En subagent i Claude Code är en specialiserad agent som utför en uppgift (kodgranskning, refaktorering, research). Om du startar flera subagenter parallellt från en session arbetar de som standard i samma mapp och kan skriva över varandras filer. Lägg till `isolation: worktree` i subagentens frontmatter för att ge var och en en tillfällig worktree, som tas bort när den är klar om den inte har committat något.
När du säger till Claude ”starta tre subagenter: en läser databasen, den andra tittar på API:et och den tredje kontrollerar testerna” arbetar alla tre som standard i din arbetskopia. Om bara två av dem skriver i samma fil samtidigt uppstår en konflikt. Lösningen är att automatiskt ge var och en en egen worktree.
Metod 1: be muntligen. Skriv till Claude i konversationen:
```
Använd worktrees för dina agenter.
```
Claude använder isolering för alla efterföljande subagenter i den här sessionen.
Metod 2: ange det uttryckligen i själva subagenten. Lägg till ett fält i dess frontmatter-fil (till exempel `.claude/agents/code-reviewer.md`):
```yaml
---
name: code-reviewer
description: Reads the diff and writes code review comments
isolation: worktree
---
Du är en noggrann granskare. Läs diffen och leta efter logiska fel...
```
Nu får varje start av denna subagent en tillfällig worktree i `.claude/worktrees/`. Om subagenten inte skrev något tas mappen bort automatiskt när den är klar. Om det finns ocommittade ändringar frågar Claude om de ska behållas eller tas bort.
Basgrenen för subagent-worktrees är densamma som för `--worktree`: som standard `origin/HEAD`; med `worktree.baseRef: head`, lokal `HEAD`.
## Beslutsmatris: worktree, `/bg`, subagent eller Agent View
Det viktigaste
Fyra Claude Code-mekanismer som ofta förväxlas. Worktree ger **filisolering** (disk). `/bg` ger en **bakgrundssession** (kontext och token). Subagent är en **specialiserad engångsagent** (prompt och verktyg). Agent View är en **översikt över alla sessioner** (UI). De kan kombineras: `/bg` skapar automatiskt en worktree, en subagent med `isolation: worktree` startar i en tillfällig worktree och Agent View visar alla tre som rader i en lista.
| Verktyg | Vad det isolerar | När du ska använda det |
|----|----|----|
| `claude --worktree ` | Filer (separat mapp + gren) | Du vill manuellt hålla N sessioner igång parallellt i olika terminaler |
| `/bg` (eller `Ctrl+B`) | Kontext och tid | En lång uppgift när du inte vill blockera det aktuella fönstret. En worktree skapas under huven |
| Subagent med `isolation: worktree` | Filer inom en session | En prompt tilldelar arbete till N agenter och du behöver skydd mot att de skriver över varandra |
| `claude agents` (Agent View) | Ingenting, det är ett UI | Du vill se alla körande / pausade / slutförda sessioner i en enda översikt |
| `/goal` | Autonomihantering | Du vill att Claude ska arbeta tills ett villkor är uppfyllt utan att du ger en prompt mellan turerna |
Vanliga kombinationer:
- **”2 funktioner parallellt, manuellt”** — två terminaler, var och en kör `claude --worktree`. Det enklaste fallet.
- **”Starta en refaktorering över natten; jag stänger appen”** — `/bg` + `/goal` med ett slutförandevillkor. Sessionen kör oberoende av ditt fönster.
- **”En prompt, tre parallella undersökningar”** — tre subagenter med `isolation: worktree`. Var och en i sin egen sandlåda.
- **”Vad körs just nu?”** — `claude agents`. En översikt över alla sessioner med filtren ”running”, ”blocked” och ”done”.
## 5 fallgropar när du arbetar med worktrees
Det viktigaste
De vanligaste problemen: du glömmer `.worktreeinclude` och miljön fungerar inte; du förväxlar en worktree med en vanlig gren och förlorar ocommittade ändringar; du har 5+ parallella sessioner och glömmer vad som finns var; du missar att konfigurera `cleanupPeriodDays` så att övergivna mappar samlas på hög; och du glömmer förtroendedialogen i en ny katalog, vilket får `--worktree` att misslyckas med ett fel.
**1. Du startade en worktree, `.env` saknas och ingenting fungerar.** Det vanligaste problemet. En worktree är en ny utcheckning utan filer som ignoreras av Git. Lösningen är att lägga till en `.worktreeinclude`-fil med `.env*` och nödvändiga lokala konfigurationer så snart du ställer in worktree-läget. Kontrollera att filen ligger i repositoryts rot, inte i `.claude/`.
**2. Du vill byta till huvudgrenen, kör `cd` till roten och förlorar dina ocommittade ändringar i worktreen.** Rotmappen och worktreen är två **olika** arbetskopior. Du gick tillbaka med `cd`; ändringarna i worktreen finns kvar—de har inte försvunnit. Men om du blandade ihop mapparna och körde `git stash` i huvudmappen i tron att du befann dig i worktreen, skapas stashen på huvudgrenen, inte på den gren du förväntade dig.
**3. Du startade 5 parallella sessioner och minns inte vad var och en gör.** Anthropics dokumentation varnar uttryckligen för att de flesta utvecklare inte klarar av mer än 2–3 sessioner mentalt. Ett tecken på överbelastning är att du öppnar Agent View och inte genast kan säga vad varje agent gör. Begränsa dig till två samtidiga sessioner. Om uppgiften kräver fler bör arbetet orkestreras med `/goal` + subagenter, inte manuellt.
**4. Worktrees från `-p` (headless) rensas inte automatiskt.** Kommandot `claude --worktree feature-x -p "do thing"` visar ingen interaktiv avslutningsfråga, så Claude får aldrig tillfälle att fråga ”ta bort worktreen?”. Sådana worktrees samlas på hög. Rensa dem manuellt med `git worktree remove .claude/worktrees/feature-x`. Eller använd ett cron-skript som tar bort allt som är äldre än 7 dagar.
**5. Förtroendedialog i en ny mapp.** Om du öppnar repositoryt för första gången och genast kör `claude --worktree` misslyckas kommandot. Kör `claude` utan flaggor, godkänn arbetsytans förtroende och avsluta—därefter fungerar `--worktree`. Detta är avsiktligt, så att Claude inte får åtkomst till någon annans projekt utan användarens samtycke.
## Rensning: vad tas bort automatiskt
Det viktigaste
En worktree från `--worktree` utan ändringar (inga commits, ospårade filer eller ocommittade ändringar) tas bort automatiskt när du avslutar. Om det finns ändringar frågar Claude. Worktrees från subagenter och `/bg` tas automatiskt bort av timeouten `cleanupPeriodDays` i inställningarna om de är rena. Worktrees från `-p` rensas inte alls—ta bort dem manuellt med `git worktree remove`.
Rensningslogiken beror på vad du har gjort i worktreen och hur du startade sessionen. Anthropics dokumentation listar tre scenarier:
Om worktreen saknar ocommittade ändringar, ospårade filer och nya commits tas worktreen och dess gren bort automatiskt när du avslutar sessionen. Om sessionen har ett namn frågar Claude i stället, så att du kan behålla worktreen för senare.
— Anthropic Docs, https://code.claude.com/docs/en/worktrees
Scenario 1: du öppnade worktreen, gjorde ingenting och avslutade—worktreen togs bort.
Scenario 2: du arbetade lite utan att committa—Claude frågar ”behålla eller ta bort?” när du avslutar. ”Behåll” sparar mappen och grenen till senare. ”Ta bort” raderar katalogen **tillsammans med** ocommittade ändringar och nya commits. Det är destruktivt—klicka inte på ”ta bort” av gammal vana.
Scenario 3: du startade med `-p` (headless), och kommandot slutfördes och avslutades. Worktreen finns kvar. Rensa den manuellt:
```bash
git worktree remove .claude/worktrees/feature-x
```
Dessutom tas worktrees från subagenter och `/bg`-sessioner automatiskt bort av bakgrundsrensningen om de är äldre än `cleanupPeriodDays` dagar (en inställning, vanligtvis 30 dagar som standard) **och** inte innehåller osparat arbete. Worktrees från `--worktree` påverkas inte av den automatiska rensningen—du ansvarar själv för dem.
## Alternativ för SVN, Perforce och Mercurial: hooken `WorktreeCreate`
Det viktigaste
Worktree-läget använder `git worktree` som standard. För SVN, Perforce, Mercurial och andra versionshanteringssystem kan du koppla in din egen mekanism via hookarna `WorktreeCreate` och `WorktreeRemove` i Claude Code-inställningarna. Hooken tar emot namnet på stdin, måste skriva ut sökvägen till den skapade katalogen och avslutas med kod 0. När du använder en egen hook behandlas inte `.worktreeinclude`—du måste själv kopiera lokala filer i hooken.
Om repositoryt använder Subversion eller Mercurial fungerar flaggan `--worktree` inte direkt. Anthropic tillhandahåller en utökningspunkt via två hookar: `WorktreeCreate` (skapar en isolerad kopia) och `WorktreeRemove` (tar bort den).
Exempel på SVN-hook från den officiella dokumentationen:
```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\"'"
}
]
}
]
}
}
```
Hooken läser worktree-namnet från stdin (`{ "name": "feature-auth" }`), kör `svn checkout` till en förberäknad katalog och skriver sökvägen till stdout—Claude Code använder den som arbetskatalog för den nya sessionen.
En viktig reservation: när du använder en egen hook används inte `.worktreeinclude`. Om du behöver `.env` eller andra Git-ignorerade filer i den nya mappen måste du kopiera dem i själva hook-skriptet.
## Nästa steg: tre närliggande mekanismer för parallellism
Det viktigaste
Worktree ger filisolering. `/bg` ger isolering av kontext och token. Subagent ger isolering av uppgift och verktyg. `/goal` ger autonomi tills ett villkor har uppfyllts. Var och en löser ett problem på egen hand. Tillsammans går det att hålla igång 3–5 parallella uppgifter utan kognitiv kollaps. Läs vidare om närliggande guider om autonomt läge, egna subagenter och dynamiska arbetsflöden via länkarna nedan.
Worktree ger filisolering. `/bg` ger kontextisolering. Subagenter ger uppgiftsisolering. Varje mekanism löser ett problem på egen hand. Tillsammans gör de det möjligt att arbeta med tre till fem parallella uppgifter utan kognitiv kollaps. Det här är verktygslådan bakom avancerad vibe-kodning i 2026.
Ämnet fortsätter naturligt med tre närliggande områden: [så ställer du in en autonom agent med `/goal` och Agent View](https://ailoot.ai/blog/sv/claude-code-goal-agent-view/), [så bygger du egna subagenter för dina uppgifter](https://ailoot.ai/blog/sv/claude-code-subagents/) och [så startar du hundratals agenter genom Dynamic Workflows](https://ailoot.ai/blog/sv/claude-code-dynamic-workflows/).
### Källor
- [Run parallel sessions with worktrees - Claude Code Docs](https://code.claude.com/docs/en/worktrees)
- [Create custom subagents - Claude Code Docs](https://code.claude.com/docs/en/sub-agents)
- [Claude Code Changelog (May-June 2026)](https://code.claude.com/docs/en/changelog)
- [Run agents in parallel - Claude Code Docs](https://code.claude.com/docs/en/agents)
- [Agent View - Claude Code Docs](https://code.claude.com/docs/en/agent-view)
- [git worktree man page](https://git-scm.com/docs/git-worktree)
[Öppna Ailoot](https://ailoot.ai/).
## Frågor om den här guiden: Git worktree i Claude Code: parallella sessioner
### Kopierar baseRef head oincheckade ändringar till ny worktree?
Nej. Den börjar från aktuell lokal HEAD-commit, inklusive lokala commits som saknas på fjärrservern. Oincheckade spårade ändringar stannar i originalarbetskopian; överför nödvändigt WIP uttryckligen och granska ny worktree.
### Varför saknas .env i ny worktree?
En worktree är ny utcheckning så Git-ignorerade lokala filer saknas. Claude Codes `.worktreeinclude` listar ignorerade filer att kopiera; en egen WorktreeCreate-hook måste sköta kopieringen själv. Inkludera bara filer uppgiften behöver.
## Ailoot · Företaget och dess projektportfölj
Ailoot bygger på etablerad driftserfarenhet, en stor kundbas, stabil service och löpande KPI-kontroll.
Företaget och dess projektportfölj: miljontals kunder; månatlig försäljning för miljarder.
Ailoot använder denna driftserfarenhet för API-åtkomst till AI-funktioner i kundernas produkter, agenter, applikationer och automatiseringar.