Racing the Beam, Trusting the Machine

I learned to program by counting.

Not counting lines of code, or features, or hours. Counting cycles. On the Atari 2600, the machine I cut my teeth on, there was no frame buffer. There was no place to draw a picture and let the hardware show it to you. There was only the raster beam, sweeping left to right across the television sixty times a second, and a chip called the TIA that knew how to paint exactly one scanline at a time. If you wanted graphics, you generated them live, in real time, while the beam was moving. The beam did not wait for you. The beam did not care about your intentions. You had 76 machine cycles per scanline, and every instruction you wrote had a known, fixed cost. A load from page zero was three cycles. A branch taken was three, a branch not taken was two, and if your branch crossed a page boundary it cost you one more, and that one extra cycle could tear your playfield in half on national television, or at least on the Zenith in your living room.

So you counted. You sat there with the 6502 reference card and a legal pad and you added up cycles like a bookkeeper because the program counter and the electron beam were locked in a dance and you were the choreographer. Three color clocks ticked by for every cycle the processor burned. The beam moved whether your code was ready or not. Writing a game for that machine meant writing a program whose execution time was the display. Your code didn’t produce the picture. Your code, running, was the picture.

This is worth dwelling on because it has become almost impossible to see. Every layer of computing built since then has labored to hide it. At the bottom of every machine there is only timing, only the clock, only events chasing events. We who wrote games for the 2600, and later for the Atari 400 and 800 with their more genteel video hardware, lived at that bottom. The 800’s ANTIC chip would fetch screen data on the programmer’s behalf, a courtesy bordering on decadence, but the tricks that mattered, the smooth scrolls and impossible colors, still came down to interrupts fired at a particular scanline and a handful of cycles in which to act before the beam arrived. One learned to feel where the beam was, the way a sailor feels the tide. It was a strange intimacy, and it bred a strange joy: the deep, almost somatic pleasure of a routine that consumed exactly its budget of microseconds, not one more, a piece of clockwork seated perfectly inside a larger clock.

We Had Evidence, and the Evidence Expired

It also bred a priesthood, and priesthoods come with doctrine. Ours was simple. The machine could not write its own code. We had evidence. Compilers existed, and their output was a form of low comedy: bloated, meandering, and above all temporally innocent. The compiled code did not know what time it was. It carried no timing signature, and timing was the whole art. A compiler could no more write a video game kernel than a typewriter could write a sonnet. The gap between machine-generated code and the handmade kind seemed not merely wide but constitutional, a fact about the nature of machines.

We were not the first to believe this. In the early 1950s, when Grace Hopper proposed that a computer might translate human-readable notation into machine instructions, the programming priesthood of her day, men who composed in raw octal and were proud of it, dismissed the idea as fantasy. Computers did arithmetic; they did not write programs. When FORTRAN appeared in 1957, its creators understood that the entire project would live or die on a single question, the same question, always the same question: could the machine’s code rival a human expert’s? For a while it could not. Then it could. The hand-coders did not surrender their doctrine gradually. Each one held it absolutely, right up until the afternoon he didn’t.

The Argument That Ended the Moment I Lost It

My afternoon came on the 68000.

By then the processors had grown spacious. Registers in abundance, memory in megabytes, time itself no longer rationed by the scanline. I had sketched a routine in C, intending, naturally, to rewrite it by hand because this was a routine I knew the compiler could not handle. I had the assembly half-composed in my head, the way you carry a tune. Then I read the output of the optimizing compiler, and the tune died.

The compiler had restructured the problem. It avoided branches I would have taken. It held values in registers across spans where I would have spilled them to memory. It found an ordering of operations that I had not seen and, I slowly understood, would not have seen, and the result would run faster than anything I would have written. Not nearly as fast. Faster. I read that disassembly the way one plays through a chess game by a superior player, admiration shading into vertigo, and somewhere in the middle of it my doctrine quietly expired. I never wrote another line of assembly. There was no transition period, no hybrid workflow, no mourning. The argument ended, and I had lost it.

Here is the paradox that took me longer to see: losing felt like wealth. All the attention I had spent on cycle counts and register allocation. This required bookkeeping so consuming it had felt like the craft itself. What still remained was the actual work. What should the program do? What should the game feel like? The compiler had not taken the craft. It had taken the counting, and the craft, it turned out, had been hiding under the counting all along.

Another Level of Indirection, All the Way Up

There is a line every programmer eventually hears, usually credited to David Wheeler, the man who wrote the first subroutine: every problem in computer science can be solved by another level of indirection. It gets told as a joke and meant as a law. The whole field is a stack of indirections, each one a bargain struck with complexity: I will stop thinking about what is beneath me so I can think about what is above me. Wheeler’s punchline, the half nobody quotes, is that this creates the one problem indirection cannot solve, which is too much indirection. The tower we keep building to get away from the details is made entirely of details we agreed to stop seeing.

This is the oldest story in computing, told over and over at ascending altitudes. Machine code disappeared beneath assembly. Assembly disappeared beneath compilers. Memory management disappeared beneath garbage collectors, the disk beneath the file system, and the network beneath the protocol stack. Each layer begins as an absurdity, an improvement only a fool would pay for, then becomes a curiosity, then a convenience, then a floor: a surface so solid that the people standing on it forget it was ever contested, forget there is anything underneath at all. The machine does not vanish. It descends.

Here’s the unexpected good news. Each time a layer hardens into a floor, the person standing on it is not put out of work; she is moved up a story. The programmer who stopped toggling switches did not retire, she started writing assembly. The one who stopped hand-assembling started designing systems. Every floor is poured so that someone can stand on it and turn to the next problem up, the one that was invisible from below because the floor beneath it had not been laid yet. Indirection does not take the human out of the loop. It keeps lifting the loop to a higher altitude, and at every altitude the work that remains is the same kind of work: deciding what the thing on this floor is supposed to do. The counting goes downward. The deciding goes up.

The Crisis We Used to Call Compilation

Which brings us to the present and to a generation of senior engineers having my afternoon all at once.

I know these people. They came up the hard way, and they held the modern form of the old doctrine: machine-generated code will never match the handmade kind, because for years it visibly didn’t, in precisely the way 1982 compiler output visibly didn’t. Then came December, the holidays, when Opus 4.5 and 4.6 arrived, and ChatGPT 5.4, and the coding agents took one of those discontinuous leaps that appear on no roadmap, and I began to hear the same sentence from people who would never have uttered it a year before. I haven’t looked at a line of code in six months. Not spoken in shame. Spoken in the flat tone of someone reporting a fact about the weather.

Their agents now generate code faster than any human could review it, and this is described, in the present anxiety, as a crisis. But consider: my compiler has generated machine code faster than I could review it for forty years, and no one has ever called that a crisis. We called it compilation. We called it progress. We stopped looking because looking was no longer where the information was.

The objection writes itself, and it deserves a hearing. A compiler is deterministic, formally specified, the same input yielding the same output until the lights go out, while an agent is a stochastic process in a vest. True. But the trust we extend to compilers was never granted by the formal semantics. It was earned empirically, bug report by bug report, test suite by test suite, across decades of afternoons exactly like mine. The agents are earning it the same way, only compressed, and part of the new craft is building the instruments that check the work while no one is looking. Editors never worked alone either. They had fact-checkers.

That is what is happening now. Source code, the great artifact of the software century, the thing we versioned and reviewed and argued over in pull requests, is becoming what assembly became: an intermediate representation, a target language, the machine’s business. The human’s business is migrating upward, to intent, to architecture, to judgment, to taste, to the shape of the problem itself, which is to say, to the things that were always the job, obscured beneath the bookkeeping of the day.

The Blank Page Stopped Being the Job

And this time the story is leaving software. For most of a century the disappearing machine was something programmers told each other in a dialect only programmers spoke; the layers that descended were our layers. But the same leap that lets an agent write code it won’t show you also lets it write the brief, the memo, the market analysis, the lesson plan, and the contract. The lawyer who believed the machine could not argue, the analyst who believed it could not reason across the numbers, the consultant, and the strategist: each carries his own edition of the doctrine, and each has an afternoon coming.

I can speak to what waits on the other side because I have held the job that everyone is about to inherit. This is not a metaphor I am borrowing. For a stretch of my life I was a magazine technical editor, with a chair and a stack of other people’s manuscripts, and the work was never to produce the sentences. It was to read what someone else had produced and know, fast and often without being able to say why, whether it was alive. Where the argument went slack. Which paragraph was structural and which was throat-clearing? What the piece was reaching for and how far short it fell. I seldom wrote the line. I decided whether the line stayed.

That is the posture the machine has handed back to me. The draft now arrives faster than I could have made it and frequently better than I would have made it, and my real work starts where the draft lands: reading it, weighing it, cutting it, and handing it back with a note in the margin. The blank page, the thing writers dread and romanticize in equal measure, has quietly stopped being the job. The full page is the job. What I bring to it is no longer the act of generating words but the judgment of which words deserve to live, the same verdict I once passed on other people’s manuscripts, now passed on a machine’s.

And the chair is about to get crowded. The whole knowledge economy is becoming an editing economy. Not because writing stopped mattering, but because the drafting, the patient assembly of words and numbers that felt like the work because it ate the day, has slid down to the machine the way cycle counting once did. What it leaves on our side of the line is the part that was always the hard part and never looked like labor: knowing what the thing is for and whether it is worth making at all.

The Difficulty Was the Tax, Never the Love

There is grief in this, and I won’t wave it away, because I felt a version of it and have watched it land harder on others. When a thing you suffered to master becomes a thing a machine does in the time it takes to describe it, what you lose is not only a skill. It is a self. You spent years earning fluency, and the years were the proof that the fluency was worth having. The standing, the quiet authority of being the one who could do the hard thing, was collateralized by the difficulty. Remove the difficulty and the collateral is gone, and the feeling that follows is not relief. It is closer to mourning.

The conclusion people draw from it is usually wrong. The mistake is the one I nearly made on the 68000, reading that disassembly: confusing the cost of the work for the worth of it. Counting cycles was expensive, and because it was expensive it felt like the craft itself. But expense is not value. I thought I loved hand-assembly; what I loved was making the thing work, and the hand-assembly was the toll I paid at the gate. When the toll fell to nothing, I did not lose what I loved. I got more of it.

I won’t pretend it lands the same for everyone. Some people loved the counting itself, the closed and masterable world of it, and for them the floor giving way is a real loss and not a disguised gift. But for most of us the slaving was never the love. It was the tax on the love, and the machine has only stopped collecting it.

The Question at the Top of the Stack

The beam never waited. That was the first lesson, learned with a legal pad and a reference card, counting cycles against the sweep of an electron gun. Every abstraction built since was a way of letting the machine do the counting, and at every layer the same thing survived the handoff. Not the counting. The verdict.

When I sat in the editor’s chair, the verdict was wordless. I could not always say why a paragraph was dead; I only knew that it was, and the knowing was enough, because verdicts were rare and human and expensive, and mine was trusted on its record. That arrangement does not scale to what is coming. The drafts now arrive faster than anyone can read them, in every trade at once, and everyone is the editor now, and a wordless verdict passed at machine speed is just a mood with a deadline. The instinct has to become a discipline. The taste has to learn to show its work.

The machine has taken the counting, the way it took my cycles and my registers and my afternoons with the legal pad, and it is welcome to all of it. What it hands back is older than software, the question the editor asks of every page, the one the whole economy must now ask of everything it makes, faster than it has ever had to ask it, with less excuse than ever for getting it wrong:

Is this good, and how do you know?