A few months ago, if you’d asked me where “the truth” lived for any of my businesses, I’d have pointed you at Notion. A beautiful, sprawling, endlessly organized Notion workspace. Project pages. Status trackers. Decision logs. The whole thing.

It looked like a source of truth. It felt like one.

It wasn’t.

Here’s what actually happened, and why I ended up somewhere I never expected: a plain folder of text files in Git, of all places, being the most trustworthy thing I own.

The slow collapse nobody notices happening

The failure didn’t look like a failure. That’s the part that got me.

Pages got longer. That’s normal — more work means more to write down. But longer pages got slower to open, slower to edit, sometimes they’d just… hang. And when a page is slow or half-broken and you’ve got five other things on fire, you don’t stop and fix the page. You do the very reasonable thing: you jot the update somewhere else “for now,” planning to reconcile it later.

Later never really comes. Not because you’re lazy — because there’s always a new later.

A few months of that, and here’s what you actually end up with:

  • Half a dozen pages that all claim to be “the current status” of the same project
  • Notes stranded in random side-documents that never made it back into the real record
  • No way to know, at a glance, which version of anything is the one that’s true

The individual pieces of this weren’t dramatic. No single mistake broke anything. It was just… erosion. And erosion is sneaky, because every day it looks basically fine, right up until the day you genuinely can’t tell what’s true anymore.

That’s the moment I actually understood what “single source of truth” means. It doesn’t mean “a nice organized place to put things.” It means: there is exactly one place, and if it’s not there, it didn’t happen. Anything short of that isn’t a source of truth — it’s a filing cabinet with good intentions.

The fix that fixed the wrong thing

So I did what felt like the obvious move: consolidate. Kill the sprawl. Get everything into a small number of canonical documents instead of a hundred scattered pages.

That part actually worked. Multiple writers agreeing on where the truth lives — genuinely solved.

But a few weeks later, a different version of the exact same problem showed up, wearing a different costume.

I’d built a system that “mirrors” my canonical documents into a place my AI tools could reliably read them — because, ironically, the tool I was using to read my source of truth kept flaking out on me. The mirror worked great for a while. And then, over the course of maybe three genuinely productive days, it got so big it started failing to load. Not because anything was wrong with the underlying documents — because I’d never actually answered the question “how much detail is allowed to pile up before this becomes unreadable?”

Same failure. Different layer. I’d fixed who writes the truth, but never fixed how much truth is allowed to accumulate in the one place everyone reads it from.

That’s the lesson I want to actually hand you, because I think it’s the one most people miss: a source of truth needs two separate answers, not one. Where does the permanent record live? And separately — completely separately — what’s the small, current thing someone actually needs to look at right now? Those are different documents doing different jobs, and conflating them is how even a “fixed” system quietly breaks again.

Why I ended up trusting Git more than anything else I’ve tried

This is the part that surprised me. I didn’t expect a tool built for software engineers to become the backbone of my actual business operations. But once I understood what I actually needed, Git kept being the answer, over and over.

Here’s the thing that sold me, in plain terms: every single edit you make to a file in Git doesn’t erase the old version. It stacks a new version on top and keeps the old one, forever, exactly as it was. You get one clean current file to look at today, and a complete, unbreakable history underneath it whenever you need to go back and see what changed and when.

Compare that to a pile of documents with dates in their filenames — which, if you’ve ever tried it, you already know the problem: it only works if every single person (or AI) writing those files gets the timestamp exactly right, every time, forever. The one time someone doesn’t, you’ve got a file that looks newer than it actually is, and now you’re making decisions off the wrong version without even knowing it. That actually happened to me. Two sessions of mine created “status update” documents on the same night, and the filenames implied one was written after the other — except they weren’t, and for a few hours the system was quietly working off stale information because a human-written timestamp lied.

Git doesn’t have that failure mode. It doesn’t ask anyone to get a timestamp right. The order is just… true, mechanically, every time.

So the shape I’ve landed on, for anyone running more than one thing at once and drowning in “where’s the real version of this”:

One canonical file per thing, edited in place — not appended to forever. This is your “what’s true right now.” It should stay small, because it only ever describes the present, not the history.

A separate, permanent decision log that’s allowed to grow forever — on purpose. Every real decision goes here, dated, never edited after the fact. This is your accountability trail, and it should never be summarized away or “cleaned up.” History is supposed to be big. That’s fine, as long as it’s not the thing you’re forced to read cover-to-cover every single day.

And a hard rule about what gets read by default. The daily view should only ever show you what’s current — not the entire history of everything that’s ever happened. The permanent record stays reachable whenever you actually need it, it just isn’t shoved in front of you every time you check in.

The takeaway, if you’re building anything like this

You don’t need Git specifically. What you need is the principle underneath it: separate “what’s true right now” from “everything that’s ever been true,” and never let the second one accidentally become the thing you’re forced to read every day just to find out where you stand.

Most sprawl doesn’t come from bad intentions. It comes from a system that never drew that line — so everything piles into one place, until one day the one place stops working.

Draw the line early. It’s a lot cheaper than the erosion.

— Warren