Digital Hoarder: Stop Organizing Everything you Never Use

Every day, you consume digital content: articles, blog posts, tweets, videos, conference talks, random links dropped into Slack right when you’re deep in something else.

Some of it is immediately useful. Some of it is inspiring. Some of it creates that familiar feeling:

This might be important.

And almost every time, the same thought appears:

I should save this for later.

That sentence sounds responsible. Productive, even.

In reality, it’s often where personal knowledge systems quietly begin to collapse, not because the tools are bad, but because we start saving inputs as if they were finished thoughts.

After more than a two decade of collecting developer resources (and after several failed attempts at building “perfect” systems) I’ve learned something uncomfortable:

Most things we save were never meant to be organized. They were meant to be temporary.

Here’s a story that led me to this conclusion.

The bookmark phase: optimism without a plan #

The first solution most people reach for is browser bookmarks. They’re frictionless. One click and the problem feels solved. You might even create folders. Maybe subfolders. This time, you think, it will stay organized.

It won’t.

Bookmarks grow faster than meaning. Every new link forces a categorization decision: Where does this belong? Over time, folders drift toward vague buckets like “Reading”, “Interesting”, or “Later”, which is just entropy wearing a nicer label.

Eventually, bookmarks stop working as a system. Finding anything depends on browser search, and only if you remember a word from the title. At that point, bookmarks aren’t a library anymore. They’re a graveyard.

Files and notes: when structure becomes the enemy #

After bookmarks fail, the next instinct is to get more serious: markdown files, Notion docs, notes with links and short explanations, carefully structured folders, or maybe even a repo called knowledge-base.

It feels like progress! Now you’re adding context, not just collecting URLs. But something subtle happens: instead of saving interesting things, you start designing a system.

Every capture now demands cognitive effort:

• Where does this go?
• Is this a note or a resource?
• Does it deserve its own file?
• Should the folder structure be reorganized-again?

The cost of saving something starts to approach, even exceed, the value of the thing being saved. You spend more time maintaining the system than using what’s inside. The friction is higher than bookmarks, but the payoff isn’t proportionally better.

Heavy knowledge systems: great for thinking, bad for raw capture #

At some point, many people discover tools like Notion, Obsidian , Roam Research, Logseq or some other for organizing complex information, and feel they’ve finally found the solution. Atomic notes, links between ideas, tags, backlinks, graphs… A tool that actually respects how thinking works.

I’ve used Obsidian for more than four years now. It’s an excellent tool. I use it daily for thinking, writing, and preparing talks.

At one point, I tried using it as my primary place for saving links and raw inputs. However, it failed.

Not because Obsidian is bad - quite the opposite. It failed because most things I encountered weren’t thoughts yet. They were just inputs:

• interesting repos
• half-formed ideas
• articles I might read someday
• conference talks I wasn’t ready to process

Obsidian shines when you already have intent, when you’re researching a topic, building an argument, writing content, or connecting ideas. But capture is a different mental mode.

The problem is that most things you encounter are not thoughts yet. They’re inputs. Half-formed ideas. Interesting references. “This might be useful someday” material. You don’t want to explain them to your future self yet, because you don’t know what they’re for.

Some people successfully use Obsidian for both capturing and thinking - but in practice it requires a level of discipline most of us don’t maintain long-term. Naming notes, linking ideas, and structuring content becomes overhead when you’re just trying to save something quickly during a busy day.

Heavy knowledge systems quietly fail here, not because they’re bad, but because they demand intent before intent exists.

The right tool for raw input #

About two years ago, I built a HomeLab and started experimenting with self-hosted tools. That’s when I discovered Karakeep - a lightweight bookmarking tool.

I tried it without high expectations. And it worked immediately, because it didn’t try to be a thinking system.

Tools in this category focus on one job: capture without friction. At their core, they should do very little:

• save links, notes, images
• organize them just enough

Examples you may already recognize:

Bookmark / capture managers

• Karakeep - lightweight bookmarking with tags, archives, automation rules, and good search
• Raindrop - polished bookmark manager with folders, tags, highlights, and solid full-text search
• Instapaper - optimized for reading later, with offline access and minimal organization overhead

Read-it-later tools

• GoodLinks - a simple, local-first “read-it-later” tool with fast capture and basic tagging
• Wallabag - self-hosted read-it-later focused on long-form articles

Despite differences in features and polish, these tools share the same philosophy:

capture first, decide later.

Saving is intentionally cheap. One click from a browser, one tap on mobile, optional tags, optional structure. No requirement to explain why something matters at the moment you encounter it. That design choice is the whole point.

These tools work because they assume most captured items are raw inputs, not finished thoughts. They let you accumulate material without interrupting your flow, and they postpone meaning-making until you’re ready for it.

The trade-off all capture tools share #

However, all tools in this category have the same fundamental weakness. They’re very good at accumulation and surprisingly bad at extraction.

Over time, saved items pile up. Even with good search and tags, the list grows long enough that reviewing it starts to feel like work. You end up with a second inbox - cleaner than bookmarks, but still rarely revisited.

This isn’t a bug in any specific app. It’s a structural problem of passive capture systems. The way to overcome it isn’t better tagging or more folders. It’s intentional review.

A simple workflow that actually works #

So, after trying all of these tools, I finally find a way that works for me, at least at this point of my life. Here’s a practical example of how I use this split today:

During the week

• Save everything quickly into a capture tool (Karakeep in my case)
• No tags unless they’re obvious
• No organization beyond quick capture

Weekly or bi-weekly review (~20 minutes)
Ask three questions:

• Is this still interesting?
• Is this actionable now?
• Does this belong in a thinking system?

After review

• Delete aggressively
• Archive rarely
• Promote selectively into Obsidian only if it connects to an active project, talk, or article

Only a small percentage of what you save deserves to graduate into a deeper system like Obsidian, a document, or a project. That’s normal. The rest did its job by being available when you needed it - or by proving you didn’t.

When you accept that most captured material is disposable, these tools stop feeling overwhelming and start feeling useful. They don’t replace thinking tools. They protect them. And that’s exactly what they’re meant to do.

A simpler way to think about your knowledge system #

Finally, I realized that most personal knowledge systems don’t fail because the tools are bad. They fail because one system is asked to do two different jobs:

1. Capturing things you might want later
2. Thinking deeply about things you’re actively working on

These two concepts require different mental modes. Capturing should be fast and low-friction. Thinking should be slower and more structured. When both happen in the same place, everything becomes work, and real thinking gets buried under raw inputs.

A simpler approach is to let tools specialize:

• Use a lightweight tool for quick capture — links, references, snippets
• Use a thinking space (Obsidian, docs, writing tools) for deeper work
• Move material only when it proves useful

Simple systems you actually use will outperform complex all-in-one setups that require constant discipline.

Most developers don’t have an organization problem. They have an unfinished-input problem. And once you accept that most things you save are disposable, your knowledge system becomes lighter - and far more sustainable.