We are at the start of a cambrian explosion of creativity and problem solving, and after you've read this post you'll understand why and you'll be ready for it. The reason for this explosion is that through the incredible work by RoamHacker and Dharam Kapila, there is now an extension for Roam Research that makes native, dynamic algorithms of thought a reality.

Algorithms of Thought

Big words in the last paragraph, so let's step back for a second. What is an "Algorithm of Thought"? You might be more familiar with the term Mental Model, and the two are closely related, but different things. Mental Models are descriptive, they describe the state or behavior of a phenomenon by way of analogy. You've probably heard something like "Startup X has reached critical mass in terms of users and is now growing like crazy". Critical mass is a term originating in physics, where it describes "the smallest amount of fissile material needed for a sustained nuclear chain reaction". In the example above, it's used as an analogy to describe the state of the startups user base.

What Mental Models typically don't do is tell you how to think through a problem. They are static - the describe the state of things and when you contrast them they can tell you the differences between to things…but they don't tell you how to get from A to B. That's where Algorithms of Thought come in.

Broadly, algorithms are well-defined sequences of steps you go through to solve a particular task. If you want to find the largest number that divides two other numbers without a remainder, for example, you would use Euclid's Algorithm. Algorithms of Thought are procedures to think through a problem or situation and solve it.

But Algorithms of Thought extend beyond math or computers, you can see and use them everywhere in life. Maybe you're familiar with the term "Post-mortem" as applied in the business world, or "After Action Report" in the military. Both of these describe the same idea: that after an event, you go through and examine it to see what happened, compare it to what you wanted to happen, and what to do so the mistakes that occurred won't occur again. That's an Algorithm of Thought.

Notably, these don't have to consist of the exact same question. Naturally, the post-mortem of a product launch will look different than the after action report of a hostage extraction from a ship. But the approach itself is still an algorithm – a defined sequence of steps you go through to arrive at a particular result or end-state.

And Algorithms of Thought come in much smaller sizes than product-launch post-mortems of hostage rescue after action reports. Every time you make a decision you're running a (likely subconscious) Algorithm of Thought.

In my first article on Algorithms of Thought, I described how Conor White-Sullivan, Co-founder and CEO of Roam, makes decisions or how some people think about getting what they want by listing impediments and remedies.

Algorithms of Thought are powerful, but they are hard to learn, and I would even say that they are harder to learn than many physical skills. The reason is that it's easier to practice physical skills because their use is easier to trigger.

If you're learning to play the guitar, sowing, or fencing, you typically have a place and time that you do them, and you have the tools that you use for the activity that can trigger the right behavior in the moment.

But let's say you want to make better decisions and every time you decide something beyond "what's for breakfast" in complexity you want to explicitly consider all your options and compare their advantages and disadvantages. How do you train yourself to do that? In my experience, learning new thought patterns is quite difficult, for the reasons I gave above. But in addition, I think one challenge is that we often suck hard at memorizing things, especially multi-step sequences that don't involve physical activity. Memorizing independent words to expand your vocabulary? Relatively straight forward, even though it requires work. Reciting long poems? Much harder, for most people.

And these examples are static - what happens if you have to memorize multi-step, dynamic sequences where the decision in step A determines you choices in step B? You quickly end up feeling like a lawyer studying for the bar exam. Not very useful or fun for most people.

In my previous post on Algorithms of Thought I shared how I solve this through the use of text expansion tools like TextExpander. I type a short sequence of letters, and I get a well-defined list of questions to ask myself or things to do to solve my problem. That solves a big part of the memory issue. I still have to have the mindfulness to say in the situation "hey, I should use this algorithm here", but that's considerably less work than memorizing a whole list of things and then typing it out. So that's great.

But what this doesn't solve yet is the dynamic part. Asking myself different questions depending on what I answer in a previous one.

Luckily, this is changing now and I predict we're going to see a whole new level of collective and creative thinking around improving thinking itself because of it. What is changing?

One of my favorite Roam Research extensions has gotten a new feature that's making dynamic Algorithms of Thought at the touch of a button a reality. As I write this the functionality is still in beta, but I've had the privilege to test it the last couple of weeks and I've been completely blown away. If you install the beta version of Roam42 through this link, you can experiment with this feature yourself: SmartBlocks.

SmartBlocks are incredibly powerful and do many more things than implement Algorithms of Thought. In the following, I'll focus on the functionality that's necessary for getting started building your own algorithms. The full documentation for SmartBlocks is available here.

Getting started with SmartBlocks

Once you've installed the beta version of Roam42, you trigger smartblocks by typing ;; (two semicolons), which pops up a list with available SmartBlock actions. You select one by typing the name of the action you want, which will filter the list of available actions, and then clicking or hitting enter on the right one.

If you want to create a new SmartBlock action yourself, you

create a block that starts with #42SmartBlock, followed by the name you want to give the action.
indent under it new blocks - anything you type in these blocks will be entered when you execute the action

For example, let's say I wanted to create a simple template for when I make a choice. It could look like this:

A SmartBlock doing that could look like this:


#42SmartBlock Decision
  TODO Choice:
    Options:
    Decision::

Awesome, that's super useful already. You don't need special tools like TextExpander, you can use this inside Roam. But SmartBlocks can do way more, so let's have a look at that.

Fighting Procrastination with an Algorithm of Thought

What if you wanted to find a way to fight procrastinating? There's an algorithm for that.

One of the most common problems that cause procrastination is that the next step is unclear. If you don't know exactly what to do next, your mind often starts wandering around and suddenly you find yourself doing things more pleasant than thinking about what to do next.

A way to fix this is to explicitly ask yourself "what the first/next step" – my friends at Ultraworking use this in their Work Cycle template, and Matt Goldenberg teaches it in his course on fighting procrastination.

Let's build this into an Algorithm of Thought you can use at the touch of a button: all you'll have to do is type ;;na and it will guide you through the algorithm.

Here it is: (Note that I've switched the trigger from typing ;; to @@ - you can ignore that)

Now, the SmartBlock:


#42SmartBlock Next Action
 <%SET:NextAction,<%INPUT:What's the very next action? (Type "I don't know" if you don't know%%I don't know%>%><%NOBLOCKOUTPUT%>  
 What's the very next action?  
   <%IF:"<%GET:NextAction%>"=="I don't know"%><%THEN:Do a 3min brainstorm to come up with steps {{POMO: 3}}%><%ELSE:<%NOBLOCKOUTPUT%>%>
   <%IF:"<%GET:NextAction%>"!"="I don't know"%><%THEN:<%SET:DidSimulate,<%INPUT:Simulate <%GET:NextAction%> mentally. Type "yes" when you've done so.%%yes%>%>%><%NOBLOCKOUTPUT%>  
   <%IF:"<%GET:DidSimulate%>"=="yes"%>
<%THEN:<%SET:CanDoNow,<%INPUT:Can you do <%GET:NextAction%> right now? Type "yes" if you can.%%yes%>%>%><%ELSE:Please start again%><%ELSE:<%EXIT%>%><%NOBLOCKOUTPUT%>  
   <%IF:"<%GET:CanDoNow%>"=="yes"%><%THEN:{{[[TODO]]}} <%GET:NextAction%>%><%ELSE:Think about the context in which you can do <%GET:NextAction%>%>

Woah, that looks scary! But it isn't really. Let me walk you through it.

Once you've activated the algorithm through the SmartBlock action, it asks you what the very next action is.

If you don't know, it tells you to do a 3 minute brainstorming session and includes a helpful 3 minute pomodoro timer.

If you do have a next action, it asks you to explicitly simulate in your head doing that action and then whether you've done so. If you did simulate it in your head, it asks you whether you can actually do that action right now. If you are able to do the action, it creates a TODO item for you. If you can't, it asks you to think about the context in which you can do the thing.

Let's take a step back here and consider how powerful this is. To train yourself to follow these steps automatically without any guidance takes some serious effort. Not only do you have to recognize that you should go through these steps, but you have to remember and then bring up the mental energy to actually do them, depending on where you are in the decision tree.

Now, with this algorithm, you still have to remember to run it, but then all you have to type is ;;Nex and Roam42 will bring up the action in its popup menu and walk you through it.

To me, that's incredibly powerful and awesome, because it frees up a whole portion of my brain and saves me a lot of mental effort I can now spend elsewhere.

The future of Algorithms of Thought

Now, is this perfect? Are we "there" yet? No, absolutely not.

The algorithm I shared is rather simple, the SmartBlocks feature is just entering beta testing as I publish this, there are loads of kinks to be ironed out and this isn't a native feature of Roam yet.

But.

If you've gone ahead and installed Roam42 and set up the algorithm above in your own graph – think about what just happened. I transmitted mental software over the Internet. If you find the algorithm useful, you can now use it, forever, without any more training. If you don't, you can adjust it to your needs, and then publish your, better, version for others to use. Or to keep it to yourself, your own trade-secret.

On Twitter I wondered the other day what would happen once these algorithms were widespread. Would people share them freely, like open-source software? Would people try to patent them and issue cease and desist letters against those who "infringed" on their intellectual property? Would there be secret sharing clubs, where people traded the "best" Algorithms of Thought?

Who knows? But as I said in the beginning – I think we're at the start of a cambrian explosion here. As mental patterns become easily transmittable between people, as it becomes easier to write and externalise them, we'll see new forms of thinking emerge. When the invention of script let us externalize and carry through time our words, the world changed profoundly. What will happen when we can do the same to the way we think?

If you're interested in learning more about Algorithms of Thought, I have a course that deals with them called Galaxy Brain. The first release was way before SmartBlocks came along, so it's not fully up to date in that regard. But I do plan to release an update covering that functionality soon (hopefully before Christmas, but might turn into January. It's still 2020, who knows). So if you're curious, you're welcome to check it out or sign up for my newsletter here so I can email you once it's updated!

Articles on Roam42