Serial Is Good

Here is a claim that sounds trivial and, I’ve come to believe, explains a surprising amount of computer science: humans are single-core animals. We follow an argument one step at a time. We cannot hold two lines of reasoning at once—we alternate, badly. And once you take this seriously, a pattern snaps into focus across every layer of the systems we build.

Machines lie to us at every layer

Your CPU does not run your program in order. It executes instructions wildly out of order, hundreds in flight—and then retires them strictly in program order, spending a startling amount of silicon on machinery whose only job is to make the chaos look, from the outside, like your code running one line at a time. The compiler plays the same trick one level up: it may reorder anything, under the “as-if” rule, so long as the observable behavior matches your sequential program. TCP takes packets that arrive scrambled and refuses to deliver a single byte out of order, even when that means everything stalls behind one missing segment.

Databases turned the fiction into a gold standard and gave it a name. A concurrent execution is serializable if its outcome is equivalent to some serial order of the transactions. Not a particular order—any serial story will do, as long as one exists. Shared memory has its own version: sequential consistency, which Lamport defined in 1979 in a paper of barely two pages—the result of any execution is the same as if all operations ran in some sequential order. That “as if” carries the whole field on its back; it is the same “as if” the CPU and the compiler are selling. A year before, he had shown that events in a distributed system come with only a partial order, and the founding move of distributed computing was to manufacture a total one. Blockchains are the extreme case: roughly half a percent of the world’s electricity, burned so that parties who trust nobody can agree on nothing more than the order of entries in a ledger.

The pattern: the world is concurrent, the hardware is parallel, and at every layer we pay—in transistors, in latency, in gigawatts—to maintain a serial fiction. So ask: who is the fiction for? The machines don’t need it. We are the customer.

The single-core animal

The bottleneck is not a habit; it is measurable. Ask someone to make two simple decisions at nearly the same time, and the second reliably waits in line—even when people are paid to process in parallel, they cannot. Play two conversations, one into each ear, and a listener following one can report almost nothing of the other—sometimes not even what language it was. The conscious workspace holds about four things. And speech, across every human language, converges on the same skinny channel: languages that pack more information per syllable are spoken more slowly, lighter ones faster, and the product lands near forty bits per second for all of them. The bottleneck is not the mouth. It has been argued, and I find it persuasive, that the brain is massively parallel hardware running a serial virtual machine called the conscious mind—slow and costly, the way emulation always is.

This is why concurrency is hard for us: reasoning about interleavings means emulating a parallel machine on a single-threaded one.

It is also why writing works. A thought in the head is not a sequence; it is a tangle—associations pointing every direction at once. Prose is a line. Writing is the topological sort: it forces the tangle into an order where each step must justify the next, and every hidden cycle, gap, and contradiction surfaces in the sorting. That is what “writing is thinking” actually means, and it gives a clean test of understanding: can you serialize it? A tangle you cannot linearize is a tangle you have not understood.

The machine that speaks in order

Now the strange part. We finally built minds out of parallel hardware, and the question of order followed them there.

A transformer reads in parallel—attention computes each token against everything before it, all at once, which is exactly why these models can be trained at planetary scale. Yet it speaks one token at a time. I used to file that under implementation detail. Two things changed my mind.

First, chain of thought. Force a model to serialize its reasoning into steps before answering and it gets measurably smarter—and this is now theory, not folklore. A single forward pass is a constant-depth parallel circuit, and complexity theory told us decades ago that some problems are believed to be inherently sequential—no amount of parallel hardware flattens them. Give that same transformer enough serial steps of thinking out loud, and the ceiling provably lifts. Serialization is not a human crutch the machines politely tolerate. It is computation that cannot be flattened.

Second, the genuinely parallel minds are arriving anyway. Diffusion language models draft an entire answer at once and refine it over a few rounds. Speculative decoding guesses many tokens in parallel, then keeps only the prefix a serial process would have produced—the reorder buffer again, one level higher. And in research prototypes, models reason in raw vectors rather than words, holding several candidate next steps in superposition. Genuinely parallel thought. It works. And it is unreadable.

Serial is how we check

Which is, I think, the real point.

Every serial fiction above buys the same thing, and it is not speed—it costs speed. It buys checkability. To trust a result, someone must walk from premises to conclusion one step at a time and find no gap. Trust requires audit; audit requires replay; replay requires an order. A reasoning trace is serializability for thoughts: the computation may be wild and parallel inside, but it owes us one serial story that explains the outcome. (Even now the trace can be a press release—models sometimes report reasoning they did not do—which is exactly why I think of this as a verification problem, not a UX feature.)

I don’t know how AI will ultimately think in parallel; I want to be honest that nobody does. But if machines move their real thinking into parallel vectors, the serial trace becomes the last interface between their cognition and ours—and when that interface goes, what we lose is not thinking. The machines will do plenty of that. What we lose is checking.

Serial is good. Not because it is fast—it never was. Because it is the only thing a single-core animal can verify.