Say you're getting your online store ready for a big weekend. You've got two AI assistants going at once, because two helpers should finish faster than one, right? You tell the first one "clean up the contact form." You tell the second one "fix whatever's broken on the checkout page." Different jobs. Different pages. Should be fine.
Forty minutes later you check in. Both of them touched the same file, the one that handles sending emails for the whole site, because of course they did. That file mattered to both jobs. Now one assistant's changes are half overwritten by the other's, and neither one has any idea the other exists. You spend the next hour figuring out whose version survived, and whether either one actually works.
That's not a fluke. That's just what happens when nobody's watching.
Two contractors and one wall
Here's a way to picture it that has nothing to do with computers. You hire two contractors to fix up a house. You never introduce them, you never give them a shared schedule, and you leave for the weekend.
You come back Monday to find one of them tore out a wall the other had just finished plastering. Not because either contractor is bad at their job. Because nobody told them the other one existed, and a wall doesn't come with a note attached saying who's already working on it.
Two AI assistants pointed at the same project have exactly that problem, except it can happen in minutes instead of days, and it can happen twenty times before lunch.
The other one: work that just vanishes
Here's a second flavor of the same headache. Ever had an assistant just... stop? Laptop went to sleep, the tab closed, the session timed out, whatever. And whatever it was in the middle of doing is just gone. Not paused. Gone.
You don't know how far it got. You don't know what it already changed. You don't know if it's safe to just start over, because for all you know it already touched three other things on its way to wherever it stopped. So you either dig through everything by hand to figure out what happened, or you just cross your fingers and hope.
Why smart assistants do such a dumb thing
None of this is because these tools are bad. Individually, they're often genuinely impressive. The problem is that each one is working from its own private memory of the project, updated only when it happens to look. There's no shared, honest, up-to-the-second list of who's doing what that everyone actually checks before touching something.
Every assistant is confident, capable, and completely unaware that anybody else is in the building. That's the whole failure, in one sentence. Nobody built the clipboard that all of them check before picking up a tool.
What actually fixes it
That clipboard is the thing we built. It's called Lacunari, and the short version is: before any assistant touches anything, it has to check in with one shared list first, and that list makes sure two of them never grab the same job or the same file at the same time.
How that actually works, in plain English, is worth its own explanation. That's the next one.
What Lacunari actually is → · How it makes sure nothing collides →