Beyond the Silicon Door

Two screens

The same interface, thirty-seven years apart

Two screens, thirty-seven years apart.

The first is a pencil sketch in a notebook I kept in 1981: a title bar that reads CORNWALL, a box for the description, a line at the bottom for input. No menus, no pages. You type; it answers. A note beside it says to print the description only once, unless the player asks to look.

The second is a roadmap I made at Precima in December 2018. Its last stage, AI Dashboard 3.0, is one screen and a conversation, with an interface the system generates for each person and need. No more pages.

There was no moment of recognition. The goal never left me: no predesigned pages, just conversation, with the system drawing whatever interface or picture the moment needs. Semantic language and on-demand visualization. The technology is only now catching up.

The Silicon Door told the story of the notebooks. This is what I took from them.

Need of user

Two needs on one page

The same notebook had already split the problem in two. A page headed VOCABULARY says it plainly.

NEED OF PROGRAM: CRYPTIC BREAK-DOWN OF WORDS INTO MATHEMATICAL COMPONENTS, THUS USEABLE BY THE PROGRAM. NEED OF USER: VERBOSITY AND FLUENCY OF PROGRAM. At the bottom, in brackets, a fluent response to questions CREATES BETTER IMAGE FOR PROGRAM.

I didn’t have words for it then. The field was still finding its own: user-centred design was set out in a 1986 book, and user experience became a job title in 1993.¹ But the split on that page is the one I’ve worked inside ever since. A machine needs meaning it can compute. A person needs to be understood in their own words, and to see what matters without hunting for it.

The bracketed line is the one I’d underline today. Fluency makes people trust a system. In a text game that was a nice touch. In AI it’s the central problem, because language models are fluent even when they’re wrong.

The physics, not the path

Rules that let a world respond

My game wasn’t a script. It was a world with rules. The math came from Dungeons & Dragons, which I played devoutly: hit points, constitution, damage subtracted as it landed.² The idea that a computer could hold a world like that came from Zork, which gave every object a weight and capped what you could carry.³

One page lists what governs movement: ENCUMBRANCE, TERRAIN, CONSTITUTION, SPELLS, MAGICAL ITEMS. Another gives a jar of grease its properties and lets the world decide the rest. It makes some floors slippery and soaks into others. It oils old machinery. A certain beast will eat it and become your friend. It burns. And an entry headed CARMA has the program keep a list of what the character does and decide its personality from that record.

Nothing in that design says which screen comes next. It sets the physics and lets the path emerge. That’s the principle I carried into enterprise software: design the physics, not the path.

At Precima it meant one screen that read across pricing, promotion and assortment and told each role what mattered, instead of separate tools with their own pages. At IBM it meant arguing against chat windows bolted onto products, and for AI built into the work itself.

Carry

Context has to survive the next sentence

The first thing a conversation needs is memory. My rule for pronouns is on a page full of sketches: CHECK LAST NOUN IN MEMORY THAT CORRESPONDS TO PRONOUN. Keep the nouns the player has used, and when “it” arrives, reach back for the most recent one that fits.

Without that, every sentence starts from zero. Most software still works this way. Each page forgets the last one: the filters you set, the thing you selected, the question you were halfway through. At Precima, the Watson prototype I built knew which page the person was on. At IBM I pushed product teams for persistent context and selections that carry from one tool to the next. It’s the same variable, at a different scale.

Guess

When the last noun is the wrong one

Recency breaks fast. Take the cup off the table and wash it: the last noun is table, and you mean the cup. The same pronoun page already had the hard case.

Beside HE EATS FAST it asks DOES TOM OR MARK EAT FAST, and answers: IN MEMORY FROM CONVERSATION. A good guess needs more than the last word. It needs what fits, what the conversation has already settled, and a sense of priority. In my arrays, as I remember them, an object’s attributes sat in a fixed order, and the earlier ones decided first.

That’s a small version of a problem the field kept working on. SHRDLU checked candidates against its world of blocks. In 1994, Lappin and Leass published a pronoun method that scores each candidate on weighted factors and drops the ones that don’t agree.⁴ Today’s models learn those weights from data. At Precima, the working prototype did a version of this at enterprise scale: it chose which data models should answer a question, and replied in plain language.

Say

Show the guess

A guess is only safe if you can see it. Around 1970, Terry Winograd’s SHRDLU, a program you could talk to about a world of toy blocks, did this out loud. When it had to choose what “it” meant, it told you what it had assumed: BY “IT”, I ASSUME YOU MEAN THE BLOCK WHICH IS TALLER THAN THE ONE I AM HOLDING.⁵

Saying the assumption turns a hidden error into a question the person can answer in one word. One designer’s choice then is design guidance now: Microsoft’s 2019 guidelines for human-AI interaction tell designers to make clear why the system did what it did.⁶ At Precima the dashboard led with its reasoning: here’s what you should do, and a path to show me why.

Correct

Let the person fix it

The last step is the one most systems skip. At IBM I defined how AI behaves when it’s uncertain or wrong: how people check its sources, how an answer becomes structured work they can edit, and how they recover when it misses. The answer isn’t a verdict. It’s a draft the person owns.

Correction needs depth on demand. My notebook gave each object a limited description, a standard one and an extended one, and showed more only when the player asked to look. Zork, which I played, had the same three settings, and the Xerox Star team named the idea in 1982: progressive disclosure.⁷ At Precima it became three steps into the evidence: here’s what you should do, show me why, I need more.

The limit

Fluency without grounding

All of this rests on a limit I understand better now. In my notebooks every word was an empty node defined by other nodes, and every chain of links ends in a bare label or loops back on itself. The cognitive scientist Stevan Harnad named this the symbol grounding problem: symbols defined only by other symbols never reach the things they stand for.⁸ He argues it holds for today’s language models too.

Put that beside the line in my notebook about fluency, and you have the design problem of this decade. A system can sound as if it understands without understanding. The fix isn’t to make it sound less sure. It’s to carry context honestly, show the guess, and make correction easy, so the trust it earns is deserved.

What lasted

Two needs, unchanged

The machinery is unrecognizable now. Google’s generative UI, released in November 2025, builds an interface for each prompt.⁹ Conversation is becoming the front door to software, and the screen is starting to draw itself. That’s the direction I sketched at Precima, and it started on a ruled page in Rosemère. Parallels, not influence. What I’d claim is narrower: the two needs on that page haven’t changed.

The program needs meaning it can compute. The person needs to be understood, and to trust what they’re shown. Everything I’ve designed since has lived between those two lines.