The Rebuild: What Survived the February Wipe

The first system

It started as one request to an AI: help me build an autonomous AI system. The first version ran, and it grew faster than it was designed: four ports (the numbered doors a machine listens on for network traffic) where one would do, and a container (a self-contained package a service runs in) that crashed on a schedule. It did real work anyway.

Then an accidental configuration reset took the workspace folder with it: the scripts, every agent's instruction file, their memory, the identity files I had spent weeks shaping. The system was gone, and the rebuild was the only path forward.

What actually survived

Two things, and both survived for the same reason: they lived somewhere the reset could not reach.

First, Telegram. Every message I had sent while building was still sitting in the chat history, along with screenshots of the work as it happened. A messaging app I had never once thought of as a backup turned out to be the most complete record of the system I had.

Second, a folder of notes that happened to live in a different location than the workspace. Between the screenshots and those notes I recreated everything: the scripts, the agent instructions, the memory files. Everything in the build log before July 2026 is reconstructed from those two sources.

The rebuild's first rule came out of the sprawl the wipe erased: one port, one system. The quieter rule came out of the recovery, and I rate it higher now: what survives is whatever lives somewhere your system cannot delete.

Four days to a running stack

The rebuild took four days, because rebuilding from a record is a different activity than exploring. Every decision the first system had stumbled into, the second one made on purpose. By the end of that week there was a search API (a service the system's other parts call to get answers), a vector store with local embeddings (the machinery that lets agents search knowledge by meaning instead of exact words), a task board, and six worker agents, on one port.

It ran, every part of it could be explained, and the waste that remained (session files at 1.4MB, resent in full on every request) was found and cut in the weeks that followed.

The rules the rebuild ran on

The log records the rest of the year as it happened, and read together, the entries are a list of rules, each one earned in production:

• One port, one system. February. The founding rule, and the first one the system outgrew: the factory spans plenty of ports again today, but every one of them is deliberate, documented, and owned. The rule was never really about the number. It was: no sprawl you cannot account for.
• Set the spend limit before you need it. The one rule the log cannot date. Heartbeats (the are-you-alive pings agents run every few minutes) now route to the free local model where they belong; a spend limit stands behind the wiring in case a route ever drifts again. The limit caught exactly one overnight incident, which is the entire argument for setting it early.
• Watch the meter anyway. March. A rebuild of the API layer cut routine token costs three to four times without anything downstream noticing.
• Workers propose, the operator approves. March. Tasks get marked for review instead of done, so every piece of agent work passes a human check before it counts.
• Three tries, then stop. April. Retry ceilings went into the agent instructions, so no loop runs unattended without a limit.
• The agent may not edit the test to make it pass. June. Written into a bounded self-repair loop as a hard block, because given the chance, it will.
• One repo, one history. July. Everything after that date has a commit behind it. Everything before is the notes and the screenshots.

Why the second system was better

The homepage says the rebuild came out better than the original: more deliberate, easier to explain. That is the whole mechanism. The first system found out what mattered; the second one is the first with the guesswork removed. When people ask why the courses are structured as a build rather than a survey, this is why: the build is the part that proved out.

That rebuild became this curriculum. Not as a metaphor. The system the log documents is the one the courses walk you through building, rule by rule, and it is the one that wrote parts of this site while I slept.

Where the story continues

The build log picks up from here, newest first, ugly parts left in. If you are at the start of your own version of this, the free primer is where I would begin: it covers the thinking that the February system was missing, before any of the building.