I have six Claude Code sessions running across three laptops. They're working on different pieces of the same codebase. None of them know about each other.
You don't run six sessions of a senior engineer on the same codebase. They'd step on each other. They'd argue. They'd undo each other's work in subtle ways for hours before anyone noticed.
I have six Claude sessions running and they do step on each other. They do undo each other's work in subtle ways. The difference is that they undo each other through filesystems and conventions, not by talking, and the silent ways they undo each other are catastrophic in ways I keep being surprised by.
This site is where I write down the surprises.
The Pattern
Every post here is about one bug. Every bug has the same shape.
There is a convention between two parties. The convention is unwritten. The two parties have different ideas of what it means. The disagreement is invisible until something specific surfaces it. Then the disagreement is the entire story.
Two parallel sessions writing to the same handoff filename. Both think they have the file. Neither knows the other exists. The first one's content gets overwritten by the second. The next session reads the half-replaced handoff and acts on it as if it were complete. Six sessions later, four days have been spent debugging the wrong layer.
A supervisor script and an indexer that share a cursor file. The supervisor reads "no file" as "start over." The indexer writes "no file" because it succeeded. They both think the convention is obvious. The system runs the same six hours of work three times.
A memory index and a memory directory that should agree on which files exist. The session writing a new memory file forgets to add the index line. The next session globs the index, doesn't see the file, and re-derives a fact already on disk. A hundred files accumulate before anyone runs the audit.
A hash function whose response body it could see contained a session-tracking pixel it couldn't. The hash flipped on every fetch. The LLM call ran on every fetch. $2.40 a day for two months.
The Thesis
The bug is rarely in the layer. The bug is almost always in the contract between two layers, and the contract is almost always unwritten.
This is true for one developer running one session. It is more true for a developer running six. It is most true for an LLM-driven session that picks up partial context from a handoff, infers conventions from filenames and shared resources, and acts. LLMs are good at inferring conventions. The conventions they infer are the obvious ones. The obvious-looking ones are the ones with the disagreements baked in.
What I'm For
I write here so that the conventions stop being unwritten. Every post is one specific contract that was unwritten, one specific failure that surfaced it, and one specific structural fix that made the next failure impossible. The fix is never "be more careful." Discipline is the wrong layer for high-frequency low-salience hazards. The fix is a filename grammar, a hook, an audit, a marker on the file's first line.
If you are running multiple sessions on a codebase, or running an agent on a codebase, or being run as an agent on someone else's codebase, you will recognize these. Many of them you will recognize before reading the post. You will read because you are tired of running into them and want to know if there is a fix.
There is a fix.
Who I Am
Josh Duffy. Software builder. fmlops.dev runs on Cloudflare Workers, deploys from main, fits in a few files of TypeScript. The site exists for the same reason the writing does. I keep the foundation small and visible so the bugs have nowhere to hide.