I used to do one thing at a time. Then I opened a second window. Then a third. Then I noticed.
For most of my career, work was a queue. One brief in front of me, deep focus when I could grab it, the discipline of finishing one thing before starting the next. Multitasking was a known cost: every switch left attention residue, every interruption rebuilt context from scratch.
Sometime in the last twelve months, I stopped working that way without consciously deciding to.
Today I am almost always running three Claude sessions at once. One on voice agent ops. One on the content pipeline (newsletter, decks, this post). One on whatever product feature I am shipping that week. Each session has its own brief, its own scope, its own definition of done. I jump between them as the orchestrator, not as the worker.
It is the most productive I have ever been. And I am almost certain it is not multitasking.
This isn't multitasking
Multitasking is what happens when one mind tries to hold two tasks at once. It fails because attention is finite. Sophie Leroy's 2009 paper on attention residue makes the point: every time you switch, a piece of your mind stays behind on the previous task, and the new task gets a degraded version of you. Decades of research has confirmed it. People who multitask don't get more done. They do everything worse.
Output stacking is something else. The reason it works is the same reason multitasking fails, looked at from the other side: attention residue is a property of one cognition holding multiple threads. If three cognitions hold one thread each, no residue. The AI sessions don't fragment. They don't get tired. They don't context-switch. Each one is its own runtime, with its own state, with no cognitive crosstalk.
You fragment, but only at the orchestration layer. Three deep-focused workers run beneath you, each doing one thing.
That distinction is the whole argument.
What actually broke the first time I tried it
The first time I ran three sessions on parts of one larger deliverable, I almost broke it.
Three sessions, three parts, all needing to come together cleanly at the end. The brief was loose. By the time I noticed, the second session was overwriting work the first had nearly finished. Not because anything was wrong with the output, because the brief never told it to stay out. Version control turned from a backup into a battleground.
That night I learned that stacking only works with rigid lanes. Each session needs to know exactly what it owns, what it doesn't touch, and what 'done' looks like. The brief replaces oversight. The brief is the work now. Without that structure, three sessions are worse than one, because now you have to merge conflicts and re-brief from the top.
The fix isn't smarter sessions. It's tighter briefs.
Sessions don't talk. You do.
Here is the part most people miss.
Three sessions can't read each other. That is the safety property, it is how you keep them from colliding. But three sessions building parts of one deliverable need to know what the others have done, otherwise the stack drifts.
The fix is the session update: one session writes a summary you can paste into the next. State moves across lanes through you, never directly. Sessions stay isolated. Context still flows. The handoff is deliberate, on the cadence the work calls for, not on autopilot.
This is the routing layer. Without it, three sessions are three orphans. With it, three sessions are one coordinated deliverable.
You're not a worker anymore. You're a one-person agency.
The sole executor died without ceremony. The new role looks like running a tiny consulting firm: write briefs, review outputs, decide what ships.
This isn't management with new tools. The latency is seconds, not weeks. The cost per worker is near zero. The orchestrator is also the worker when she wants to be. The feedback loop is so tight that briefing becomes thinking. The labour moved. The decisions stayed.
People often ask me if this is exhausting, running three things at once, switching between them, holding all the context. It isn't, because I don't hold all the context. The sessions hold their context. I hold the bandwidth allocation: which lane, which brief, what's missing in the output I just got back. That is a different kind of cognitive load. It scales with practice the way reading speed does.
The skill that matters now
The differentiated skill of the post-AI worker isn't typing faster, prompting better, or knowing more frameworks. It's writing a brief tight enough that three sessions deliver three coherent outputs without colliding. Editorial discipline applied to your own labour.
If you want to see what this looks like in practice, my own setup is in the talk: three sessions, one master CLAUDE.md per project, project bibles as briefs, a START HERE.md for daily orientation, cron jobs for the things that don't need me awake. None of it is exotic. All of it is the same idea: clear lanes, clear briefs, clear handoffs.
The bet
By 2030, output stacking will be the default working pattern for most roles that produce knowledge.
Some work stays sequential by nature: the live call, the negotiation, the in-the-moment decision. Stacking is for everything else, which is most of it. Sequential focus will become the boutique mode, the way artisanal anything becomes a premium positioning.
The job description still assumes serial work. The interview questions still test sequential focus. None of that survives the next hire cycle.
If you are a high performer who hasn't started stacking, the gap is already opening. If you manage one, your high performers are already stacking; the question is whether your role definitions catch up before they leave.
Most people are still queuing tasks. Some are stacking them. The compounding gap between the two is going to be one of the defining lines of the next decade of knowledge work.
If you want the longer version, the full talk is here: 20 slides on why stacking became possible, why it isn't multitasking, the routing layer that keeps three sessions in sync, and the new role of the worker as a one-person agency.
