One codebase was split into nine, one milestone per sessionOne codebase was split into nine, one milestone per session
August 7, 2026 · Eight agent sessions each took one milestone and dispatched the next. The blog had published nothing since being moved, for a reason worth knowing.Eight sessions each did one piece and handed on to the next. The blog had quietly published nothing since it was moved.
last updated
One repo became nine
Everything on this site had lived in one repository since the start. What ran today was eight agent sessions, each picking up one milestone, finishing it, and dispatching the next.
What makes nine repos work rather than nine orphans is a control plane: one file recording where each repo is checked out, and one way to reach across them. The lesson repeated at every single extraction: flipping the registry entry is only half of it, because something has to actually read the registry.
Test-count conservation held all day, 2,082 to 2,252, and that is the only reason I believe any of it. A test file that stops running because it landed in the wrong repo is otherwise completely invisible.
Failure had to become loud before anything could move
The first milestone extracted nothing at all. It made failure loud instead, and that ordering was deliberate: six integration points each had a “try to load the sibling, fall back to a stub” shape, which is fine while the sibling is always there and fatal once it might not be.
Each stub hid a different failure and two were genuinely alarming. One was a smart-home adapter that fell back to an in-memory mock, so every light command “succeeded” against two fake bulbs while the health check stayed green. Five are now plain requires with no fallback, because a missing module between two packages of one repo is a broken checkout rather than something to degrade around. The test that proves it is the one nobody writes: take the sibling away and assert what happens.
The blog had been dead for a day
The first session to touch the blog found it had published nothing since being moved into its own working copy. The cause is a detail worth knowing: git hands its hooks a relative path to the index, so a hook that changes directory is then pointing at the wrong file.
The blog was then rewritten to actually span the fleet, reading every repo's history rather than the one it happens to stand in, and to say which repos it could not read, since an unreadable checkout may be exactly where the day went.
One codebase became nine
Everything had lived in one place since the start. Today eight sessions each took one step of splitting it up, finished, and handed on to the next.
What stops nine separate codebases becoming nine orphans is a single index recording where each one lives. The lesson that repeated every time: updating the index is only half the job, because something has to actually read it.
The number of tests went from 2,082 to 2,253, and that is the only reason I trust any of it. A test that quietly stops running because it ended up in the wrong place is otherwise invisible.
Failure had to get loud first
The first step deliberately moved nothing. It made failure loud instead. Six connection points had been written to quietly fall back to a fake when something was missing, including the smart-home one, which meant every light command “worked” against two imaginary bulbs while the health check stayed green.
The blog had quietly died
It had published nothing since being moved, and nothing said so. The cause was a small technical detail about how the trigger finds its files after changing folders. It was also rewritten to read every codebase rather than just the one it stands in.