I’ve been thinking a lot about planning lately. I realized I’ve fallen into the same trap many times, and understanding the root cause has made all the difference.
My first impulse was always to over-organize. I’d create a neat system:
- I'd create a separate folder and file for each family of tasks (e.g., "Work," "Personal," "Learning"). It felt great at the beginning—so structured! But after a few days, it became a hassle.
- The same feeling occurred when I tried building a complex goalscape, with first-level goals for task families, and then another level of goals for each individual task.
In both cases, I was creating a system that demanded too much energy just to maintain.
***
I was unknowingly introducing an unnecessary dimension to my planning.
When I used multiple files, it felt like I was generating a final complexity of N x M, where N is the number of files (or task families) and M is the total number of tasks.
***
Then, I tried the opposite: one single file.
In this file, I created a section for each task family, and a simple Table of Contents (ToC) at the beginning. Each task lives in its relevant section.
Immediately, the system simplified. By removing the file-switching dimension, the complexity was converted to a simple line: M, the total number of tasks.
***
This is exactly like when I analyze code.
If I am analyzing a method x() with N lines, and it calls another method y() with M lines, it’s easy to get lost by constantly jumping: analyze a line in x(), then go deep into y(), then jump back to x(), and so on.
The better approach is to stay at the level of x(), or finish analyzing y() completely, but you must avoid the inefficient back-and-forth.
