Trick Your Brain to Stop Procrastinating by Creating Microtasks

Every programmer I know, myself included, has suffered from procrastination. It is, indeed, a major problem that plagues the profession.

Sometimes the desire to procrastinate occurs in the most surprising circumstances. It could be that programming is all you have ever wanted to do. Or you could be working on an extremely exciting project that you can’t stop thinking about while you are away from your computer. Still, when the time comes to get some actual programming done, you can’t help but browse the web or do some mundane admin tasks instead.

When these situations occur, you may start thinking that programming has lost its appeal to you. You may even think that you have chosen the wrong profession to begin with.

This might be true; however, it’s not necessarily the case. There is one major reason why you might procrastinate even when you are engaged in the activity that you truly love—the perceived size and complexity of the task ahead of you.

When any given task, especially if it’s mentally demanding, seems to be too large or too complex, your body starts doing everything it can to get you to avoid the work. And there is a good biological reason for that.

While the brain occupies only 1/50 of the body mass, it can use up to 20 percent of all energy available to the body. Therefore, the physiological processes inside our bodies try to conserve as much energy as possible by trying to steer the brain away from the tasks that are too demanding.

It’s similar to why it’s so easy to gain weight and so hard to lose it. Our bodies evolved in an environment where food was scarce, so conserving resources and creating reserves are still some of the most fundamental driving factors of our subconscious behavior.

However, there is a fairly easy hack that you can perform to trick your brain into thinking that a task is extremely simple, regardless of its real complexity. Split the task into many ,microtasks, and focus on one of them at a time.

What Are Microtasks?

You may have heard the the following expression:

“How do you eat an elephant? One bite at a time.”

And this perfectly summarizes the idea of microtasks.

The notion is not new. The idea of avoiding procrastination by splitting a large project into smaller ones has been proposed by many productivity gurus. It has even been mentioned on Simple Programmer. However, there are situations where this idea doesn’t go far enough.

For example, if you want to become a full-stack developer without having any prior programming experience, you may be told that you should learn front-end first and not touch any other technologies until you have gained sufficient competence in this one. But, as any front-end specialist will tell you, learning front-end is an enormous task in itself. Chances are you will still procrastinate or even give up on the endeavor completely.

This is where the concept of micro tasks comes in. In the example above, splitting the project of learning the entire stack into several smaller projects is certainly the right first step. However, after that, each of these smaller projects can be split into a large number of small atomic activities.

For example, as your bigger goal is to internalize a particular set of programming skills, your first task may be to spend a couple of minutes trying to come up with a specific learning outcome for the very first part of the process.

So, let’s assume that you’ve realized that learning all there is to learn about HTML, CSS, and JavaScript is not practical. Therefore, after a short brainstorming session, you may decide that the best way to go forward is to choose any particular webpage and try to replicate its layout.

After this, you may come up with a list of the tasks that looks like this:

  • Create a basic webpage with a title text.
  • Find out how to host it so it can be opened in a browser.
  • Apply font styling and coloring to the title.
  • Add a picture under the title.
  • Ensure that the picture is correctly aligned.
  • Insert the navigation bar on top.
  • Make the items on the navigation bar clickable.
  • Add a side panel.
  • Add text to the main panel.
  • Ensure that the text is correctly styled and aligned.
  • Apply the background styling.

So, as you can see, each of these tasks looks small.

As an experienced software developer, you may realize that some of these tasks may be complex, but as a beginner, you probably wouldn’t know that.

The trick is to split the activity into tasks that seem small in purely subjective terms. They don’t have to be small by objective measures. Remember, we are trying to trick our brain here.

However, splitting the project into small tasks is not enough. You need to put your entire focus on each task on the list.

It shouldn’t matter how long the task at hand takes. All you need to do is complete just that one task. While you are at it, nothing else should exist in your subjective version of reality. And then, if you want it, you can have a break.

In this situation, it won’t seem like a big deal to your subconscious mind. No matter how mundane and unpleasant the task is, it’s just a small activity that you can easily get out of the way.

Although you still may feel an urge to procrastinate, the urge would be much weaker compared to a large task with an ambiguous goal. In any worthwhile activity, the hardest part is to get started. But getting started is easy if the target in front of you is small and well-defined.

This is similar to the Pomodoro technique that is mentioned in various articles on Simple Programmer. However, instead of limiting your work activity by time, you limit it by atomic unit of work.

Many developers will prefer microtasks over Pomodoro. I, for example, struggle to switch when I leave any given task in an incomplete state.

An Example of an Action Plan

I have been using this principle in my own career and found it to be highly effective. Here is one example:

One of my projects required me to build a cross-platform app that would play audio on both Windows and Linux operating systems. I was limited to using .NET Core, as this is the core area of competence of my team.

As I have no prior Linux experience and didn’t know of any in-built capabilities of .NET Core to play audio, the little voice in my head started telling me that the task is not achievable within a realistic timeframe.

However, I chose to ignore that little voice and decided to come up with a plan of action. This is what I ended up with:

  • Compile a list of third-party libraries that can play audio on .NET Core in a cross-platform fashion.
  • For each library, assess its suitability for the project at hand (this would be treated as a separate task for each library).
  • If no suitable libraries are found, compile a new list of tasks.

So, that got me started and was enough to have me occupied for a while.

Unfortunately, although I found some audio libraries for .NET Core, none of them was suitable to meet the requirement. They were either available at a high premium or relied on OS- and CPU-specific components that had to be pre-compiled. Therefore, I needed to come up with a new list of activities.

I ended up with this:

  • Find another free cross-platform technology that has either in-built audio playback capabilities or reliable third-party libraries available.
  • Investigate how this technology can be integrated with .NET Core.
  • Implement the logic in my own app.
  • Test the app on Windows.
  • Test the app on Linux.

This time, I found that audio playback can be achieved in Node.js by an NPM library play-audio. I also found that Node.js code can be interacted with from a .NET Core app via a library called NodeServices.

The solution I then came up with was relatively easy to implement and met all of the requirements. For those who want to know more, I wrote about it on my blog.

Getting Into the Flow

Once you have started that difficult task, maintaining momentum is then relatively easy.

If you manage to complete several related tasks in a row, you may even get into the most productive mental state—the state of flow.

This is where you will no longer even have to think about microtasks. You will be so focused on your work that procrastination won’t be on your mind at all. The transition from one task to the next will happen naturally.

Usually, the state of flow occurs after at least 15 minutes of uninterrupted, focused work. And it’s not only productive but also very pleasant to be in.

This is something you should always keep in mind. Although microtasks are still an effective cure against procrastination when you allow yourself to take a break after a task is completed, the chances of entering the state of flow will be maximized if you move on to the next task right away.

After all, microtasks are merely means to an end, with eliminating procrastination being the goal. Microtasks are only useful while your mind is trying to wander off.

Once you get yourself into the state of mind that has no place for procrastination, you can completely forget about microtasks and just focus on the flow.

Procrastination Is Mentally Draining

While procrastination delays the intended outcome of your work, it also negatively affects your productivity in another important way. It drains your valuable mental energy, which decreases your performance even further.

When we have an urge to procrastinate, we tend to fight it. This uses up some of the energy that could have been utilized for solving the actual problem that we are working on.

But there is also another reason why procrastination makes you feel mentally drained. When we shift our focus between several unrelated tasks, we engage in context switching. And context switching is an energy-consuming process.

The most efficient use of your conscious mind is to focus on a single activity and let your focus flow naturally through it. Therefore, being mindful of how mentally draining procrastination is would add effectiveness to applying the concept of microtasks. Reminding yourself of this will help you to complete the maximum number of microtasks in one go, as the pauses between the tasks are similar to procrastination, although taking a planned break is still much better than fighting the urge to procrastinate.

As I have already mentioned, you can allow yourself to take a break when any given task is completed, but it would be much better to just carry on as long as the next task on your list is related to the one you have just completed.

On the other hand, if you feel a strong urge to stop after any given task, you should just allow yourself to do so. Yes, you may lose some mental energy to context switching, but you won’t have to lose even more energy trying to fight the urge to have a rest.

Become a Master of Your Productivity

Keeping yourself focused is a skill. And, just like any other skill, it gets better with practice.

Microtasks allow you to complete an atomic unit of work while only keeping yourself focused for a limited amount of time. So, regardless of how good or bad your ability to focus is, microtasks will help you.

However, even though you can take a guilt-free break after any of the tasks is completed, the most beneficial use of this technique comes when you carry on working through the list of tasks until you stop struggling to fight off the urge to procrastinate.

Eventually, especially after you become familiar with the state of flow and experience it a few times, you will be able to keep an uninterrupted focus for longer.

This is how you become a master of productivity. One little microtask at a time.