← Writing

You stopped babysitting. Now try worktrees — parallel agents on isolated branches. The safety net is the same one you're already standing on.

How many features are you working on sequentially that could run in parallel?

You stopped babysitting. Hooks run your tests. Deny lists guard the dangerous stuff. Auto memory holds context across sessions. You trust one agent to work unsupervised.

But you’re still feeding it one task at a time. Waiting for it to finish. Starting the next.

You’ve seen the tweets. The tmux screenshots. Three terminals. Three agents. Three features at once. It looks impressive. It also looks reckless.

It’s not. Here’s what those screenshots don’t show you.

The Safety Net

The entire parallel agent workflow rests on one flag:

claude --worktree feature-auth

That’s it. A full copy of your repo on its own branch, completely isolated.

What actually happens:

  • No changes? The worktree deletes itself on exit. Zero footprint.
  • Bad changes? Choose “remove” at the exit prompt. Gone. Zero damage to your main branch.
  • Your deny rules? Apply everywhere. The same 11 rules you already trust.
  • Your hooks? Still run. Permissions still hold.

The worktree isn’t a new environment with new rules. It’s the same environment on a separate branch.

Running Three Features in Parallel

The practical setup:

# Terminal 1
claude --worktree feature-auth

# Terminal 2
claude --worktree fix-pagination

# Terminal 3
claude --worktree update-api-types

Three agents. Three branches. Each one working from the same codebase, completely isolated from the others. No merge conflicts until you choose to merge. No contamination between tasks.

When each one finishes, you review the diff, approve or discard, and merge the ones that are good.

The Worst Case

The worst case isn’t broken code. It’s deleting a worktree you didn’t need.

That’s the actual downside: wasted compute time on a task that went sideways. Your main branch is untouched. Your working tree is untouched. You just delete the worktree and start over.

Compare that to the worst case of sequential single-agent work: you don’t get three features, you get one.

The Trust Ladder

This is the natural progression:

  1. You let the agent run without approving every command
  2. You let it run without watching every step
  3. You let it run on its own branch while you do something else
  4. You let three branches run simultaneously

Each step uses the same safety primitives — deny lists, hooks, permissions — just applied at larger scope. You already trust one agent to work alone. Now let three work in parallel.

The safety net is the same one you’re already standing on.

AI Minus the Friction #5. Read the full series →