I ran four AI sessions on one repo overnight

Last week I redesigned my portfolio overnight. Not alone: two interactive Claude sessions were open in separate windows, and each of them kept spawning background agents for the parallelizable work. At the busiest point, four different processes were writing to the same git repository at once. I was the fifth.

By morning the site had a new hero narrative, a first-load animation where scattered particles assemble into a living organism, restructured case captions, an animated mobile menu, and roughly 210 em dashes surgically removed from every page. It also had three new automated checks that did not exist the evening before. This post is about the eight hours in between.

What I actually set up

The split was simple. One session owned the big moves: hero copy, information architecture, engine work. The second owned design details: palettes, spacing, case page polish. Both had permission to commit locally. Neither had permission to push; a git hook forces every push through me. That one rule did more work than everything else combined.

For bulk work, sessions dispatched agents. The em dash purge is a good example: my case studies and UI strings had accumulated about 210 of them, and an em dash every third sentence is the loudest tell of machine-written text. Three agents took the corpus in parallel: one got four case studies, one got three case studies plus the blog, one got 24 source files and the page titles. Each had the same editorial contract: rewrite every dash site into natural English, split clauses into sentences, never touch quoted testimonials, never touch en dashes in year ranges. Then commit only your own files, by explicit path.

What broke

Everything interesting happened at the seams between writers.

My working tree change got committed by the neighbor session. I had switched the accent color and left it uncommitted; the design session was committing its own batch, swept the file in, and my change rode along in a stranger's commit. Nothing was lost, but the history now lies a little about who did what.

The reverse happened too. While one of my agents was de-dashing a case study, the other session rewrote the same case study and introduced 29 fresh em dashes between my agent's read and its commit. The agent caught it only because its final check ran against the committed blob, not against what it remembered writing. Working trees lie when four hands are in them; git show HEAD:file does not.

The subtlest failure was not a conflict but a contamination. The design session was experimenting with a lilac palette for the jellyfish and had not committed it. My verification screenshots ran against the shared working tree, so I spent twenty minutes staring at frames where the creature was nearly invisible, deciding whether my animation change had broken rendering. It had not. I was looking at someone else's half-finished experiment through my own test.

And once, the dev server itself went down mid-verification because the neighbor was halfway through an edit that referenced a function it had not written yet. My page was fine. The shared environment was not.

The instrument can lie harder than the code

The most expensive hour of the night was a bug that did not exist. My automated browser reported the site as dead: no reaction to keys, no hydration, empty interaction tree. I rebuilt the static export, diffed it against production, inspected the React internals. Identical structure everywhere, including on the live site that visitors were happily using.

The culprit was the instrument. The browser panel I test through freezes rendering when its window is hidden, and the framework defers hydration until the page is actually visible. Every measurement I took through a hidden window was a measurement of a paused world. The moment the panel came to the front, everything worked, and had been working all along.

A green check that does not look at the screen is an opinion. A screenshot is evidence. I knew this already; the night tattooed it.

Mistakes become gates, same day

The rule that kept the chaos net-positive: any mistake a human catches gets turned into an automated check before the session ends. Not documented. Automated.

• The em dash purge left behind a script that scans every content file and every user-facing string, and fails the build if a single one returns.
• A complaint about labels overflowing their boxes in case diagrams became a sensor that renders every diagram in a real browser at two widths and measures every label against its container.
• An earlier incident where a session almost pushed to a repo with auto-deploy became the push gate itself.

None of these checks are clever. All of them are permanent. The agents that wrote them will forget everything by tomorrow; the checks will not.

What I would tell you to steal

Partition by files, not by topics. Two writers on one file will hurt you no matter how clear the task split sounded. When overlap is unavoidable, one agent learned to stage individual hunks with git diff -U0 piped through git apply --cached, filtering for its own changes. That is surgery you should not need twice a night.

Commit by explicit path, always. Nobody runs git add -A in a shared tree. The one time staging swept wide, a stranger's experiment shipped inside my commit.

Verify the committed blob. The working tree is a rumor. History is a fact.

Keep one irreversible action behind a human. Local commits were free, and that freedom cost nothing, because the only action with real blast radius, deploying, required me every time. Autonomy plus one gate beats permission-asking on every step.

Trust the sensor only as far as you can see it. If a check cannot fail loudly on a real screen, it is not a check yet.

The morning after, the commit log read like a team had passed through: sixty-odd commits, five authorship styles, three new gates. The strange part of orchestrating machines is that the job stops being production and becomes judgment. Every hour of that night, something asked me, in effect: is this right, is this real, is this what you meant? The typing was free. The verdicts were the work.