Commanding Bits at Scale

Software engineering is no longer the priesthood. The interface is English.

Power has always come from commanding many of something. The interesting question is who gets to do the commanding.

Caesar commanded legions. Genghis Khan commanded an empire of horsemen that moved as one body. Napoleon commanded armies on a scale Europe had never coordinated. The Royal Navy commanded ships across oceans it could not see across. The modern tech company commands codebases longer than any one engineer can hold in their head.

The thing being commanded changes — soldiers, sails, signals, source files — but the underlying mechanism is the same. You do not move the things yourself. You set the intent. An apparatus translates that intent into coordinated action far below your direct attention: hierarchy, doctrine, drilled procedure, signal-passing protocol. Caesar did not know what every centurion was doing in the third hour of a battle. He did not need to. The apparatus carried the intent down to the men who carried out the work, and the result that bubbled back up was the battle.

Said another way: leverage has always been an organizational achievement. The general gets credit for the victory. The apparatus does the work.

I. The software era as a new kind of commanding

When software arrived, a new kind of general appeared. One human, sitting at a keyboard, could now command billions of coordinated bit-flips per day. The apparatus was code. The doctrine was the algorithm. The hierarchy ran from the source file down through the compiler, the operating system, the microcode, and into the transistors themselves — the bit either on or off, with no layer below.

The leverage was real. A single software architect, working alone, could move more bits than every clerk in the British Empire combined. But the entrance fee was steep. To wield the leverage you had to be able to author the apparatus. You had to write the algorithm that translated your intent into the actions of the machine. The set of people who could do this was small. They were called software engineers, software architects, occasionally — at the very top — systems architects. The leverage was real, and the population that could touch it was not.

I watched this from the inside for thirty years. The chips got faster. The screens got prettier. The languages got higher. But underneath, every computer I ever touched did the same thing it was doing the day I sat in Yale Patt's office in 2001 helping edit the LC-3 chapters: it set some ones, cleared some zeros, did it again, in patterns specified by a human who wrote down what they wanted.

Then about three and a half years ago that changed. Not in the chips. Not in the languages. In the apparatus.

II. The ratio that exploded

There is a ratio underneath every program a human has ever written. Call it the intent-to-bits ratio — how many coordinated bit operations a single unit of human intent can summon. For every line of code, billions of bit-flips. For every CPU instruction, dozens of micro-operations.

For most of computing history, the binding constraint on that ratio was the human writing the spec. You wanted the machine to do something. You spelled it out in C, or Python, or whatever language sat between you and the silicon. The ratio was bounded by how fast you could write down what you wanted, and how skilled you were at structuring the apparatus that would carry that intent to the metal. You could buy more compute. You could not buy more intent-per-keystroke.

This is the wall the entire software industry has operated against since FORTRAN. You measured productivity in lines of code, features shipped, pull requests merged — because those were the units of intent-output you could actually control. Compute kept getting cheaper. Intent did not.

Then we built a thing that takes intent and produces coordinated bit-flips without requiring you to author the apparatus between them.

Say I tell an agent: research these fifty companies, score them on these five dimensions, build me a comparison table. That sentence — twenty-three words, spoken into a phone if I want — triggers billions of coordinated bit operations across multiple machines. Token sampling. Retrieval. Tool calls. Database queries. JSON parsing. Probably a dozen API hops. I never wrote the apparatus. I described the result.

The ratio exploded by orders of magnitude.

III. How big the change is

A useful comparison. In 1980, an engineer wrote assembly to control a few thousand bytes of memory and a handful of registers. Call it one programmer commanding roughly ten thousand bits in active coordination per workday. By 2005 the same engineer was writing Python on a multi-core machine talking to a server farm — maybe a billion bits in active coordination per workday once you count the cycles spent in libraries the engineer didn't write but did invoke.

In May of 2026, the same engineer can sit at a terminal and dispatch a swarm of agents across a thousand subtasks before lunch. The active coordination per workday is bounded only by inference cost and by the clarity of the operator's intent. The intent-to-bits ratio has exploded by orders of magnitude in the agent era — a modern agent swarm can coordinate more downstream compute before lunch than a 2005 engineer could directly orchestrate in months.

The bottleneck moved up the stack.

For most of computing history, software engineering was the priesthood that sat between human intent and computational leverage. If you could not author the apparatus, you could not command the bits at scale. That entrance fee just changed.

The constraint used to be writing the spec. The constraint is now choosing what to ask for.

IV. The middle is opaque, and always has been

There is an objection here that goes: but you don't actually know what the model is doing in the middle. The bits are being flipped but you can't explain why. The whole stack is a black box, and any apparent magic will turn out to be a hallucination dressed up as competence.

The objection is serious. It also doesn't survive a look at the computing stack we already trust.

You do not know what the OS scheduler is doing when you call print(). You do not know how the JIT is reorganizing your bytecode. You do not know how the branch predictor is guessing. You do not know what the CPU's microcode is decomposing your MUL into. None of these layers are transparent. All of them are wrong sometimes, in ways you only catch in production. Caesar did not know what every centurion was doing either.

Every layer of abstraction in computing is a fuzzy contract. You hand inputs to the layer. You get outputs from the layer. The middle is opaque, and you trust it conditionally — based on track record and on your ability to detect when it has failed.

Opacity has always been the price of leverage.

We accepted it because the trade was worth it.

The LLM is the same trade, scaled up. The contract is fuzzier — the layer is non-deterministic in ways the JIT is not. But the difference is one of degree, not of kind. We accept it again because we are getting more useful work in exchange than we have ever gotten from any single layer of the stack.

V. Who is now in the room

This is where the entrance fee story gets interesting.

For thirty years, the leverage of commanding bits at scale was gated by the apparatus you had to author. You needed C, or Python, or assembly, or some other language that sat between your intent and the metal. You needed years of training to write code that did anything coordinated at scale. The general's chair existed, but you had to build the army before you could command it.

That entrance fee just changed. The apparatus is already built. The interface is English. The friction has been compressed down to whether you can hold a clean enough picture of what you want, and whether you have the agency to keep iterating until the picture and the result line up.

You can dispatch coordinated bit-flipping at scale, today, by speaking into a phone and watching the result appear in a terminal. I am doing some version of that while I write this.

This is not "AI can write code." That framing misses what's happening. The interesting thing is not that the model produces code as output. The interesting thing is that the model produces coordinated activity as output, and that activity may or may not pass through a piece of code at any point. The bits flip either way.

The skill that matters now is not learning a particular model's API.

The scarce skill is no longer syntax.

The scarce skill is intent.

The intent layer has become the binding constraint. Everything below it has gotten cheap. The differentiator between two people of equal capability is no longer who can type faster or remember more syntax. It is who can hold a clean enough picture of what they want that the bits land in the right places.

This is closer to architecture than to programming. Closer to management than to engineering. Closer to teaching than to typing.

It is also why most of the people getting good at this very fast are not the people you would expect. The twenty-four-year-old who memorized React hooks is not at an advantage. The forty-four-year-old who has run teams, taught classes, written specs, and sat with customers across three decades — figuring out what they actually wanted from a confused fifteen-minute conversation — has been training for this role the whole time. The bit-flipping was always going to get cheaper. What stays expensive is the intent.

Closing

The four-minute mile didn't break because human legs evolved. It broke because someone redrew the picture of what was possible, and the rest followed within a year. What happened in computing over the last three and a half years is the same kind of redrawing — not in the silicon, but in the channel between us and the silicon.

The bits have always been there. They have always been willing to flip in coordinated patterns. What changed is that for the first time, the general's chair is no longer reserved for the people who could build the army themselves. The apparatus is already standing.

Anyone with enough agency to walk up to it and speak can command it.

Welcome to commanding bits at scale.