Are "Bullshit Notes" Killing Your Focus!?
We Need A "Knowledge Janitor" To Prune Dead & Revitalize Mismanaged Notes
As a software engineer, I often find that concepts from my professional life spill over into how I handle personal affairs—or at least they get me thinking. Recently, I started wondering: What would a “garbage collector” for notes look like?
I.
For a computer to do practically anything, it must first load data into memory (RAM). This memory is limited, so programmers must ensure that they only load what’s necessary and, just as importantly, clear out what isn’t needed anymore. Otherwise, unused data will build up as useless and wasteful residue. Worse, uncleaned memory can eventually slow down our program as well as everything else on our system.
In the early days of programming, software engineers had to manage memory manually. This was tedious, error-prone, and, most of all, pretty annoying. Thankfully, this became less common with the invention of programs that automatically clear out unused memory.1 We call this “garbage collection” because this unused memory is just sitting there, not serving any purpose, just like garbage.
This got me thinking: empty notes created by accident, duplicate tasks, or obsolete files — we all have at least some obvious garbage lurking in our personal accomplishment systems. But that's only a tiny part of what could be called garbage. For the most part, we navigate the gray area of dubious value: a note that’s little more than a snippet copied from Wikipedia, a pro forma task already lodged in your mind, or an obscure PDF in the depths of your “read-later” pile. While these things may have some value, they are so minuscule that they are probably not worth keeping.
So the question is: Could a similar tool be helpful in personal productivity and PKM? Are we in need of a knowledge janitor?
II.
Imagine a collector of garbage tasks—those that have lingered in your task manager for years but haven’t been addressed. A few years back, I created an extensive list of 22 types of pseudo tasks — many of these can be considered garbage. So, this would be a great starting point for building a task artifact janitor.
Or consider a tool to identify stale files in your file system. With AI more accessible than ever, these ideas might not seem as far-fetched as they once seemed. I believe that file janitors will eventually be commonplace.
Our personal knowledge companions (PKCs — one’s main notes app for PKM & PKB) are undoubtedly also in need of an upgrade. With PKCs taking on the role of the knowledge janitor, we could finally drop the shackles of “second braining” and embrace the fact that our note apps can and will play a more dynamic role in the future. This could be the step in turning them more into autonomous agents.
I’m not one of those cloud-headed AI fanatics who think AI will be the end-all of everything. Some things will be beyond our reach, quite likely forever. A tool can’t tell if you’ve memorized the contents of a note, making it redundant, or if a task is so apparent and “mentally visible” that it’s already handled.
However, certain functions are realistic, and we can build them today, like setting pruning or reviewing rules based on when something was last created or modified.
In many cases, the last time we touched an item, it said a lot about its usefulness. A note or task untouched for 12 months or so might warrant a quick review. There are caveats, of course: journal entries often gain value over time, and essential files, like certificates or legal documents, should never be pruned. So, while time is a strong indicator, there’s still the question of which items should be targeted.
III.
To keep things focused, I’ll stick to digital notes for the remainder of this essay.
With a good organizational system, it’s fairly easy to narrow down which files a knowledge janitor might target. In my PEAKER setup, at least, it was surprisingly straightforward. If I had a garbage collector, I’d let it focus on the org space called The Keep, the K in PEAKER. The Keep is a lively, chaotic zone for ideas, interesting facts, and random thoughts. Unlike the other, more structured org spaces in my system, The Keep doesn’t contain essential records like certificates, log files, or journals. There are no active project materials, templates, or anything else that defied time as a qualification criterion. Instead, it’s an unstructured catch-all, a doom box, an incubator, a breeding space for knowledge clusters, a riot against folders. The Keep isn’t intended to be pruned by hand anyway. So, in short, it’s the perfect scope for a garbage collector.
Combine this with the abovementioned time frame of around 12 months, and we have something that could be prototyped. So, last weekend, I decided to give this idea a test run. I ran a quick query in my Obsidian vault, and here are the honest, unstaged results I got.
As expected, quite a few notes needed cleaning up…
IV.
A couple of the notes the proto-janitor found were pure dead wood—empty, duplicated, obsolete, or containing random gibberish—so I deleted them instantly.
Several notes were misplaced, mistitled, or mistagged, while others were poorly managed and, therefore, unlikely to resurface when needed. With just a few keystrokes, I fixed, moved, or re-tagged these and fed them back into my knowledge cycle.
A few notes were “orphaned” or lone wolves, holding unique content but not well-connected to anything else. So, I merged their contents into related notes where they’d have a better chance of resurfacing when needed.
Then, there was the big “gray area” of notes with questionable value, like snippets copied from Wikipedia. These required case-by-case decisions on whether to keep, merge, or discard.
Additionally, none of these notes lived up to my current standards—no default metadata, outdated formatting, etc.—so I took the chance to reformat them. With the Obsidian Linter plugin I use, this was a quick, single-keystroke fix per note.
All of this took me about 20 minutes, including setting up the query and cleaning the notes. It felt good to declutter, and, more interestingly, I uncovered a few forgotten ideas, adding some notes to my writing workbench as possible future essays. The next time I look at my query for the oldest notes, it should take even less time.
Overall, this exercise was a solid prototype of what a garbage collector could target—and how it could work. But with virtually unlimited disk space, you still may wonder: Why do this at all?
V.
The problem with stale notes, tasks, and files isn’t so much about them taking up memory, like in the garbage collector analogy. Instead, these outdated and unused items clog up our mental bandwidth. Like RAM limits computers, we are bound by a mental WIP limit, determining how many things we can consider simultaneously. This is why any digital clutter that doesn’t need to be there can be considered “noise” — noise that drowns out the valuable signal within each of our repositories.2
Bullshit tasks distract from real work.
Bullshit notes lead us down the wrong paths in The Forest.
Now, the usual recommendation is to “capture less” and be more discerning about what we let into our system in the first place. But frankly, that never worked for me, so I devised another tactic: keep everything that even remotely sparks but feed it a contained “safe space” where the potential downsides of having are mitigated. In PEAKER, The Keep takes on the role of this safe space (among others).3
So, garbage collection in our system isn’t about saving disk space; it’s about clearing out distractions and refining focus. Resurfacing old ideas and updating notes to current standards are a bonus, but the real value lies in reclaiming the signal from the noise.
Some people might see red flags here. They don’t trust AI and automatism. They might argue that this can be done opportunistically and manually upon encountering dubious notes. And that is true. I also usually favor manual workflows over automation, as long as I’m not 100% sure the automation will work and is actually the right thing to do. However, manual workflows also have the downside of accumulating small mistakes. So, the idea of a garbage collector would be an addition to opportunistic cleanup. The stale notes the knowledge janitor would target are precisely the kinds of notes you wouldn’t re-encount by coincidence, as they are obviously “hard to reach.” They are either orphaned, wrongly categorized, titled, poorly-linked, or some combination of these. An as-needed strategy won’t work here.
VI.
So, where does this short experiment and idea leave us?
Assessing the quality of a note is where the beef is to be found. Beyond some trivial cases, such as empty notes, duplicate tasks, etc., an AI alone can’t determine a note’s relevance, so manual interventions, to some extent, are inevitable.
One idea for a hybrid solution I had came from the “spaced repetition” folks. Only, instead of periodically prompting us for recall, we would get asked whether to keep, archive, or delete a stale item.
Also, even for the obvious cases, the thought of automatic deletion might make some of you uneasy. So instead of deleting items immediately, the garbage collector would move them to a “Selected-for-Pruning” folder—a sort of waiting room—where you could retrieve them if needed but where they are “out of the way.”
In my personal setup, garbage collection could start as a simple script or an Obsidian plugin with configurable options for scope and timing. After working with my prototype for a while, I might investigate that.
What do you think?
Would a tool like this lighten the load on your knowledge system?
Of course, this is a problem of scale. If your note base has 100-200 notes, you probably won’t need it.
But I’m curious: How could you see it fitting into your own workflow?
If you enjoyed this essay, you should also check out:
As a side note, garbage collectors weren’t perfect. Newer programming languages have moved on to even better memory management approaches, such as automated reference counting (ARC) and borrow checking. But “garbage collection” makes for a better analogy to highlight some ongoing maintenance that moves quietly and consistently in the back without diving into the complexities of memory ownership or reference tracking. So, I’ll stick with that here.
As a straightforward illustration of our cognitive WIP Limit, you can try the following: in the following text, without counting, guess on which line number the string “ante ipsum primis“ appears:
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Mauris finibus massa massa, fringilla molestie enim feugiat et. Interdum et malesuada fames ac ante ipsum primis in faucibus. Sed neque tellus, dignissim quis mattis a, tristique eu dui.
Pretty easy, right?
Now, guess the line number of “Nunc sed tincidunt”:
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Mauris finibus massa massa, fringilla molestie enim feugiat et. Interdum et malesuada fames ac ante ipsum primis in faucibus. Maecenas dapibus tristique diam, sit amet semper ex aliquam quis. Sed ac arcu in augue dignissim sagittis. Nunc sed tincidunt neque. In semper egestas laoreet. Proin pellentesque sem ornare orci sodales, ac elementum mi tempus.
Maybe you also got this right, but chances are you couldn’t get much further than that.
Granted, a person following this strategy may end up with more garbage than the one who diligently and precisely guards what is captured. But as I’ve written elsewhere, this is ultimately the better approach for me. Besides, even if you are the kind of person who captures selectively, your system won’t ever be free from garbage. The only benefit you’d have is that the garbage collector yields fewer results. But it might still be helpful.