# Freewriting in my head, and overcoming the “twinge of starting”

The empty cache problem
-----------------------

I used to be terrible at starting on even moderately complex tasks.

I was okay while “in the zone” in something, but if I had to start anything that involved reading any significant length of notes… I would be tempted to scroll Twitter first and waste 10 minutes. Even without any distractions, I’d feel quite uncomfortable. It wasn’t pleasant.

This happened even when I was restarting a task, even when I had taken notes to “help” remember the important things. Why didn’t that help?

I eventually realized it wasn’t that I didn’t have enough information; it was that the information wasn’t in my mind. It wasn’t in my working memory, my “mental cache”. I’ll call this the **empty cache problem.**

The challenge was how to reliably get from having the *idea* of a thing in my mind, to having enough *context* in my mental cache to start making progress and overcome the [twinge of starting](https://www.lesswrong.com/posts/9o3QBg2xJXcRCxGjS/working-hurts-less-than-procrastinating-we-fear-the-twinge).

I’ve found one particular approach to be particularly effective for myself: “freewriting in my head”.

Compared to alternative methods, of which there are many, this “freewriting in one’s head” method is relatively simple, it is very flexible, and it can be carried out anywhere. In this post, I’ll describe the basic logic of the method and the key rules of thumb that make it effective for me.

Force filling my brain
----------------------

To effectively orient myself to a task, I “freewrite in my head” (or “cogitate”) by challenging myself to **mentally generate a stream of relevant words** about the topic.

The basic idea, generating a bunch of words in order to think, is not novel. It exists in the time-tested practice of *freewriting*, is implicit in all writing, and exists as well as in more recent ideas like language model chain-of-thought. The main novelty is the *medium* — one’s mind — and the rules of thumb that I’ve found to be important for getting a good result.

The basic logic behind “freewriting in one’s head”:

*   Your mind has a cache with a large number of slots, and you need to populate it.
*   Every new thought populates one slot.
*   Every time you think of a new word represents a new thought.
*   So, thinking of many relevant words will automatically populate your mental cache with relevant thoughts. And if you think of relevant new words *at a high rate*, you will populate your mental cache quickly.

Of course, the devil is in the details. How can you think of relevant things? After all, this is the problem you’re facing in the first place; it’s the whole reason you feel stuck.

For concreteness, let’s consider the following example task:

***Ticket: Prohibit access for certain users in a certain novel edge case.** (Plus many details that would realistically be present but aren’t necessary to illustrate the method.)*

(Assume that you have thought about many of the details before — it’s not a research task — but it’s been a month since you have worked on the area, and you now only have a fuzzy idea of what you need to do.)

I’ll lay out the “mental algorithm” step by step:

*   **Start** with the bare pointer to the task in your mind.
    *   Optionally: skim the notes/text and pick out a few key words
        *   “Multi-team user”
        *   “Authorization service”
*   **Repeatedly think of relevant words.** Examples:
    *   Basic concept words (the more the better)
        *   “Service”
        *   “User”
        *   “Groups”
        *   “Roles”
    *   Specific objects (the more central the better)
        *   “The status page”
        *   “The endpoint the admin page uses to fetch”
        *   “AdminDashboard.ts”
        *   “User information”
        *   “Folders, which affect permissions”
        *   “OpenFGA”
    *   “Breakdown” words (the more basic the better)
        *   “Lifecycle”
        *   “State” (of users etc)
        *   “Schema” (of permissions etc)
        *   The idea is to make yourself enumerate what you already know about these things.
    *   Questions (ideally asking about something fundamental but concrete)
        *   “Where in the stack” (should I change)
        *   “Source of permissions ultimately”
    *   Naming the relationship between previously thought-of concepts
        *   “User” + “properties” -> “schema”
*   **Pump words hard** through your mind, working at a substantially faster rate than is comfortable.
    *   Resist the urge to “ponder” a concept for a long time, holding it inert in one’s mind and merely “rotating” it; it’s not productive. If it’s truly important, instead try to explicitly name a relevant aspect of it as fast as possible.
        *   Idea: Like a language model unrolling a chain of thought, naming a thought is how you make it available for building on.
        *   This might be obvious to you; it was not obvious to me, nor was I ever taught that this is bad. To me, “thinking about something” meant I held the “something” in my head. I was not taught how to think about things in my head, nor even how to think about something in this way on paper.
            *   It’s basically the *opposite* of “meditating” on an idea.
    *   To me, it *feels much more effortful* to try to think of words than to just hold a question in my head. This is not bad; it is precisely this effort that lets you devise a concrete next action that you can do!
*   **Build on previous words** that seem important; with enough words built on each other you’re bound to end up with a highly specific idea.
    *   As you think of more words it “magically” becomes easier to know what is important
*   **Stop** once you think of a concrete next step.
    *   **The idea:** It’s always better to get real information or make definite progress than to overthink. The “cogitating” is just to get you to that point.
    *   In a programming context:
        *   Wanting to look up specific information in the codebase
        *   Wanting to do a specific test
        *   Realizing that a certain task needs to be done first
    *   In a professional writing or project-work context:
        *   Realizing that a certain point should be emphasized
        *   Realizing that you should ask someone about something specific
    *   In a creative context:
        *   Having a specific idea for how some aspect of the work *should* be

How it feels
------------

When I’m doing this, I feel strong *pressure*, like I’m being pushed by someone who is running and I need to keep moving, keep moving. The pressure is strong but not unpleasant. It’s the opposite of relaxing, but it gets a lot done.

If I am generating words at a high enough rate, I feel totally immersed in the task, as I don’t have the mental space to be thinking about anything else.

Tips
----

*   If feeling stuck, aim for an easier word (e.g., just name something specific that you know; in a software context, this could be some specific attributes or relations of a known object)
    *   Targeting a roughly constant rate of words
*   If things feel trivial, aim for words that represent purposes or problems (i.e., higher-level concerns) or higher-level tasks (what larger task something is part of)
*   It can be surprisingly helpful just to name the high-level kind of thing that something does (i.e., “authorization”)
*   Prefer to generate “heavier”, higher-information phrases (but not at the cost of getting stuck)
    *   Examples of “light” phrases:
        *   “Task”
        *   “User”
        *   “Requirement”
    *   Examples of “heavy” phrases:
        *   “API endpoint definitions that have a @requires_authz decorator”
        *   “What Prem said on Friday”
*   If you have been distracted by something else, it can be very helpful just to generate trivial words related to the task you want to focus on. Even trivial thoughts, as long as they are somewhat related to the task, will occupy your working memory and “evict” whatever was in your mental “cache” before, and you will naturally stop thinking about it.
    *   I find this sort of “active cache eviction” to be much more effective than just telling myself I want to focus on something.

Illustrative transcript
-----------------------

For the same example, here is what might actually go through my mind:

*   Forbid
*   User
*   Types
*   Pages
*   Actions
*   Checking
*   Data
*   Roles
*   Error codes
*   Copy (words)
*   Message
*   Object state
*   Ownership
*   Test data
*   Roles
*   Readonly
*   Realistic?
*   Fixtures?
*   How did it get in this state
*   **The stopping point: What if I wrote a test fixture and test for the basic case where the user has readonly access?**

Notice that we did this exercise without needing to have any access to any of the nuances of the task in working memory. This was a made-up task description for which no details actually exist!

Related ideas
-------------

Two closely related ideas to “cogitating” are *freewriting* and *morning pages*. I am basically saying that you can do freewriting in your head, sometimes even faster than on paper. The commonality is that you try to think of a lot of relevant words sequentially, in hopes of eventually coming to a meaningful realization.

“Cogitating” is complementary to writing. Thinking in your head is faster, and can be done even while (say) standing outside or in the shower. Once your mental cache is reasonably full, though, it absolutely makes sense to transfer your thinking to a written medium.

Benefits that I’ve noticed
--------------------------

**On tasks:** The big benefit I get now is that I rarely feel dread when restarting a complex task. It is my go-to method for starting work when I don’t immediately know what to do. (Though when I have access to paper or a computer document, I often freewrite instead, following similar rules of thumb for what to think of.)

**On teams:** The same basic idea has helped me un-jam a number of team meetings, especially ones that I didn’t organize. The “empty cache problem” exists in groups as well — there’s a meeting about something, and it seems like no one is talking. It can similarly be overcome by prompting the group to recall a bunch of stuff. Usually all it takes is a few simple questions like “what is this” or “what is this for”. It’s even easier in a group than by oneself, because the pool of knowledge that can get dug up is much larger.