The Spec That Never Shipped: A Story About Building Backwards

The Nine Hundred and Seventy Seven Lines

There is a document sitting in a docs folder right now, freshly moved there like furniture into a storage unit. Nine hundred and seventy seven lines of architectural specification. Five planned stages. Three databases working in concert. A knowledge graph. A vector store. A plugin system with abstract base classes.

It produced seven commits.

Seven commits, all written in a single night back in January. Two hours of actual work. Then the project went dark for two and a half months. Not because the code was bad. The code was clean. The architecture was sound. The Svelte components had proper error states. The date precision model covered exact, month, year, and guess. The HEIC to JPEG conversion handled all eight EXIF orientation cases.

It was a beautiful machine that nobody drove.

The Third Attempt

This was the third try. Version one took weeks. Real weeks, with frustration and debugging and plugin discovery systems and kernel abstractions. It had five working importers. It had sixty thousand location points ingested. It had five hundred and twenty two photo clusters. It even had a constitution.

The constitution is the only part that aged well. Eleven articles governing how a personal evidence system should behave. Evidence over opinion. Curious, never authoritative. Reversible by design. And the privacy model, which labels everything as either Pants, Underwear, or Naked.

"If LifeLab ever feels confident when it should feel curious, this Constitution has been violated."

The builder kept the constitution. The builder also kept the fact that filing things as Underwear makes him smile. That is a feature, not a quirk.

What Orchestra Taught

Between version two dying in January and today, something happened. A completely different project called Orchestra spent weeks analyzing eighteen hundred AI conversations, tracing how one person's relationship with tools evolved over three and a half years. And Orchestra discovered something that changed how LifeLab needed to work.

Orchestra did not succeed by building a pipeline. It succeeded by investigating. Pick a question. Gather what you have. Notice the gaps. Go hunting for more. See the picture fill in. Notice new gaps. Repeat. The dopamine was not in the import. The dopamine was in the discovery.

Version two had been built as a pipeline. Scan photos. Stage them. Correct errors. Commit to database. Browse results. It was an assembly line for memories, and nobody wants to work on an assembly line.

Version three needed to be an investigation tool. The question drives the data gathering, not the other way around.

Two Hours, Not Two Months

Here is the part that should not work but does.

The entire system was rebuilt in one session. Not a weekend. Not a sprint. One conversation. From reviewing the dead project through designing the new architecture through writing every line of code through testing every endpoint through deploying the storage bucket through building the OCR correction interface.

The conversation started with an inventory. What exists. What failed. What changed since January. Then a comparison with everything learned from Orchestra, from Director lessons, from how the rest of the toolkit evolved. Then a design document. Then a plan. Then code.

Six phases of implementation, each delivering something that works. Phase zero stripped out two databases that never held data. Phase one added investigation tables, threads, findings, a timeline density endpoint that immediately showed twenty three years of photos in a single API call. Phase two connected a Scaleway storage bucket named Tidsmaskin, which is Swedish for time machine. Phase three rebuilt the entire frontend as a timeline viewer with pink density bars.

Phase four added search and a copy on link system for pulling evidence from email archives and chat logs. Phase five added document scanning and Google Timeline import. Then, because the conversation was still going, a full OCR pipeline appeared. Two model profiles. Per page processing. A side by side correction interface where you see the scanned image on the left and the editable text on the right and you press Command S and it saves and automatically advances to the next page.

Thirteen hundred artifacts visible on a timeline. Three data types mixing together. A review queue. Investigation threads with open questions. Privacy badges that say Pants and Underwear. All of it working.

The Underwear Principle

The builder corrected an assumption early in the session. The original restart document had narrowed the scope. Physical artifacts first, it said. Basement boxes as the new stage one.

"The goal of LifeLab is still very wide. The basement boxes are just one input. The workflow from Orchestra is the key."

This correction saved the project from the same trap that killed the first two versions. The spec disease. The urge to narrow scope into something manageable, to define the one correct entry point, to plan five stages before writing a line of code.

The system that actually got built has three importers, not one. It handles photos, scanned documents, and location history. It has a universal artifact table where everything lands on the same timeline. It has an investigation API where Claude Code sessions can create threads and save findings. It does not have a five stage roadmap. It has a loop.

Pick a thread. Gather evidence. See gaps. Hunt for more. See the picture fill in.

The specification that never shipped was nine hundred and seventy seven lines. The conversation that built the working system was shorter. But it asked better questions.

What Remains

The OCR models are not downloaded yet. The AI SSD with forty thousand photos is not plugged in. The Google Timeline has not been exported from Takeout. The basement boxes have not been opened.

None of that matters yet. What matters is that when the builder gets home tonight and plugs in the drive, the photos will appear on the timeline. When the OCR model finishes downloading, the correction interface is waiting. When a box gets opened and things get scanned, the upload endpoint accepts files and the bucket stores them and the privacy selector includes an option that makes someone smile every time they use it.

The system exists now. Not as a specification. As a thing that runs.

Version one took weeks and stalled. Version two took one night and stalled. Version three took one conversation and shipped. The difference was not the technology. It was knowing what question to ask first.