Your Second Brain Deserves Git, Not a Sync Service

Table of Contents

1. Why Sync Services Miss the Point
2. Git Diff Shows You How Your Thinking Evolved
3. Branches Let You Explore Without Commitment
4. Grep Your Entire Knowledge Base in Milliseconds
5. True Portability Across Every Machine You Touch
6. The Plain Text Advantage Nobody Talks About
7. What This Actually Looks Like
8. When Git Doesn't Make Sense

Why Sync Services Miss the Point

You commit code multiple times per day. You write detailed commit messages explaining why you changed something. You create branches to experiment with ideas. You use git log to understand how a system evolved.

Then you open Notion or pay for Obsidian Sync and... none of that exists for your thoughts.

The problem isn't that Notion or Obsidian Sync are bad products. They work fine for syncing. The problem is they treat your knowledge base like Dropbox treats files: copy this thing to that place, hope nothing conflicts, show you a timestamp if something goes wrong.

That's not version control. That's just file synchronization with better UX.

Analogy: Using a sync service for your notes is like using FTP for code deployment. Sure, the files end up on the server, but you've lost the entire history of why they changed.

If your notes matter enough to organize into a second brain, they matter enough to version control properly. And you already know how.

Git Diff Shows You How Your Thinking Evolved

Here's what happens when you use git for notes:

You write initial thoughts on async architecture. Commit.

Three weeks later, you update those notes after a production incident. Commit with context: "Added fallback patterns after redis timeout killed checkout."

Six months later, you run git log -p async-patterns.md and see exactly how your understanding deepened. Not just that it changed. How it changed and why.

Notion gives you "Last edited 6 months ago." Obsidian Sync shows you conflicted copies if you're unlucky. Git shows you the semantic diff of your thinking.

$ git diff HEAD~5 distributed-systems.md

- Event sourcing solves everything
+ Event sourcing trades consistency for complexity
+ Only use when replay semantics matter

That diff is worth more than the original note. It shows you learned something.

Notion's version history costs $10/user/month and maxes out at 30 days unless you're on Enterprise. Git's history is infinite and free.

Branches Let You Explore Without Commitment

You don't merge half-baked ideas into main. Why would you do that with your notes?

When you're exploring a new concept, create a branch:

$ git checkout -b exploring-crdt-for-collab

Now you can write messy thoughts, copy paste from papers, link to random Twitter threads. If the exploration leads somewhere, merge it. If it doesn't, delete the branch or leave it around as a time capsule of what you considered.

Notion and Obsidian make you either:

1. Pollute your main workspace with exploratory mess
2. Create a separate "scratch" area that never gets organized
3. Just not explore because the friction is too high

Git branching is zero friction. You already do this for code. Your thoughts deserve the same workflow.

Grep Your Entire Knowledge Base in Milliseconds

Notion search is slow. Really slow. You type, wait for the request, scroll through results that include every page where you mentioned that word in passing.

Obsidian search is fast but limited to whatever subset of notes you have locally synced.

Git gives you the entire Unix toolchain:

# Find every note mentioning rate limiting
$ git grep -i "rate limit"

# Show context around matches
$ git grep -C 3 "circuit breaker"

# Search through history
$ git log -S "eventual consistency", all

# Combine with other tools
$ git grep "postgres" | xargs wc -l

This isn't just faster. It's a different class of search. You can pipe to awk, filter with sed, cross-reference with comm. Your knowledge base becomes queryable data, not a walled garden with a search box.

True Portability Across Every Machine You Touch

You SSH into a server. You want to check your notes on how you configured nginx last time.

With Notion: open a browser, log in, wait for the app to load, search, hope your connection is stable.

With Obsidian Sync: doesn't work in a terminal.

With git:

$ git clone git@github.com:you/notes.git
$ cd notes
$ grep -r "nginx config"

Thirty seconds. Works on every Linux box, Mac, or Windows machine with git installed. No GUI required. No internet required after the initial clone.

This matters more than you think. Your notes should be accessible in the same environments where you need them most: SSH sessions, Docker containers, CI pipelines, air-gapped networks.

The Plain Text Advantage Nobody Talks About

Obsidian already uses markdown files. That's good. But Obsidian Sync locks you into their ecosystem for accessing those files across devices.

Git + markdown means:

• Every editor works: vim, VS Code, Emacs, Sublime, even cat
• Every diff tool works: GitHub, GitLab, terminal, GUI clients
• Every static site generator works: Jekyll, Hugo, Gatsby
• Every LLM tool works: feed your entire knowledge base to Claude via git archive

Your notes outlive any company. Notion could shut down tomorrow. Obsidian could pivot to blockchain. Git and markdown will still work in 2050.

What This Actually Looks Like

Here's a realistic setup:

notes/
├── areas/
│   ├── backend/
│   ├── frontend/
│   └── devops/
├── projects/
│   ├── api-redesign/
│   └── migration-2024/
├── journal/
│   └── 2024/
├── .git/
└── README.md

Daily workflow:

1. Morning: git pull to sync from other machines
2. Take notes in markdown throughout the day
3. Evening: git add -A && git commit -m "Notes from incident review"
4. git push to sync

That's it. No special apps. No subscriptions. Just files and git.

For mobile access, use Working Copy on iOS or any git client on Android. Less polished than Notion's app, but infinitely more flexible.

When Git Doesn't Make Sense

Git isn't always the answer.

If you:

• Need real-time collaboration (Google Docs model)
• Want rich embeds and databases (Notion's strength)
• Prefer GUI-only workflows (perfectly valid)
• Don't use the command line daily

Then Notion or Obsidian Sync might be better. This isn't about git being superior for everyone. It's about git being obviously superior for developers who already live in the terminal.

The comparison table:

| Feature | Git | Notion | Obsidian Sync | | --- | --- | --- | | Version history | Infinite, semantic | 30 days (paid) | None | | Branching | Native | No | No | | Full-text search | Instant, scriptable | Slow, basic | Fast, GUI only | | Offline access | Complete | Limited | Complete | | Cost | Free | $10+/mo | $4+/mo | | Learning curve | Low (for devs) | Low | Low | | Mobile experience | Terminal-based | Excellent | Good | | Collaboration | PR-based | Real-time | Sync-based |

Conclusion

You trust git with code that runs your business. You should trust it with thoughts that inform that code.

The mental overhead of switching tools is zero. You already know git commit, git diff, git log. You already have a GitHub or GitLab account. You already write markdown in README files.

Stop paying for sync services that give you less power than tools you use every day. Your second brain deserves the same version control as your first brain's output.

Create a notes repository. Add a README. Commit your first markdown file. You're done. Everything else is just git pull and git push.

The best knowledge management system is the one you already know how to use.