Parallel sessions
Running ten sessions at once
Three worktrees and two terminals going — a refactor here, a bug fix there, a feature in another. Two of them are about to touch the same file.
The scenario
Dev — a senior engineer at a three-person startup, building a B2B analytics dashboard (Next.js + Postgres).
The goal
Ship a big release — new charts, an auth refactor, and billing — inside a single one-week sprint by running several Claude Code sessions in parallel across git worktrees.
Dev has learned that the way to move fast with AI is to parallelize: one worktree refactoring auth, another adding Stripe billing, a third building the new chart components. Three agents, three terminals, all going at once. The problem is that the auth refactor and the billing work both need to touch the shared session helper — and neither session has any idea the other one is in there.
Without afterclick
- The billing session rewrites `src/lib/session.ts`; ten minutes later the auth session overwrites the same file with its own version. One set of changes is silently gone.
- Nobody notices until the merge — or worse, until a logout bug shows up in production and the afternoon’s work has to be reconstructed from memory.
- After it happens twice, Dev stops trusting parallel sessions and goes back to working one-at-a-time — losing the whole speed advantage.
- There’s no record of which session changed what, so untangling the conflict is pure detective work.
With afterclick
- Sees across every session. afterclick watches all the worktrees at once, so it knows the billing session is editing a file the auth session just changed — something no single session can see.
- Warns before the clobber. The moment the second session is about to overwrite the first’s work, it’s flagged — before the damage, not at merge time.
- Holds the merge. It can pause the merge until the conflict is reconciled, so good work never gets silently overwritten.
- Keeps the speed. Dev keeps parallelizing across as many sessions as he wants, because the safety net makes it safe to.
What afterclick did here
- 1Noticed the session labelled billing-fix had opened `src/lib/session.ts`.
- 2Cross-referenced live activity and saw the auth-refactor session had edited that same file four minutes earlier.
- 3Held the merge before billing-fix could overwrite it, and surfaced both diffs side by side.
- 4Let Dev reconcile the two changes by hand, so the auth work and the billing work both survived.
- 5Logged which session touched which file, so there was nothing to reconstruct later.
What you’d have seen
Session billing-fix → src/lib/session.ts
About to overwrite a file edited 4 min ago in session auth-refactor. Merge held until you reconcile.
The obvious objection
Why not just use GitHub?
GitHub sees code after it’s committed and pushed — at merge time, reviewed by a human looking at a diff. The clobber here happens minutes earlier, in two uncommitted working trees, while three agents type in parallel. Git will happily let the billing branch and the auth branch each rewrite `session.ts`; you find out at the merge conflict if you’re lucky, or in production if you’re not. Branch protection and required reviews assume a reviewer exists and that the danger lives in the pull request — but the danger here is the live, concurrent, pre-commit editing that no PR can see. afterclick watches the working trees themselves, in real time, and speaks before the overwrite, not after the merge.
For the senior engineer
You know git cold — that’s not the point. The point is that at four agents editing at machine speed, the coordination that used to live in your head doesn’t scale: you can’t track six concurrent working trees by feel. afterclick isn’t training wheels for branching; it’s air-traffic control for parallel agents, holding the picture no single session — and no human — can. The one clobber it prevents pays for itself in a recovered afternoon.
What it replaced for you
- The senior engineer who’d otherwise have to mentally track who’s editing what.
- The lost afternoon reconstructing silently-overwritten work.
- The “don’t run sessions in parallel” rule that would have killed the speed.
- Merge-time archaeology trying to figure out where a change went.
The outcome
Dev shipped the full release inside the sprint, running four sessions in parallel the whole time, and didn’t lose a single afternoon to a clobber. Parallelizing went from “risky” to “the default way we work.”
Sound like you?
One paste, AI included, free to start.