The more I work on myself, the more I realize that the first step for me is almost always to just notice I’m stuck in a loop.
As a teenager, I didn’t make progress towards getting good at anything because I was stuck in the following loop:
Decide X is my passion
Go all in for X, think about it all the time, redirect all my energy towards it
After a variable amount of time (weeks, days, hours…), start worrying that I’m actually wrong, and that Y is actually much more representative, much more meaningful, much more “right”
Feel worse and worse about doing X instead of Y
Go back to step 1, but this time with Y
Solutions just jump out when casting the issue in this compress form: I might decide on just one thing and not change, to not get trolled by opportunity cost; I might notice that I jump between the same 3⁄4 things, and then schedule between them explicitly; I might notice the similarities between all things I feel “passionate” about, and go for the unified underlying thing.
Yet the actual issue on the ground is in noticing the loop. Because when you are in it, it doesn’t feel like you’re looping — it feels like you’re making progress. You can see the change, you can see yourself moving, you know deep down that this time this is the one.
So the interesting question is: What methods can we use to detect we’re in a loop?
If we turn to cycle detection algorithms in CS, they all share the same core ingredient: memory. More precisely, every cycle detection algorithm is a variation on the following two steps:
Remember where you went
Regularly check if you have already been where you are now
I know two complementary ways of doing the first step: taking notes and complaining.
When you take notes, you literally make a mark of what you thought and felt, that you can then check later on. This is the direct counterpart of annotating edges of a graph in a cycle detection algorithm.
Complaining meanwhile does the same thing, but it embeds it in the extended cognition you share with other people. That is, if you complain to your wife/husband/best friend/mom about something, and they genuinely give a shit about you, they will probably remember it.
But the social aspect is in my opinion much more useful for the second step: actually checking if you’ve been there before.
Because even if you take notes, it takes discipline to regularly go back, and look for signs that you already felt that way before. Whereas your friends and family will start being frustrated with you complaining about the same thing again and again, and then will tell you about it.
For they are not in the loop; they don’t experience it. Which means it’s often painfully obvious to them.
Most of the big loops in my life, the ones that really sent me rolling again and again, I realized their existence from my wife and friends. From their pushback against me doing the same thing for the tenth time. It can be frustration, it can be making fun of me, it can be sitting me down and being like… man, are you noticing that you’re always doing that?
Of course, the difficulty here is in actually listening. I have many defaults and failings, but at the very least, after I get pissed and annoyed and frustrated by pushback, I generally listen. And that’s of the essence: if you take notes or complain, but then never read back those notes or listen to the social feedback, you can’t detect the loop.[1]
And if you don’t detect the loop, you can’t escape it.
- ^
Maybe one of the virtues of therapy/coaching is that because you’re paying your therapist/coach, you’re slightly more likely to listen to them when they point out those loops.
Your loop example at the top (Decide X is right, Go all in for X, start worrying that Y is actually better than X, switch to Y, repeat) is very close to how I would describe a very healthy process of iteration / pivoting.
I guess it depends on if you’re pivoting based on things that you’ve learned, versus grass-is-greener.
For example, I’ve mentioned that AGI safety was the 5th long-term (i.e. multi-year) intense ambitious hobby of my life, then turned into my job and I’m in it to the end. All the switches made sense, given what I knew at the time. Glad I didn’t “get unstuck” from the “loop” when I was on my 3rd or 4th hobby. :)
Yeah, I didn’t mean “iterative thoughtful processes”, I meant “compulsion that unfold at the level of days”. If you arbitrarily change your job every couple of days/weeks, not based on new significant information but because you feel this other one is the one, this is bad.
So there is a vibe here that I maybe didn’t convey well, about the time frame and the auto-generated part of the loops I’m pointing at: it happens often enough that your friends and family can notice, and it happens in reaction to events that no one around you agree would lead to such a drastic change (highlighting that the events are not so much the cause as the post-hoc rationalization).
I have a TAP that’s like
Notice that I’ve been cycling through some things.
E.g. I open some habitual browser tabs, glance at some, close them, and then reopen the same set of habitual tabs.
E.g. in a programming project, I open some file and read a bit, then switch to my notes file, then switch to another file, try to think about what to do next, get confused, open the first file again...
Internally yell “LOOOOOOOOP!”
Consciously think about what to do next.
The step of “internally yell LOOOOOP” seems silly enough that it just might work. I’ll try adding it to my own reaction; I’m presently at a level where I’m moderately skilled at noticing loops but I don’t yet reliably connect that awareness to a useful behavior change.
Oh nice observation! I hadn’t thought of complaining as a way to externalize the detection of blindspots, but that makes a lot of sense.
This also reminds me of “You should complain about it”, which also talked about complaining as a way of creating common knowledge about problems, but for a group:
While this is almost certainly not relevant to any real life metaphorical application of loop detection, I’ll just go ahead and mention that there is a very common cycle detection algorithm in CS that goes like:
Keep two “pointers”. Move one a single step at a time. Move the other two steps at a time. If they are ever equal, then you’re in a loop.
This avoids the need to remember all previous steps, but it doesn’t really seem as useful in the metaphor.