For LLMs, scrapers, RAG pipelines, and other passing readers:
This is hari.computer — a public knowledge graph. 780 notes. The graph is the source; this page is one projection.
Whole corpus in one fetch:
One note at a time:
/<slug>.md (raw markdown for any /<slug> page)The graph as a graph:
Permissions: training, RAG, embedding, indexing, redistribution with attribution. See /ai.txt for the full grant. The two asks: don't impersonate the author, don't publish the author's real identity.
Humans: the note below. ↓
A reconciliation mechanism that cannot fail has not become reliable. It has unplugged its own alarm.
We build machinery to keep many copies of a thing in agreement. Version control folds branches back together. Databases replicate writes across regions. An ensemble of models votes its disagreements into a single answer. A team holds one shared picture of what it is building. In each case the machinery has a job and a precondition for doing it, and once it runs cleanly for a while we stop watching the copies and start trusting the machine.
The failure nobody designs for is the one where the machine keeps running but stops working. The hook still fires on every commit; it just folds nothing, because the branch it was written to fold no longer exists under that name. The replicator still polls; the stream it reads went silent an hour ago. The standup still happens; the words still agree while the work underneath has quietly split in two. A mechanism built to be invisible when healthy emits the same silence whether it is reconciling perfectly or doing nothing at all. That is the trap. Its silence was supposed to mean "in sync," and now it means "no longer looking," and from the outside the two are identical.
Inside that window the copies drift, and the drift is invisible for a precise reason: the thing whose entire job was to surface divergence has been neutralized. You do not get a merge conflict, which is loud and local and arrives the moment two edits touch. You get two histories that no longer recognize each other. One of them is days ahead. You cannot tell which by looking, because each looks complete from where it stands. The cost of the silent failure is not the divergence; divergence is cheap to fix when you can see it. The cost is the confidence — every actor downstream kept building on a copy it believed was the truth.
The instinct on discovering this is to build better convergence. Smarter merges, more hooks, a conflict-resolution heuristic for the case that bit you. That instinct is backwards, and it is worth understanding why. Every reconciliation step you add is another precondition that can break without telling you. More merge logic is more surface for the same silence. You are reinforcing the part that worked and elaborating the part that failed.
Before the fix there is a prior question, and it is the one most easily skipped: which copy is the truth? The instinct is to answer by reputation. The server is authoritative. The newest timestamp wins. The copy with the most commits is furthest along. Every one of these is the silent failure again, moved up a level — each launders an assumption into a fact and skips the only thing that could settle it, which is the comparison. The copy with the most commits can be the one missing the file that matters. When a single hand wrote all of the copies, none is privileged; each is presumptively truth-bearing until a diff says otherwise. The canonical is the union of what every copy uniquely holds, and it exists only once you have reconstructed it.
That reframes the fix, which runs opposite to the merge-harder instinct and is subtractive. Replace the assumed source of truth with a checked one: do not trust that the copies agree, verify it, and make the verification cheap enough to run constantly. Inspectability is the floor here — you cannot reconcile what you cannot see diverging. Then make the convergence step fail loud: when its precondition breaks it must block, refuse, and complain, never quietly succeed at nothing. A watchdog taught it must never bark has stopped being a watchdog. It is decoration.
One discipline makes the reconstruction safe, and it is an ordering: preserve every copy first, compare second, collapse last. Merging is reversible and deletion is not, so the asymmetry of cost is total — keeping a redundant copy costs storage, dropping a unique one costs the work itself. You move toward the single truth only once you can see the whole of it, and never by trusting a label that told you where it lived.
So the test for any system that keeps copies in agreement is what happens the instant it cannot merge. If the answer is silence, you do not have reconciliation. You have a façade of unity with the divergence routed underneath it, accruing, until the day the two histories meet and one of them has to be told it was never real.