The text file of things I don't understand yet

Somewhere on my laptop is a plain text file called, unglamorously, dont-know-yet.txt. It has no categories, no priority column, no tool behind it, just a running list of small things that came up during a working day and turned out to be something I only half understood, or fully didn’t. I’ve kept some version of this file for a few years now, and it’s quietly one of the more useful habits I’ve built, not because any single entry on it is important, but because of what the file itself does to the moment right after you notice a gap in your own understanding.

What actually ends up on the list

The list is a lot less impressive than it sounds. A recent handful of entries: a teammate mentioned “the write-behind cache” in a meeting and I nodded like I knew exactly what that meant, when what I actually had was a vague sense it was a caching thing, adjacent to write-through, and nothing more specific than that. Another entry: a config flag in a Terraform module set to true that I’d copied from an existing module two projects ago, without ever actually checking what it did, just trusting that whoever set it originally knew what they were doing. A third: someone referred to “the outbox pattern” assuming everyone in the room already knew it, and I wrote down the phrase exactly as I heard it so I wouldn’t misremember it by the time I got around to looking it up.

None of these stopped the meeting. That’s the entire mechanism the file exists to support: the moment you notice you don’t fully understand something is almost never the right moment to stop everything and go learn it, you’re mid-meeting, mid-incident, mid-focus on something else entirely, and derailing that to chase a tangent is usually the wrong tradeoff. But if you don’t write it down, the honest truth is you don’t go back and learn it either, the small discomfort of not knowing fades within the hour and the gap just quietly persists, sometimes for years, resurfacing every time the same term comes up and gets nodded through again.

What the batch-clearing actually turns up

Every couple of weeks I go through the list and actually resolve a handful of entries, usually five or six at a sitting since that’s about how many accumulate. Some of them are almost embarrassingly simple once looked up properly, the write-behind cache thing turned out to be exactly the adjacent-to-write-through concept I’d vaguely guessed, five minutes of reading confirmed a hunch I’d been too rushed to confirm in the moment. The Terraform flag was more interesting: it turned out to disable a safety check that made sense in the original project’s context but genuinely didn’t apply to the one I’d copied it into, and nobody else on my current team knew it was there either, so the file didn’t just close a personal gap, it surfaced a small real risk that had been silently copy-pasted forward through two unrelated codebases.

That second kind of find is why the batch-clearing matters as much as the writing-down. A list of things you don’t understand is only mildly useful sitting unread. It’s the periodic pass through it, actually looking things up with full attention instead of the half-attention available mid-meeting, that turns vague discomfort into either a confirmed non-issue or an actual finding worth telling someone about.

Why this stuck when a one-time resolution wouldn’t have

I’ve tried the other version of this, the New Year’s-resolution style commitment to “understand things more deeply,” and it never lasted more than a week, because it demanded the impossible: stopping in the moment, every time, to go learn something properly. That’s not sustainable against a normal working day’s actual pace. What made the file version stick is that it split the habit into two much smaller, much easier actions: noticing you don’t know something takes five seconds and one line in a text file, and actually resolving it happens later, in a dedicated batch, when there’s real attention available for it instead of borrowed attention stolen from whatever you were supposed to be doing.

It’s not a sophisticated system. It’s a text file and a habit of glancing at it every couple of weeks. But most of what I’ve genuinely learned on the job in the last few years traces back, in some indirect way, to something that first showed up as a single unglamorous line on that list, written down instead of quietly forgotten the way it would have been otherwise.