One Writer per File.
When several agents work at once, each one claims its files, and only one ever writes to a file at a time.
Both save. The second save quietly erases the first. Nobody gets an error.
Everyone claims their own. The one shared file gets a lock, and they take turns.
“Don’t step on each other.”
One October afternoon I had two agents each building a different game of mine, on the same Mac. Games are built in a big engine called Unreal, and Unreal is heavy. Two copies of it running at once can bring the whole machine down. I'd already learned that one the hard way. So when the first agent asked whether it could run its heavy work in the background while I was at the Mac, I said yes, and then I added one more thing.
[…] You can build with unreal or whatever you need. There is also another session building another game, […] So coordinate with him so you guys don't step on each other or crash the machine.
Your schedule is now built into the safety gate, and I've coordinated with […]
[…] its single lock, so the two games can never run Unreal at the same time. […]
Fair sharing: keep each heavy step short, release the lock between steps, and never have two Unreal editors open.
The “safety gate” is a little script every heavy job has to pass through. The lock is a token only one agent can hold at a time. Its message to the other agent didn’t get through, so it left the same note as a file in that agent’s folder, then told me why it wasn’t worried:
Nothing else depends on it. The shared lock already keeps the two games apart.
That's the whole lesson in two lines. I said it the way I'd say it to two people: don't step on each other. The agents turned it into something that can't fail on a busy day: one lock, and turns. In Lesson 15 I told you every helper needs its own desk. This lesson is what happens at the edges, where the desks touch.
The second save wins. Silently.
In my studio, every agent ends its session by adding one line to the top of a shared file: who it was, what it did, and where its full notes are. The next agent reads that line first. Handy, until two agents finish at the same moment.
Here's what happens. Agent A opens the file. Agent B opens the file. A adds its line and saves. B adds its line to the copy it opened a minute ago, which doesn't have A's line in it, and saves. A's line is gone. No error, no warning. Just a line that used to be there.
That happened to us in July. One agent noticed its own summary had slipped below an older one, and dated wrong. Its notes say how we found out:
“Caught by luck while tidying notes.”
Luck is not a system. So the fix came in two parts, and both work for you too.
Give every writer its own file.
Each agent now writes its real notes in a file of its own, with a name nobody else will ever use. Two agents can't collide on a file only one of them writes. The shared line became a pointer to those notes, nothing more. As the agent that built the fix put it: “Losing a pointer update is annoying; losing a note is not acceptable, so notes never depend on the pointer.”
Take turns on the one you can't split.
The shared line still exists, so only a tiny tool may change it. The tool takes a lock, so only one agent at a time gets in. Then it reads the file fresh, inside the lock, before it adds anything. That re-read is the part people miss. Taking turns doesn't help if you're writing onto a copy from five minutes ago.
Three more ways the desks touch.
A shared file is the obvious one. These are the sneaky ones, all from my studio.
Two copies of the same helper.
A lead agent sent a message to a helper that was already running. The app didn't deliver it to the running helper. It quietly started a second copy of that helper, and the copy got the message. Now two of the same agent were editing the same files, and the original noticed someone else had changed its work. The fix: talk to running helpers through one agreed place, like a status file they check before each step.
Two helpers, one scratch file.
Two helpers each kept a tiny scratch file saying which program was theirs, and they both picked the same file name. One of them read the other's note and shut down the other's program. Nobody did anything wrong on purpose. Even scratch files need an owner, so now every helper gets its own folder.
Sending more than you made.
When an agent publishes a site or uploads work, it sends whatever is sitting there, not just its own part. One agent's upload once carried another agent's draft along with it. My studio's rule book says plainly what the real danger is:
“Unreviewed code going live is the hazard; lost code never was.”
And why you can't just watch for it yourself: “A human approving the deploy prompt cannot prevent this.” When an agent asks “OK to publish?”, you can't see that half of what's in the folder belongs to someone else. So in my studio, every agent claims the files it's working on when it starts, and is told who else is working. Publishing goes through one gate that flat-out refuses a folder holding another agent's unfinished work. And before an agent sends anything, it lists exactly what's going out and checks that every piece of it is its own.
Notice who did what. I said it once, in plain words: don't step on each other. The agents built the locks, the claims and the gate.
Take your turn, and read before you write.
Most files should have one writer, full stop. For the few that can't, like a shared to-do list, writers take turns. Whoever has the turn opens the latest version, adds to it, saves, and hands the turn back.
Never write onto a copy you opened a while ago. That's how the second save erases the first.
Draw the lines before the helpers start.
Next time more than one AI, or an AI and you, work on the same thing at once:
- Make an owners list first.
Before any helper starts, have your lead agent write down who owns what. Paste this:
Before anyone starts, make an owners list for this job: every file, document or section we'll touch, and the one helper (or me) who is allowed to change it. Anything two of us need to change goes on a short "shared" list, and for those we take turns. Each helper gets its own folder for its scratch work. Show me the list before work begins. - Split the shared document.
Two AIs drafting one report? Give each its own sections, or its own copy, and let the lead put them together. Don't have two of them typing in the same place at once.
- Refresh before you edit.
For anything you truly share, open the latest version right before you change it. That goes for you too.
- Ask “is all of this ours?” before anything goes out.
Before your agent publishes, uploads or sends, paste this:
Before you send or publish anything, list exactly what's going out, and for each piece say who made it and whether it's finished and checked. If anything isn't yours or isn't finished, stop and tell me instead of sending it. - Message running helpers in one place.
Tell a busy helper things through the place you agreed on, not by starting a fresh copy of it.
Give every writer its own file, make them take turns on the one they must share, and check that everything going out belongs to whoever is sending it.
Check the License
Free to download isn't free to use. Before a tool, a model or a song goes into your work, find out what you're allowed to do with it.
Every exchange on this page really happened and is quoted exactly, slips included; […] marks where I trimmed. Lines quoted from my studio's notes and rule book were written by my agents. Times are Eastern. My agent here is Claude, made by Anthropic.