A few months ago I sat in a design review for the next version of an AI assistant. We had the usual things: a Figma file, a backlog of open questions, a whiteboard buried under arrows. About an hour in, I noticed something I couldn’t un-notice. Nobody had mentioned a button.
That should sound trivial. It isn’t. I have spent an embarrassing share of my career arguing about buttons. Primary or secondary. Filled or outlined. Where it sits, what it says, how it behaves when you can’t press it. For twenty years that was the texture of the work, across stakes that had nothing else in common: a newsroom that never slept, a studio report written for two hundred million people, a fashion storefront. Different worlds, same arc. Take something ambiguous and narrow it, patiently, into an artifact you could point at on a screen and ship.
We never got near a screen. The conversation kept sliding somewhere else, and an hour in it settled on a single question someone raised almost offhand. A guest is standing in a hotel lobby and asks the assistant about changing a reservation. Does the system answer the question it was asked, or does it assume the person is trying to do something and move them toward the change itself?
We spent twenty minutes there. Not on layout. On what the system should assume, how sure it should be before it takes the lead, and where helpful tips over into presumptuous. Nobody opened Figma. The strange part, the part I kept turning over afterward, is that it was the most design-heavy conversation I’d had in months. We were making the decisions that would decide whether the thing felt good to use. We just weren’t making them on a screen.
I tried to talk myself out of the feeling. Designers have always worked on systems. Information architecture wasn’t invented last year, and user flows and decision trees have been part of the craft for decades. But the easy explanation didn’t hold. Every system I had designed before was a structure that eventually resolved into a screen, one artifact we would argue about and ship. This was a structure that might resolve into a hundred different screens, depending on who showed up, what they needed, and how sure the system was that it understood them. The interface wasn’t the thing we were designing. It was a byproduct of the thing we were designing.
Which left a question I couldn’t put down.
When did the screen stop being the thing?
For most of my career it was the thing. Every project narrowed toward it. Ideas became layouts, layouts became interfaces, interfaces became the product. I never questioned that progression, because it was the whole shape of the work. The screen was where every argument finally met and got settled.
What that meeting made obvious is that the meeting place has moved. The interface still matters, probably more than ever. But it is no longer where the hardest decisions live. They sit one layer up now, in how the system behaves: what it pays attention to, what it remembers, when it acts and when it waits, what it does when it isn’t sure. Software used to not really make those decisions. Now it makes them constantly, and someone has to be responsible for how good they are.
That someone, increasingly, is a designer.
I learned the underlying lesson long before any of this, in entertainment. You can build a story with enormous care and people will still receive it through their own context: their assumptions, their bad morning, their reason for showing up that day. Two people watch the same film and walk out with different films. For years, software fought that variability with structure. Menus, flows, onboarding, ever-more-elaborate ways to march everyone down the same path. An adaptive system stops fighting it and meets the person in front of it instead of the average person we imagined. That is the opportunity and the catch in the same breath, because the moment software can decide, a confident wrong decision is worse than an honest dead end.
Designing for that is closer to coaching than to drawing.
You are not specifying every move. You are setting what the system values, what it does under uncertainty, when it should hand control back to a person. The skills that suddenly carry the weight are not new ones. Reading intent, cutting complexity, deciding what someone should see instead of more text, knowing what matters and what doesn’t. They used to hide under the surface of the screen, where they looked like layout calls. The screen moved, and now they are sitting in the open.
I spent twenty years learning to design what software shows. The work in front of me now is designing how it behaves. I didn’t notice the line get crossed until I was already on the other side of it, in a room full of smart people, ninety minutes deep, and no one had mentioned a button.