I tried every note-taking hype stack Notion, Obsidian, Zettelkasten and ended up debugging my thoughts like a bloated codebase. Deleting it all wasn’t the failure. It was the fix.
I rage quit my second brain.
Not archived. Not exported. Just rm -rf.
Because what started as a “productivity upgrade” turned into the ugliest legacy repo I’ve ever managed: 10k half-baked notes, broken links, and enough TODO tags to make Jira blush.
At some point, opening my Obsidian graph view felt like staring at spaghetti microservices with circular dependencies. Debugging my own thoughts had become harder than debugging production code at 3 a.m.
And that’s when I realized: the problem wasn’t me forgetting things the problem was me trying to remember everything.
TLDR: Most devs don’t need a “second brain.” We need a lightweight toolbox that makes retrieval easy, not a bloated vault where ideas go to die. In this article, I’ll explain why I rage quit my second brain, show the before/after receipts, share a dead-simple decision table, and walk through the minimal PKM stack that actually works for developers.
Why devs fell for the second brain hype
A few years back, PKM (personal knowledge management) hit dev Twitter like a shiny new framework drop:
- Tiago Forte’s Building a Second Brain was pitched like the React.js of self-help.
- Zettelkasten was hyped as the “TDD of note-taking.”
- Notion workspaces were flexed on YouTube harder than dotfiles in a GitHub repo.
As developers, we’re wired for system-building. We write aliases for fun. We refactor configs nobody asked us to. We believe if we just capture everything, we’ll compile into a 200 IQ productivity machine.
And for a while, it felt amazing. Obsidian had backlinking. Roam had graph views. Notion had databases on databases. It looked like GitHub for your brain.
But here’s the catch: the same obsession that makes us tweak .vimrc at 2 a.m. also makes us vulnerable to productivity theater. My second brain wasn’t a knowledge base. It was a side project that never shipped.
The debugging nightmare of my notes
At first, it felt powerful. Every idea, code snippet, and design doc went neatly into Obsidian. I had backlinks, tags, YAML frontmatter. It was like standing up a clean monorepo.
Fast-forward a year and my “brain repo” looked like this:
- 10,000+ notes (half unfinished).
- 400+ TODO tags promising I’d “fill later.”
- Broken links everywhere, pointing to notes that didn’t exist.
- Duplicate files I had three versions of regex cheatsheet.md and still googled “regex lookbehind.”
Trying to search my vault was like grepping logs with no timestamps. You might find the info you need, but you’ll drown in garbage first.
And the Obsidian graph view? It looked less like a brain and more like Neo staring at the Matrix pure spaghetti.
At some point, I realized something brutal: if I can’t retrieve my own notes when I actually need them, does my second brain even exist?
The false promise of infinite capture
The PKM hype preached a simple mantra: “Just capture everything. Future you will thank you.”
So I did. Every snippet, every article, every random Hacker News hot take shove it into the vault. It felt productive, like I was building a personal Stack Overflow that only I controlled.
Reality check:
- The GitHub gists I clipped? Never opened again.
- The Stack Overflow snippets I saved? Duplicated what I already knew.
- The article highlights? Basically a trash folder with Markdown syntax.
It was like writing Jira tickets no one ever picks up. A backlog with infinite tickets isn’t “organized” it’s dead weight.
The more I captured, the less I trusted my system. My vault didn’t feel like a second brain. It felt like a black hole where ideas went to die.
Before/after: receipts from my vault
I’ll show you what my “second brain” actually looked like.
Before (bloated vault):
Arduino:
/vault
┣ regex-tricks-1.md
┣ regex-tricks-2.md
┣ regex-snippets.md
┣ regex-snippets-final.md
┣ todo-fill-later.md
┣ meeting-notes-2022.md
┣ meeting-notes-2023-v2.md
┣ random-idea-1.md
┣ random-idea-2.md
Each file had 2–3 half-sentences. Most were duplicates. Some just said:
TODO: expand later
Spoiler: “later” never came.
Now compare that to my rebuilt setup:
After (minimal stack):
/knowledge
┣ regex.md # only 6 patterns I actually reuse
┣ sql.md # 5 queries I reference constantly
┣ shell.md # grep, awk, sed in one place
Every file is short, grep-friendly, and actually used.
This was the “aha moment” for me: a second brain isn’t measured by note count, it’s measured by retrieval speed. My bloated system was a database I never queried. My minimal setup? A cache I hit daily.
What worked after I deleted it
When I nuked my vault, I expected chaos. I thought I’d be lost without my “knowledge base.” Instead, something weird happened: my brain kicked back in.
That regex trick I kept forgetting? I remembered it not because it was buried in regex-tricks-4.md, but because I had to struggle through it twice. Struggle beats tagging every time.
My rebuilt stack looked almost embarrassing in its simplicity:
- Markdown + grep → long-term storage. No fancy graphs, just plain text I can search.
- Browser bookmarks → for active research (stuff I’ll need this week).
- Memory → reinforced by repetition, not hoarding.
It felt like running git clean -fdx on my head. Brutal at first, but refreshing once the cruft was gone.
And here’s the kicker: the less I stored, the more I actually remembered. Turns out, relying on memory makes it sharper like muscle that atrophies if you outsource all the lifting.
Dev brain vs second brain
Here’s the mental model that finally clicked for me:
- A cache is valuable because retrieval is fast and the stuff inside gets reused.
- A database full of stale, unqueried rows? Worthless it just eats storage and slows things down.
Most “second brains” are junk databases. They grow endlessly but rarely get queried. My real brain, when I stopped outsourcing everything, acted more like a cache: it remembered the useful stuff through repetition and naturally garbage-collected the rest.
I set myself a rule:
If I don’t use it twice in six months, it’s basically dead code.
That one principle alone cut 90% of my note-taking overhead.
And honestly? It was freeing. My brain doesn’t need to be a bloated warehouse. It just needs to be a hot cache with the right eviction policy.
The decision table: when to save vs forget
One of the biggest mistakes I made with my second brain was zero filtering. If it crossed my screen, I dumped it into Obsidian. That’s how you end up with 10,000 zombie notes.
So now I use a simple rule: save only what I’ll actually use. Here’s the table I follow:
It’s not fancy, but it’s way more useful than obsessing over tagging systems or backlink graphs.
Think of it like garbage collection: most data is temporary. Only persist what you’ll reuse, everything else can be thrown away.
The minimal PKM stack that works
After deleting everything, I realized I didn’t need a “second brain.” I just needed a couple of tools I could trust:
- GitHub gists → for snippets I actually reuse and sometimes share.
- README.md files → personal documentation worth keeping (regex, SQL, shell one-liners).
- One lightweight note app → Apple Notes, Obsidian, Logseq, pick your flavor. The key is to keep it boring.
That’s it. No 10,000-note vaults. No backlink graphs. No “productivity theater.”
And it turns out, I’m not the only one who came to this conclusion.
- On Reddit: “My Obsidian vault turned into procrastination” → thousands of upvotes.
- On Hacker News: “PKM feels like busywork” → devs admit they spent more time tagging than using notes.
The pattern is clear: most developers don’t need bigger vaults, they need fewer dependencies.
Because the truth is simple: your brain doesn’t fail because it forgets it fails when you try to make it remember everything.
Conclusion + resources
Deleting my vault felt like running git clean -fdx on my head. Harsh. Irreversible. But freeing.
Here’s the hot take:
Most PKM isn’t “knowledge management.” It’s procrastination theater.
It feels productive tagging, linking, highlighting but it’s the same energy as endlessly tweaking .vimrc or rewriting dotfiles. Busywork disguised as progress.
Developers don’t need massive note vaults. What we need is:
- A lean toolbox (gist + README + one note app).
- A brain that remembers through use, not hoarding.
- The humility to let junk expire, just like dead code.
Maybe one day, AI will become our real second brain. Until then, I’m fine running human memory v1.0 with a few Markdown files taped on.
So what about you? Are you still running a second brain… or did you rage quit too?
Helpful resources
Top comments (0)