Parallel in, serial out

Someone asks me a quick question in a meeting. Why did we pick this design?

I know the answer. I know it very well, actually, and that is the problem. By the time I open my mouth I can see the performance reason, the security reason, the thing we tried last year that went badly, and how the second reason only matters because of the third. So I start with the third.

Forty seconds later somebody says, kindly: “Sorry, can you start from the beginning?”

There is no beginning. That is the part I have never managed to explain.

A few days ago Brivael Le Pogam posted a thread on X, in French, that explains it better than I ever have. His starting point is one I already believed: AI does not think in your place, it multiplies what is already in your head. “If you have nothing to say, it will make you average faster. If you have a real thought, it makes it executable.” I wrote a whole post about why the average is a bet on the one outcome greatness is defined against, so a machine that gets you there faster is less of a gift than it sounds.

Then he goes somewhere I did not expect. Some people think in trees: one idea, and instantly ten branches, each connected to ten more. The world runs in straight lines, one sentence after another, one slide after the next. The branching mind thinks in parallel and has to speak in series. It sees everything, then unwinds it thread by thread and loses half of it on the way. So it comes across as scattered, confused, “too much”.

Okay. That’s me in the meeting.

His conclusion is that AI removes the bottleneck. You throw it the whole tree, out of order, with all its connections, and it helps you unfold it into text, code, a plan. Translating parallel into sequential was always the weak point of that kind of mind, and it is becoming nearly free. What remains is the raw advantage: seeing connections other people do not.

I agree with nearly all of it. I want to spend the rest of this post on why it is true, because the mechanism is more specific than “AI is a great tool”, and on the one place where I would stick a warning label.

Every sentence is a traversal

Steven Pinker has a chapter in The Sense of Style called “The Web, the Tree, and the String”. Grammar, he says, brings together three things:

the web of ideas in our head, the string of words that comes out of our mouth or fingers, and the tree of syntax that converts the first into the second.

Look at the first word. Web, not tree. Hmm.

What is in my head during that meeting is not even a tree. A tree has a root, and every branch hangs off exactly one parent. My design reasons loop back on each other: the security reason depends on the incident, the incident explains the performance budget, and the performance budget is why the security got hard. That is a graph with cycles in it. Language will only take a line.

Anyone who has written software knows this problem under another name: serialization. You have a structure in memory, all pointers, and you need to send it down a wire that carries one byte after another. So you pick an order. You decide what happens when two things point at the same thing, and what happens when something points back at itself. Every serializer makes those choices, and a bad one either drops connections or walks in circles forever.

Writing is serialization. Speaking is serialization with no time to plan.

When a thought is sparse, the order is easy, because there are few connections to lose. The denser it is, the harder the choice gets, and the more of it leaks out mid-sentence as “wait, but that’s related to…”. To the listener, that is not richness. It is a program that jumped to a new node without remembering where it came from. They lost their place, so they ask you to start from the beginning.

This is why the tweet is sharper than it looks. For a long time the cost of thinking densely was paid at the exit. Having the connections cost nothing. Getting them out, in an order another person could follow, was slow, lossy and expensive, and it was the part everyone graded. School essays, job interviews, meetings, slide decks: all of them measure the serializer and assume they are measuring the mind.

When the line gets cheap

A language model is, among other things, an absurdly good serializer. You can hand it the web in the order it arrives: fragments, arrows, “and this links to the budget thing”, a voice note and half a bullet list. For the meeting, mine would have looked something like this:

why this design??
- perf is fine, BUT only because of the budget
- budget exists because of last year's incident
- security got hard because of the budget  (loop!)
- incident also explains... wait, start with perf?

It hands back a line. Not always the right line, but a candidate, in seconds, and another one if you do not like the first.

The step that used to cost me forty seconds and a confused room now costs a paragraph of mess and a careful read.

What is left, once the exit is cheap, is whatever sits behind it: whether you had the connections in the first place. That is the reversal Brivael is pointing at. A lot of what looked like a defect in the person was a defect in the interface.

The warning label

Two of them, actually, and they matter more than a thread has room for.

The first is that choosing the order is not only packaging. Sometimes it is where you find out what you think. I have had branches that felt load-bearing in my head and simply did not survive being written down in sequence: the line showed me they did not connect to anything. If the machine does all the serializing, it also skips that check, because it will lay out a web that is not there just as fluently as one that is. A bush of nothing comes out as a confident, well-ordered page. That is “average faster” wearing a nicer shirt. So I use it to unwind, and then I read the line it gives back with one question in mind: is this my graph, or just a plausible one?

The second is about the word neurodivergent. The thread ties all this to people whose minds branch, and I recognise myself in the description. I am wary of turning it into a badge, though. For plenty of people the branching comes with costs that no interface removes, and “your bug was a feature all along” is kind to hear and not always true. What I am confident about is narrower. One specific cost, the tax on getting a dense thought out in order, just dropped sharply. That is enough to be excited about.

Brivael ends on a line I love. If you have always felt you think too fast, too wide, in too many directions at once: “it wasn’t a bug. The world just didn’t have the interface yet.”

My version of it, today: the interface does not give you the web. It gives you the string. The web was always the part that was yours, and now it is the part that shows.

There still isn’t a beginning. Choosing one has just stopped being the expensive part.