Read Part I, if you missed it.

There's an old story, told about half a dozen different famous scientists, that ends the same way every time. A lecturer finishes explaining how the earth orbits the sun, and someone in the audience objects: nonsense, the world sits on the back of a giant turtle. Ah, says the lecturer, and what does the turtle stand on? The reply comes without hesitation. Another turtle. And that one? You're very clever, young man, but it's turtles all the way down.

Aside: The audience member never specified whether the turtles were or were not ninjas.

I ended the last piece with a promise to come back to the turtles, because computing really is built this way. Underneath every layer is another layer, and underneath that another, with no solid ground at the bottom. What I didn't say is that the stack has been growing for seventy years, one turtle at a time, and that each new turtle lifted us a little further from the raw machine and a little closer to simply saying what we want. Every generation of makers climbed onto the newest turtle, looked down, and announced that it had finally reached the ground.

They were always standing on another turtle. Here's the climb.

The last thing you could hold

Photo by Bernd 📷 Dittrich on Unsplash

Start near the bottom, with the punch card, because it's the last rung where the medium had a body.

A program was a deck of stiff paper cards, each one a grid of little rectangular holes. You could hold your logic in two hands. You could fan through it. You could set it down in the wrong order, and you could, in the moment every old programmer still winces about, drop the deck and watch your program scatter across the floor, to be rebuilt card by card. It was tedious and unforgiving and completely, physically real. The holes were the program. You touched the thing itself.

That was the last time.

Into the machine

After the card, the medium went inside, and it never came back out.

First it became pure pattern: charge or no charge, on or off, invisible switches flipped somewhere in the machine. You "wrote" a program by setting numbers, and the numbers were the naked instructions the processor obeyed. Nothing to hold anymore. Only state.

Then we started stacking turtles.

Assembly language gave the raw numbers names. Instead of a numeric code you wrote ADD, or MOVE, mnemonics an assembler would translate back into the machine's real tongue. A small mercy, and the first layer between us and the bit.

High-level languages stacked another turtle on top. FORTRAN in 1957, then COBOL, then C, then the whole family. A compiler now did the translating, which meant you could stop tracking exactly which sliver of memory held which value and start describing what you wanted done. BASIC arrived in 1964 wearing the same banner every rung would carry: now anyone can program.

Objects stacked another. You stopped modeling the machine and started modeling the world the software was actually about, in nouns and verbs a person could reason with.

Each of these was an extension, in exactly the sense Marshall McLuhan meant it: a technology that reaches out and does more of our work for us. And every extension removed us from the layer beneath it. Assembly severed us from the bare number. The compiler severed us from the register. We gained enormous reach, and we paid for it in contact. We stopped touching what we used to touch, and mostly we were glad to.

The leap most people actually felt

For most people the climb was invisible until one enormous turtle: the graphical interface.

Photo via Hackaday

In December of 1968, a researcher named Douglas Engelbart sat on a San Francisco stage and, in ninety minutes now remembered as "the Mother of All Demos," showed a room of engineers a mouse, windows, and text you could link and edit live. It took years and a trip through Xerox and Apple to reach the rest of us, but when it did, it changed what a computer was for anyone who wasn't a programmer. You no longer typed commands into a black void. You pointed at pictures of things: a desktop, a folder, a trash can. Direct manipulation, the researchers called it. The command line, which everyone before you had been required to understand, became a turtle you never had to see again.

As an aside, given that my current modality of choice is Claude Code in a terminal, I can only think that Engelbart is somewhere rolling his eyes and mocking me. Or celebrating me. Again, that's the point of this series.

Pause on this rung, because it rhymes with the one we're on now.

The machine was always supposed to help

We tend to talk about AI as a sudden arrival, a thing that showed up out of nowhere and changed everything. It isn't, and the people who built computing knew it wouldn't be.

In 1960, J.C.R. Licklider wrote a short paper called "Man-Computer Symbiosis," imagining people and machines as partners thinking together, each doing what it does best. Two years later Engelbart, the same man who would run the great demo, laid out a research program with a plain title: augmenting human intellect. Not replacing it. Augmenting. His word is McLuhan's word, extend, in an engineer's mouth. The founding dream of the field was never a tool that waited for orders, it was a collaborator.

McLuhan saw the shape of it too. Watching the first wave of automation in 1964, he argued that the machine had stopped being merely mechanical. Electricity's instantaneous, connect-everything character had invaded it, turning the machine into something that processed information and, in his phrase, seemed to think. He was describing, sixty years ahead of schedule, the rung we are standing on now.

So the difference this time is real, but it isn't a break in the story. For its entire history the machine could only interpret us. It took our gestures, our clicks and keystrokes, and did exactly and literally what they encoded. Click meant click. The graphical interface made that interpretation feel like handling real objects, but underneath it was still interpretation. The new turtle is different in kind: the machine has begun to collaborate. It guesses at intent, fills gaps, proposes things you never specified.

The strange part is that we were rehearsed for this. In the 1990s, two Stanford researchers, Byron Reeves and Clifford Nass, ran experiment after experiment showing that people treat computers like real people: extending politeness to them, ascribing personalities to them, reacting socially to machines they knew perfectly well were only machines. They called it the Media Equation. We were talking to our tools as though something were listening long before anything was. Which is why the fantasy is so old and so calm. Nobody in Star Trek resents the ship's computer. You ask, it answers, it hands you the near-infinite, and no one finds it uncanny. AI is that ancient fantasy meeting a social reflex we were already carrying.

Everyone's final answer

There's a pattern in all this that should keep us honest, me most of all.

Every rung came with the same announcement. BASIC would make everyone a programmer. The spreadsheet would make everyone an analyst. Hypertext and the web would dissolve the distance between having an idea and publishing it to the world. Then Flash, then HTML canvas, then responsive design, then design systems and tokens, each one sold as the thing that would finally end translation and unite what we imagine with what ships. The industry-standard design tool we skipped in the last piece was itself hailed, not long ago, as the bridge that would at last join design and development.

Every one of them was a turtle. So is this one.

That's not a reason to doubt that AI changes the work. It plainly does, and the rest of this series is about how. It is a reason to distrust anyone, including me, who tells you this is the change that ends all the others. The history is the humility. We have stood on a "final" turtle many times before.

The shape of the whole climb

Step back and take the seventy years in at once, and one shape stands out.

Every turtle put the medium more within reach and, at the very same moment, further out of sight. The punch card you could hold in your hands; the charge in the silicon you cannot. The command line you had to understand; the desktop let you forget it existed. Each rung bought reach by spending contact, and then by spending visibility. We got closer and closer to just saying what we mean, and we could see less and less of what was actually happening beneath us.

Which raises a question the cheerleaders tend to skip.

We are standing now on a rung where the medium has very nearly stopped resisting us at all. You say what you want, and it appears. That's supposed to be the happy ending.

It might be the dangerous one.