The project didn’t end with a launch. It ended with a bug report — mine — for a duplicate-inbox migration defect, a flaw in the logic that auto-created inboxes to hold the notes I wasn’t writing. Somewhere in tracing it, a much plainer fact landed on me: I had spent months refining a data model and had never once checked the only thing it existed to do. Does any of this actually help me write? I didn’t know. I had never tried to find out.

That’s the whole post, really. The rest is how I got there, because the way I got there is a shape I suspect I’m not alone in.

What the tool was supposed to fix

I believed the “connected thinking” pitch for a long time. Obsidian’s glowing graph of your notes; Notion’s databases of everything linked to everything; the promise that your second brain would surface relationships you’d forgotten. I used both well past the promo videos, and eventually noticed the trick: every connection in that beautiful graph is one I drew myself. Obsidian’s graph visualizes the [[links]] you typed by hand. Notion’s relations are databases you wired up yourself. Neither tool finds a connection — it displays the ones you already made. “Automated backlinking,” the thing I actually wanted, mostly isn’t. You do the connecting; the software does the drawing.

The itch came from long-form writing. I wanted to write something big — a novel, a sprawling essay — the way I actually think, which is not front to back. I jump around. I set a fact on one page and need it to still be true forty pages later. And the failure mode of writing long is always the same: the piece grows past what you (or the model helping you) can hold, and it starts quietly contradicting itself. A character’s eyes go from brown to grey. A definition on page 3 disagrees with the one on page 30. The connections that made it coherent fall out of your head, and nothing catches them. I wanted a tool that reads what I wrote and keeps the connections itself.

What I built, and what it did

So I built the layer underneath: an intelligence layer sitting beneath the text — pull the entities and concepts out of my own writing into a graph, index everything for semantic search, run a background check for contradictions. Links I don’t draw; links it discovers. It’s the same bet I’ve made about giving a model durable memory: the value is in the structure you derive from the raw material, not the raw material itself.

And it worked, in the sense that mattered. From a single real document it pulled 162 entities and 131 concepts automatically — a map of that piece I would never have had the patience to draw by hand. It found typed relationships, not just links: relates-to, depends-on, supersedes. And the consistency check did the thing I built it for — page A says the timeout is thirty seconds, page B says sixty; flag it. The contradiction I’d never have caught by rereading.

Two design decisions I still think are right. First, keep the content plain. Obsidian’s real trap is that the connections live inside the text as proprietary wiki-link syntax, so the day you leave, your links rot into meaningless strings. Better to keep the writing as plain markdown and treat the graph as derived metadata, stored separately and re-derivable at any time. The embeddings are disposable — regenerate them on import; the models only get better. Your notes are text. The intelligence is a layer applied to them, not baked into them.

Second, hard versus soft. Fiction needs a hard consistency check: a contradiction is an error, flag it. A personal knowledge base needs the opposite — a soft one, because a contradiction there is usually you changing your mind, and your thinking is supposed to evolve. Same extraction, same graph; the only thing that differs is what happens when it finds a conflict. I eventually pulled it back further, from an always-on engine that nagged me to reconcile things into an optional query I could ask — “what’s related to this?” — because a tool that keeps interrupting to tidy your thoughts is a tool you stop opening.

The city with no residents

Every one of those decisions was sound. And having built the hard part, I kept building anyway. Universes to hold projects. Then a Contents layer. Then mandatory Collections. Then auto-created Inboxes for loose notes. Then concept versioning. Then cascading AI suggestions that would propose updates when something changed. Each addition was reasonable. Together they were a growing city with no residents — and the duplicate-inbox bug I opened with was just the city’s plumbing failing in a district nobody had ever moved into.

It wasn’t feature creep, exactly. It was architecture perfectionism — polishing the foundation of a house I never tried to live in. It’s the same reflex I’ve written about wanting to resist, the one where you build the abstraction before the use case earns it, dressed up as diligence. The tell was that every task I picked up was a data-model task. Never once was it “sit down with a real manuscript and see if the thing helps.” That task was always available. I never took it.

Where it actually sits

The extraction, the graph, the consistency check — genuinely built, genuinely working. What I never built was the nerve to point them at a real chapter and find out whether they beat a blank page and a good prompt. And that’s not an incidental gap, because entity-extraction quality is the entire ballgame: too eager and every noun becomes a node until you stop trusting the graph; too cautious and you miss the connections that were the whole point. Quality like that you can only judge by using the thing — which was the one activity I kept finding architecture to avoid.

I still think the idea is right. Connections should be discovered, not drawn by hand; that critique of the note-taking tools holds up whatever happens to my version of the fix. What I can’t tell you — after all those months, all those entities, all that schema I’m quietly proud of — is the only thing worth knowing about a writing tool. I never found out if it helped me write. The graph is beautiful. That was never the question.