The Git Feature I Ignored for Years Is Now How I Think in Parallel

I knew git worktrees existed. I'd seen them mentioned in git documentation for years.

I never used them because I couldn't see the problem they solved. Branch switching was fast. Stashing was good enough. The workflow I had worked.

Then I started running multiple agents in parallel, and everything broke.

What Actually Goes Wrong

The failure mode isn't dramatic. It's insidious.

You've got two agents working on related parts of a codebase. One is writing tests. One is implementing the feature those tests are meant to cover. You've described the tasks carefully. Both agents are capable. Both start confidently.

Twenty minutes in, they've corrupted each other's working state. One agent staged files the other didn't know were staged. One modified a config the other was also reading. The merge isn't a git conflict — it's a logic conflict, buried in changes that individually look fine.

The problem isn't the agents. The problem is that shared physical state and parallel mental work don't mix.

Physical Separation Enables Mental Parallelism

The using-git-worktrees skill from obra/superpowers treats this as a first-class architectural concern, not an operational detail.

The premise is simple: git worktrees create isolated workspaces that share a single repository. Each worktree is its own directory, its own branch, its own staging area. Two agents in two worktrees cannot accidentally interfere with each other's files because they're literally working in different places on disk.

That sounds technical. The insight is psychological.

When an agent has its own directory, it has its own context. It knows where it is. It knows what it owns. It makes decisions without having to reason about what some other process might be doing simultaneously. That's not a small thing — uncertainty about shared state is one of the primary causes of agent thrashing, the loop of undoing and redoing that burns time and tokens and produces nothing.

Isolation isn't the goal. Clarity is. Isolation is just the mechanism that produces clarity at scale.

The Safety Ritual That Makes It Reliable

What I found valuable in the skill isn't the worktree creation commands — those are a few git calls. It's the safety verification protocol that runs before any worktree gets created.

The skill checks whether the worktree directory is gitignored before proceeding. If it isn't, it adds the appropriate line to .gitignore and commits that change first. This sounds like a footnote. It's actually the difference between a workflow that works and one that periodically produces a mystery commit containing an entire parallel workspace.

There's a principle at work here that Jesse, the author of superpowers, calls "fix broken things immediately." When the setup reveals a gap — gitignore missing, directory structure wrong — you close the gap before continuing, not after. The cost of doing it later is always higher.

This is the kind of operational rigor that doesn't feel important until the one time you skip it.

Running Parallel Agents Without Losing Your Mind

The superpowers toolkit includes a dispatching-parallel-agents skill, and using-git-worktrees is its prerequisite infrastructure.

Before you can think in parallel — before you can have three independent streams of work running simultaneously without them corrupting each other — you need three physically separate workspaces. The worktree skill is what creates that infrastructure cleanly and verifiably.

The mental model that clicked for me: your brain doesn't multitask by running one process with a shared memory space. It context-switches, or it uses different neural circuits that don't interfere. Worktrees are how you give each agent its own neural circuit.

The work I used to do sequentially — implement a feature, then write tests, then update docs — I now do in parallel, with different agents, in different worktrees, and fold the results back in at the end. The wall-clock time for a significant feature dropped.

I now think of git worktrees as: the physical fact that makes parallel thought possible rather than merely attempted.

---

Part of the Superpowers series — 14 specialist skills from obra/superpowers.