Git Worktree + AI Agents: A Match Made in Developer Heaven

The Problem: Context Switching Is Killing Your Flow

You are deep in a feature branch, the architecture is crystal clear, and then ping. A critical bug fix needs to go out now.

You git stash your changes, git checkout main, create a hotfix branch, fix the bug, push, and then try to remember where you left off. By the time you git checkout feature/amazing-thing and git stash pop, you have lost 20 minutes of cognitive momentum.

I ran into this daily until I tried Git worktrees combined with AI coding assistants.

What Are Git Worktrees?

Git worktrees let you check out multiple branches simultaneously in separate working directories, all sharing the same Git history.

Each worktree is a fully functional working directory with its own:

• Working tree (files)
• Index (staging area)
• Node modules / dependencies (if you install separately)

Creating a Worktree

# Add a new worktree for a feature branch
git worktree add ../my-project-feature feature/new-thing

# Add a worktree for a hotfix
git worktree add ../my-project-hotfix hotfix/critical-bug

# List all worktrees
git worktree list

# Remove a worktree when done
git worktree remove ../my-project-feature

Why This Matters for AI Agents

AI coding assistants work best when they have clear context and isolated environments.

AI agents produce unpredictable changes. A single session might install new dependencies, modify configuration files, generate thousands of lines of code, or refactor existing code in unexpected ways.

Running an AI agent in a worktree gives you zero risk to your main directory, easy review, parallel experiments, and fast discard if it fails.

My Workflow

// scripts/agent-worktree.ts
import { execSync } from "child_process"
import { existsSync, mkdirSync } from "fs"

interface WorktreeConfig {
  branch: string
  worktreePath: string
  baseBranch?: string
}

function createAgentWorktree(config: WorktreeConfig) {
  const { branch, worktreePath, baseBranch = "main" } = config

  // Ensure latest base branch
  execSync(`git checkout ${baseBranch} && git pull`, { stdio: "inherit" })

  // Create branch
  execSync(`git branch ${branch} ${baseBranch}`, { stdio: "ignore" })

  // Create worktree
  if (!existsSync(worktreePath)) {
    mkdirSync(worktreePath, { recursive: true })
  }
  execSync(`git worktree add ${worktreePath} ${branch}`, {
    stdio: "inherit",
  })

  // Install dependencies in the worktree
  execSync("npm install", { cwd: worktreePath, stdio: "inherit" })

  console.log(`Agent worktree ready at: ${worktreePath}`)
  console.log(`Open your AI agent in: ${worktreePath}`)
}

Real Results

Since I started using this workflow:

• 3x more experiments. I can try AI solutions without commitment.
• Zero accidental merges. Worktrees make it obvious when you are in the wrong branch.
• Parallel AI sessions. Claude refactors one feature, Cursor builds another.
• Cleaner reviews. Each worktree produces a focused, reviewable diff.

Give It a Try

Next time you fire up an AI coding assistant, create a worktree first. It takes 10 seconds and saves hours of cleanup.

# One-liner to create and open a worktree for AI work
git worktree add ../experiment-ai feature/ai-experiment && \
  code ../experiment-ai

Your future self, the one not dealing with merge conflicts, will thank you.