West of House
You are standing in an open field west of a white house,
with a boarded front door.
There is a small mailbox here.

>

That blinking cursor is 1977. It is also, in a sense, 2026.

The first thing a computer ever asked a person to do — outside of punch cards and toggle switches — was type what you want in English. Not click. Not tap. Not drag. Type a sentence, the way you would tell a friend what to do. Zork, Colossal Cave Adventure, and the whole text-adventure genre were built on a promise that sounds exactly like the promise being made today: describe your intent, and the machine will figure out the rest.

It took nearly fifty years to make good on it. This is the story of the detour.

The Dream Arrived Before the Capability

Will Crowther wrote Colossal Cave Adventure around 1976, mapping a real cave system in Kentucky into a text world for his kids. Don Woods expanded it the following year. The interface was radically simple: you type, it responds.

The parser behind it was radically simple too. Two words. VERB NOUN. TAKE LAMP. GO NORTH. KILL TROLL. The game held a dictionary of a few hundred words and matched against it. That was the entire "understanding".

Zork, written at MIT's Dynamic Modeling Group starting in 1977, was a genuine leap. Its parser handled prepositions, articles, multiple objects, and clause structure. You could write put the lamp and the jeweled sword in the trophy case and it worked. Infocom's marketing leaned on this hard, and deservedly — it was the most sophisticated natural-language interface most people had ever touched. It fit, along with the entire game world, in roughly 100 kilobytes of Z-machine bytecode. Less memory than a single modern emoji font.

And it still broke constantly.

Guess the Verb

Every player of text adventures knows the failure mode. The interactive fiction community even named it: guess-the-verb.

You are in a room. There is a rope hanging from the ceiling. You know — with complete certainty — what you are supposed to do.

> climb rope
You can't go that way.

> pull rope
Nothing happens.

> swing on rope
That's not a verb I recognise.

> use rope
Using things isn't something I understand.

> grab rope and swing
I only understood you as far as wanting to take the rope.

The gap here is not a gap in the player's intent. The intent was perfectly formed and perfectly communicated. The gap is that the machine held a small finite set of acceptable phrasings, and the player had to reverse-engineer the developer's vocabulary. The interface pretended to speak English while actually speaking a private dialect of about three hundred words, and every failure message blamed you for not knowing it.

xyzzy is the purest expression of this. In Adventure, typing that nonsense word teleports you between two locations. There is no way to deduce it. It is not English. It is a magic word in the literal fairy-tale sense — arbitrary, unguessable, and powerful only to those who already know it. An entire generation of computing was built on the premise that you had to know the magic word.

The Two Dead Ends of Early NLP

The research world had already mapped the shape of the problem, and it looked like a fork with no good branch.

The first branch was to fake it broadly. Joseph Weizenbaum's ELIZA (1966) held a conversation with almost no machinery at all — pattern matching and reflection. "I'm worried about my mother." became "Tell me more about your mother." It convinced people. Weizenbaum was horrified by how thoroughly it convinced people. It understood nothing, and it scaled to any topic precisely because it understood nothing.

The second branch was to understand deeply, in a world the size of a shoebox. Terry Winograd's SHRDLU (1970) genuinely parsed complex, ambiguous, referential English — "Find a block which is taller than the one you are holding and put it into the box" — resolving pronouns, tracking history, explaining its own reasoning. It was real understanding. It worked in a simulated world containing about nine coloured blocks. Every attempt to widen the world collapsed under the weight of hand-written rules.

Broad and hollow, or deep and tiny. For decades, those were the options. Nobody had a third branch.

So the industry gave up on language. Not loudly, not as a stated defeat — but decisively.

The Graphical Interface Was a Brilliant Surrender

Here is the reframe that I think gets lost in the usual telling of the Xerox PARC story. The Alto (1973), the Star (1981), the Lisa (1983), the Macintosh (1984) — we remember these as a triumph of vision. And they were. But look at what the graphical user interface actually does, mechanically:

It displays the complete set of things you are permitted to say.

That's the trick. The menu bar is a vocabulary list. The toolbar is a vocabulary list with pictures. The dialog box is a form that constrains your sentence into slots the program already knows how to fill. Drag-and-drop removes the verb entirely — the gesture is the command, so there is no verb left to guess.

Ben Shneiderman named the principle direct manipulation in the early 1980s: continuous representation of objects, physical actions instead of typed syntax, immediately visible results. Don Norman gave us affordances — the handle that tells you to pull, the button that tells you to press. Jakob Nielsen's heuristics enshrined recognition over recall: don't make the user remember the command, show them the command.

Every one of those principles is, underneath, the same engineering decision:

The computer cannot understand what the human means — so let us make it impossible for the human to mean anything the computer doesn't already understand.

This is not a criticism. It was the correct call, and it worked spectacularly. It put computers in front of a billion people who would never have learned a command vocabulary. Four decades of interface craft — Fitts's law, information architecture, progressive disclosure, responsive layout, the entire discipline of UX — is the accumulated art of making a constrained vocabulary feel spacious.

But it was a surrender, and it came with a bill.

The Bill Comes Due

Constrain the vocabulary and you cap what can be said. The moment an application becomes genuinely powerful, the GUI starts to buckle under the weight of its own vocabulary list.

Photoshop's menu tree runs to well over a thousand distinct commands. Microsoft Office hit the same wall so hard that in 2007 it threw out the menu bar entirely and invented the Ribbon — an interface whose sole purpose was to make several hundred commands findable again. Enterprise software grew settings pages that need their own search function. Discoverability, the GUI's founding virtue, collapses under scale.

And notice what every single one of these escape hatches turned out to be:

• Office kept growing the Ribbon, then gave up and bolted a "Tell me what you want to do" text box on top of it.
• macOS added Spotlight; Windows put a search box in the Start menu.
• Sublime Text, then VS Code, then Figma, Slack, Notion, Linear and essentially everything else adopted the command palette — Ctrl-Shift-P, type roughly what you want.
• Emacs had M-x in the 1970s and never saw a reason to stop.

A blinking cursor. Type what you want. Every mature graphical application eventually grows a text box in the middle of it, because the point always arrives where showing you all the options stops being possible, and the only remaining move is to let you say it.

Meanwhile the command line never went anywhere. Unix pipes remained the most expressive general-purpose interface ever built, and the reason non-specialists never adopted them is not that they're bad — it's that they invert the burden. The CLI is maximally expressive on the condition that you learn its language, exactly, character by character, with no forgiveness. git checkout versus git switch. Guess-the-verb, wearing a suit.

So the real situation, for four decades, was this:

Both sides of the fork ended at the same wall. Neither could handle a person who knew what they wanted but not what it was called.

The False Dawns

The industry kept trying to reopen the language branch, and kept rediscovering ELIZA and SHRDLU.

Clippy (Office 97) watched for surface patterns and guessed at intent from a fixed decision tree. "It looks like you're writing a letter." Broad and hollow — ELIZA with eyebrows.

Ask Jeeves (1996) invited you to ask a question in plain English and then, behind the curtain, matched it against hand-curated question templates. Ask something off-template and it fell back to ordinary keyword search — which is to say, it asked you to guess the verb after all.

Siri, Alexa, Google Assistant (2011 onward) were the most serious attempt: real speech recognition feeding a real intent classifier. But the architecture was still a finite menu wearing a microphone. Speech to text, then classify into one of N intents, then fill the slots. SET_TIMER(duration). PLAY_MUSIC(artist). WEATHER(location).

Which is why the failure mode was so familiar:

1977    That's not a verb I recognise.

2011    Sorry, I don't know that one.

The same sentence, forty years apart, in a pleasanter voice. The vocabulary grew from three hundred words to a few thousand intents. The shape of the wall did not move.

What Actually Changed

The third branch — the one that didn't exist for fifty years — turned out to be: don't write the rules, model the language.

The transformer architecture in 2017, and the scaling results that followed, produced systems that do not map input onto a fixed grammar at all. There is no intent list. There is no verb table. There is no "I only understood you as far as…" because there is no as far as — there is a model of how language is used, applied to whatever you typed.

The practical differences are the ones that matter, and they are precisely the failures that defined every previous era.

Ambiguity stops being fatal. "Make this bit less shouty" is not in any intent table. It doesn't need to be.

Vocabulary stops being a gate. You don't have to know that the feature is called kerning, or that the command is sed, or that the verb is swing. Describe the effect you want; the naming is the machine's problem now.

Context accumulates. "No, the other one." "Do that again but for the whole folder." Pronouns, back-references, correction mid-flight — SHRDLU could do this in a world of nine blocks. Now it happens in a world without walls.

And the machine can ask. No parser in history could say "do you mean the rope hanging from the ceiling, or the one coiled on the floor?" A parser either matched or it didn't; ambiguity was an error state. A model can treat ambiguity as a conversational turn. That single capability is what converts guess-the-verb into an actual dialogue, because for the first time the burden of resolution is shared instead of dumped entirely on the human.

Full Circle, But Not a Circle

I am writing this in a terminal. Black background, monospace font, blinking cursor, and an agent on the other side of it that I talk to in ordinary sentences. Visually it is indistinguishable from a 1977 text adventure. Functionally it is the thing text adventures were pretending to be.

But it would be wrong to read this as a simple return, with the GUI as a forty-year detour we can now discard. Text is genuinely bad at things the GUI is genuinely good at:

• Showing state. A file tree, a diff, a dashboard, a seating chart — describing these in prose is strictly worse than seeing them.
• Precision. Nobody wants to describe a bounding box in English. Drag the corner.
• Spatial reasoning. "Move it a bit left" is a worse interface than moving it a bit left.
• Speed for the known. If you already know the command and use it fifty times a day, a keyboard shortcut beats a sentence every time.

The GUI was never only a workaround for weak language understanding. It was also a discovery — that some intents are better shown than said. That part survives on its own merits.

What's actually emerging is the synthesis the fork always ruled out. You say what you want in whatever words you have; the system does the understanding, and then hands back the right shape of interface for the answer — prose when prose is right, a table when a table is right, a diagram, a chart, a form, a running program. Language becomes the universal entry point, and the graphical interface becomes the output format rather than the input constraint. Generated per intent, rather than designed in advance for every intent anyone might ever have.

Direct manipulation, without the vocabulary list.

The Magic Word

The deepest thing the old games got right was also an accident. In Adventure, you cannot deduce xyzzy. You either know it or you don't, and knowing it is a property of the person, not the puzzle.

For fifty years that was the actual condition of computing: the machine held a secret vocabulary, and competence meant having memorised enough of it. File extensions. Ctrl-Alt-Del. chmod 755. The difference between Save and Save As. Which of the four nested menus holds the setting you need. A thousand small magic words, each one arbitrary, each one a small tax on everyone who hadn't yet learned it.

We spent four decades building beautiful interfaces whose real job was to hide the fact that the magic word existed — to lay the vocabulary out on screen so you'd never have to guess it, at the cost of never being able to say anything that wasn't already on screen.

The shift now underway isn't that we've memorised more magic words. It's that there stopped being one. You just say what you meant.

> swing on the rope

You grab the rope and kick off from the ledge, swinging
across the chasm in a long arc. You land, slightly winded,
on the far side.

>