It is 10:14 AM on a Tuesday, and you are currently failing at three different things.
You are sitting in a meeting about the Q3 roadmap, nodding occasionally to signal that you are a functioning member of the team. On your lap, hidden by the table, your thumbs are dancing across your phone, crafting a reply to a text from your partner about the specific brand of oat milk that is acceptable for the grocery run later. Meanwhile, a third of your brain is preoccupied with an unsent email to a client that has been sitting in your drafts for three days, glowing like a low-level radioactive isotope in the back of your mind.
You feel busy. You feel like a high-performance engine, pistons firing in rapid succession. You are "multitasking."
But if we were to zoom in on your actual experience, the reality is much uglier. You aren't actually listening to the roadmap discussion: you missed the last three sentences because you were debating between "Extra Creamy" and "Original." You aren't actually connecting with your partner: the text you sent was curt and lacked a necessary emoji. And the client email? It’s still just sitting there, draining your battery.
By 5:00 PM, you will be exhausted. You will look at your to-do list and realize that while you "worked" all day, you didn't actually finish any of the big, meaningful tasks. You will feel like you’ve been running a marathon on a treadmill: a lot of sweat, a lot of movement, but you are still in the exact same place you started.
This is the central paradox of modern life. We have been sold the lie that our brains are like modern computers, capable of running dozens of applications simultaneously. We believe that if we just get better at "juggling," we can fit more into the day.
The truth is that your brain is not a parallel processor. It is a single-threaded machine. And the "busy" feeling you have is not the sound of a powerful engine: it is the sound of your mental gears grinding themselves into dust because you are forcing them to switch directions every forty-five seconds.
To understand why this feels so bad, we have to look at what happens when you "switch."
In psychology, there is a concept called "Attention Residue." When you shift your focus from Task A (the roadmap) to Task B (the oat milk), your brain does not immediately move 100 percent of its resources. A significant portion of your cognitive power stays stuck on the previous task. You are still "processing" the roadmap while you type.
When you then switch to Task C (the client email), you now have residue from both previous tasks clogging up your working memory. It is like trying to drive a car with three different GPS voices shouting different directions at the same time. You end up driving slowly, hesitantly, and frequently missing your turn.
Think of your brain as a giant library. To do any complex work, you have to "load" the relevant books into your internal reading room. If you are writing a report, you have the data, the tone, the goals, and the structure all laid out on the table. This takes time. It takes about fifteen to twenty minutes of focused effort just to get the library organized so you can actually start working.
But then, your phone buzzes.
It’s a Slack notification. It’s a trivial question about a meeting time. You check it. You spend thirty seconds answering it. You think, "That only took half a minute, no big deal."
But it was a big deal. The moment you looked at Slack, the librarian in your head threw all the books for the report off the table to make room for the Slack "books." When you turn back to the report, you don't just pick up where you left off. You have to spend another ten minutes finding the right pages, re-reading the last paragraph, and remembering what your point was.
The cost of the switch is often higher than the cost of the task itself. This is what engineers call "overhead." If you switch tasks every ten minutes, and it takes five minutes to fully "reload" your context, you are effectively operating at 50 percent capacity. You aren't working harder: you are just paying a massive tax to your own scattered attention.
We have become addicted to this tax. We crave the switch because every time we check an email or see a new notification, our brain gives us a tiny squirt of dopamine. It feels like "progress."
But this is a cheap trick. True work, the kind of work that moves the needle in your career or brings you deep satisfaction, requires a state of "Flow." Flow is that magical zone where the self disappears, time slows down, and you are operating at the absolute ceiling of your ability.
Flow is biologically impossible in a multi-tasking environment. Flow requires a "protected thread." It requires the brain to stay on one track long enough to exhaust the easy answers and start finding the creative, difficult ones.
Funnily enough, programmers ran into this exact problem in the 1990s. As computers became more powerful, they wanted them to do more things at once. But they found that if they let multiple parts of a program touch the same data at the same time, everything crashed.
In the language Python, which runs much of the modern world, they solved this with something called the Global Interpreter Lock, or the GIL. Even on a computer with sixteen "cores" (the hardware equivalent of sixteen brains), the GIL ensures that the Python interpreter only executes one thing at a time. It keeps the system safe by preventing "race conditions" where two tasks fight over the same memory.
Here is literally what that looks like in Python: just to make the parallel concrete:
import threading
def focus_on_one_task():
print("Executing a single thread of deep work...")
# Even if we create two 'threads', the GIL ensures
# only one actually runs at a time in the CPU.
task1 = threading.Thread(target=focus_on_one_task)
task2 = threading.Thread(target=focus_on_one_task)
task1.start(); task2.start()
The Global Interpreter Lock is a built-in "bottleneck" that forces the language to focus on one instruction at a time to maintain stability.
While programmers have debated for years about how to "break" the GIL to make Python faster, they have found it incredibly difficult because the lock provides a fundamental kind of safety. When the lock is on, the program knows exactly what is happening. When you try to do everything at once without a lock, you get "memory corruption."
In human terms, memory corruption is what happens when you finish a long day of "multitasking" and realize you can't remember a single thing you actually did. Your "lock" was off, your threads were fighting for the CPU, and your internal memory got garbled in the process.
If we accept that our brains are, by design, single-threaded, we have to stop trying to "fix" our ability to multitask. Instead, we have to learn how to manage the lock.
We need to become the masters of our own Global Interpreter Lock.
The most successful people I know aren't the ones who can answer emails while leading a meeting. They are the ones who are "viciously present." When they are with you, they are 100 percent with you. When they are writing, their phone is in another room. They understand that the "high-latency" of switching is a death sentence for quality.
Latency is the delay between a request and a response. In networking, high latency makes the internet feel laggy. In your brain, high-latency context switching makes your life feel laggy. You feel like you are perpetually behind, even when you are moving fast.
To fix this, we have to adopt a "Batching" mindset.
Think about how you do laundry. You don't wash one sock every time it gets dirty. That would be an insane waste of water, electricity, and time. The "overhead" of starting the machine for one sock is too high. Instead, you wait until you have a full load. You batch the task.
Yet, we "wash one sock" with our attention all day long. We reply to one email the second it arrives. We check one notification. We answer one "quick question."
To reclaim your focus, you have to create "Large Batch" windows. This is the core of Deep Work. You decide that from 9:00 AM to 11:00 AM, the lock is on. No Slack. No phone. No oat milk. Only the "Primary Thread."
This feels uncomfortable at first. We are so used to the dopamine hits of switching that the silence of a single thread feels like boredom. But boredom is the lobby of creativity. You have to sit in that lobby for a while before the librarian starts bringing out the really good books.
There is a historical example of this that has always fascinated me. It involves the way we built the great cathedrals of Europe.
If you look at the construction of something like the Cologne Cathedral, it took over 600 years to finish. The people who started it knew they would never see the end. But the "engineering" of their focus was singular. The stone cutters weren't worried about the "roadmap" for the stained glass windows that would be installed three centuries later. They were focused on the single thread of the stone in front of them.
They understood that the only way to build something that lasts for 600 years is to work on it as if nothing else in the world exists. They protected the thread.
In our world, we are building digital cathedrals of code, business, and art, but we are trying to do it while being poked in the ribs every thirty seconds. We have replaced "depth" with "breadth," and we wonder why we feel so hollow.
The engineering metaphor of the GIL teaches us something profound: stability comes from constraints. By limiting ourselves to one thing at a time, we aren't being "less productive." We are being more stable. We are ensuring that the work we do is "thread-safe"-that it is coherent, thoughtful, and free of the "corruption" that comes from split attention.
So, how do we actually apply this in a world that refuses to leave us alone?
First, you have to acknowledge the Switching Tax.
The next time you are tempted to "just check" your phone during a deep task, realize that you aren't just losing thirty seconds. You are throwing away the fifteen minutes of "loading time" it took to get your brain into that task. You are literally lighting fifteen minutes of your life on fire. When you frame it that way, the urge to check the notification becomes much easier to resist.
Second, you need to implement Hardware Isolation.
In computing, if you want a process to be truly safe, you run it in a "sandbox" where nothing else can touch it. You need a mental sandbox. This might mean a physical space where you only do one kind of work. It might mean a "dumb phone" that doesn't have email. It might mean "Air Gap" hours where your router is literally turned off.
Third, you must respect the Cool-Down Period.
After a period of deep, single-threaded work, your brain needs to "dump the cache." You can't just jump from a deep strategy session into a high-stakes emotional conversation with your spouse. Your brain still has "attention residue" from the work.
This is why "commutes" used to be so important. They were a buffer zone. They allowed the library to be cleaned up before the new task started. In our work-from-home world, we’ve lost the buffer. We close a Zoom window and immediately walk into the kitchen to engage with our families. We are "high-latency" humans trying to operate in a zero-latency environment.
We need to build our own buffers. A ten-minute walk. A cup of tea. Five minutes of staring at a wall. These aren't wastes of time: they are "clearing the register" so the next thread can run cleanly.
The most radical thing you can do in the twenty-first century is to be "unavailable."
We have been taught that being "responsive" is a virtue. We put "Highly Organized" on our resumes, which is often just code for "I am very good at context switching."
But the people who actually change the world-the great writers, the visionary engineers, the profound thinkers-are often remarkably "disorganized" in their responsiveness. They don't answer texts immediately. They don't jump into every "urgent" meeting. They protect their Global Interpreter Lock with their lives.
They understand that there is a massive difference between "Doing Things" and "Doing Work."
Doing things is easy. You can do a hundred things a day and still be a failure. Doing work is hard. Doing work requires the slow, painful process of staying on a single thread until the problem gives way.
It is the difference between a laser and a lightbulb. A lightbulb is "multitasking": it spreads its energy in every direction, illuminating the room but cutting through nothing. A laser is "single-threaded": it focuses all its energy on one tiny point, and because of that focus, it can cut through steel.
Imagine what your life would look like if you stopped trying to be a lightbulb.
Imagine waking up and knowing that for the first four hours of your day, your Global Interpreter Lock is on. You have one thread. You have one goal. The rest of the world is paused.
The anxiety that dogs you-that low-level "vibration" of having too many things open-begins to fade. You find that you actually finish things. And because you finish them with 100 percent of your attention, they are better. They have a "polish" that multitasking can never achieve.
You realize that you don't need a faster brain. You don't need better "time management" apps. You don't need to "optimize your workflow."
You just need to stop fighting the way you were built.
You are a beautiful, complex, single-threaded machine. Your "lock" is not a bug: it is a feature. It is the thing that allows you to be deep in a shallow world. It is the thing that allows you to be fully present with the people you love. It is the thing that allows you to do work that matters.
The next time the world tries to force you into a dozen different directions at once, remember the Python interpreter. It knows that to be fast, to be safe, and to be effective, it has to do exactly one thing at a time.
Turn the lock on. Focus the thread. Let the world wait.
The most important things in life aren't found in the "switches." They are found in the long, quiet stretches of staying put.
TL;DR
- Multitasking is a biological lie: Your brain does not do two things at once: it rapidly switches between them, incurring a massive "Attention Residue" tax every time.
- The Loading Cost: It takes 15–20 minutes to fully "load" a complex task into your working memory. If you check your phone every 10 minutes, you never actually reach your full cognitive potential.
- The Global Interpreter Lock (GIL): Much like the human brain, the Python programming language uses a "lock" to ensure only one thread executes at a time, preventing data corruption and maintaining stability.
- Stability over Concurrency: Engineering tells us that trying to do everything at once leads to "memory corruption." In humans, this manifests as burnout, mistakes, and the feeling of being "busy but unproductive."
- Protect the Thread: True brilliance comes from "single-threading" your deep work. And yes, while reading this, you just quietly learned how Python's GIL manages concurrency.
The most powerful tool you own is your ability to stay on one channel until the signal becomes clear.
Top comments (0)