Intelligence Is the Interface Now. Design Has to Catch Up.

For most of my career, designing software meant deciding what goes on the screen. Where the button sits. How the navigation flows. Which chart tells the story. The screen was the product, and the craft was in arranging it well.

That assumption is quietly collapsing. In the products I find most interesting right now, the screen is no longer where the value lives. The intelligence is. And that changes what design is actually for.

Concept illustration of a system of intelligence without use of interactive screens, where we design systems with a point of view instead.

The shift, in one sentence

We used to design tools that wait for instructions. We’re now designing systems that form a point of view and act on it.
That sounds abstract until you watch it happen in real products. So rather than argue it in the abstract, I want to look at two companies that get it right from opposite directions, because the contrast between them is the whole lesson.

The shift, in one picture.

From rules defined in advance to a system that decides the path itself.

Attio: when the system surfaces what matters before you ask

A traditional CRM is a filing cabinet with a search box. You put data in, you pull data out, and the quality of what you get depends entirely on the discipline of what you fed it. The interface is a set of forms and lists. The work is yours.

Attio’s recent direction treats that as the problem to solve, not the model to polish. Its AI attributes turn unstructured records into structured judgment, scoring an account’s fit, enriching a contact, synthesizing a call, as fields that compute themselves rather than fields a human fills in. Ask Attio puts a conversational layer across records, emails, and calls, and its MCP support lets external agents create tasks and update records directly.

Strip away the feature names and the move is this: the system stops being a passive database and starts being an analyst. The interface isn’t the table anymore. The interface is the judgment the system brings to the table.

That’s the principle I keep coming back to, the one I’d argue defines good product design now. You’re not arranging data for someone to interpret. You’re architecting what the system notices, and when it speaks. The screen becomes the place that judgment surfaces, not the place the work happens.

Restraint made literal.

Routing each request to the smallest model that fits, as a design and footprint choice.

Linear: restraint is what makes intelligence trustworthy

Here’s where most thinking about AI products goes wrong. The instinct is to add: more suggestions, more automation, more agent surface area. Linear is the counter-argument, and it’s the more important half of the story.

Linear has spent years building a reputation on opinionated design, one good way to do things, deliberately few knobs to turn. As they’ve moved into AI, that philosophy didn’t soften; it became the foundation. Linear now treats coding agents like Cursor and Codex as first-class users. You can assign an issue to an agent the way you’d assign it to a person, and watch what it’s doing. Their triage intelligence quietly sorts the backlog. Teams at companies like OpenAI and Ramp build alongside these agents inside the tool.

What makes that work isn’t the agents. It’s the opinion. Because Linear is strict about how work is structured, an agent operating inside it has clear rails. It knows what an issue is, what a cycle is, what “done” looks like. The constraint that some people read as a limitation is exactly what lets autonomous behavior stay legible instead of turning into chaos.

This is the part the hype cycle skips. Flexible systems let everyone invent their own workflow, which is charming at five people and catastrophic at five hundred, and it’s fatal the moment you hand that ambiguity to an agent that will happily act on it. An agent inside a loose system amplifies the looseness. An agent inside an opinionated system inherits the opinion. Restraint isn’t the absence of design. In an agentic product, restraint is the design.

What this asks of designers

Put the two together and the new job description writes itself. Attio shows that the interface is increasingly the system’s judgment, not its layout. Linear shows that judgment is only trustworthy when the system has a clear, opinionated point of view about what it will and won’t do.

So the questions I’m designing around now look different than they did three years ago:

Not “what should this screen show?” but “what should the system notice, and what should it stay quiet about?”
Not “how do we give users more control?” but “where is human judgment actually required, and where is asking for it just friction?”
Not “how flexible can we make this?” but “what opinion does this product hold, and is it strong enough that an agent acting on our behalf won’t embarrass us?”

The craft hasn’t disappeared. It’s moved. It used to live in pixels and flows. Now a lot of it lives in constraint and behavior, deciding what the system perceives, when it acts, when it defers, and how it explains itself. Explainability is becoming as much a design surface as visual hierarchy ever was.

Restraint is also a responsibility

There’s a version of this argument that gets framed purely as governance: audit trails, the EU AI Act, human-in-the-loop checkboxes. That’s real work, but it’s not the part that belongs to designers, and I’d rather not pretend it is.

The part that does belong to us is quieter, and it connects directly to the restraint Linear models. Every time a system chooses to compute an inference, surface a suggestion, or run an agent in the background, there’s a cost, and not only the cognitive cost of one more thing demanding the user’s attention. There’s a literal one. The energy and water behind large models is an ethical dimension of AI that still gets far too little attention from the people designing the experiences that trigger all that computation. A product that calls the model on every keystroke isn’t just noisier than one that calls it when it matters. It’s heavier, in a way that has a footprint.

I spent a decade working close to sustainability and ESG, and the thing that stuck with me is that the most credible environmental decisions are usually the unglamorous ones made early, by people who weren’t required to make them. For a designer of intelligent systems, that decision is increasingly: does the system need to act here at all? Designing an agent to stay silent, to compute less, to defer to a cheaper path when a heavier one wouldn’t change the outcome, that’s a sustainability choice dressed as a UX choice. The same instinct that makes Linear’s restraint feel trustworthy makes it lighter. Good behavior and good footprint turn out to be the same discipline.

That’s the version of responsible AI I find worth designing toward. Not a compliance layer added at the end, but a bias toward enough: enough intelligence, surfaced at the right moment, and no more.

Concept illustration of a system of intelligence without use of screens, where voice UX takes the main stage.

The throughline

The temptation with AI is to treat it as a layer you add on top of a finished product: a chat box in the corner, a “summarize” button, an agent bolted to the side. The products that feel genuinely new don’t do that. In them, the intelligence isn’t on the interface. It is the interface.

Designing for that means giving up the comfort of the screen as the unit of work, and picking up something harder: responsibility for how a system behaves when no one is watching it. That’s less like decorating and more like governing.

And the screen is about to matter even less. In 2026 the entire industry is pushing toward ambient computing. Google, Meta, and Apple are all moving on AI glasses, audio-first wearables, devices meant to bring assistance into the world you’re already walking through rather than asking you to stop and operate a rectangle. The whole premise is an interface that doesn’t demand you look at it. When that lands at scale, “intelligence is the interface” stops being a turn of phrase. It becomes literal. If there’s no screen to arrange, then judgment, timing, restraint, and trust aren’t part of the design. They’re the entire thing left to design.

That’s the future I’d point any design team toward now, well before the hardware is in everyone’s pocket or on their face. The teams that learn to design behavior, what a system notices, when it speaks, when it stays quiet, what it costs to act, on today’s screens will be the ones ready when the screen quietly disappears. The ones still arranging dashboards will be designing for a surface that’s on its way out.

So the most interesting design problem of the next few years isn’t making AI look good. It’s making it behave well: usefully, legibly, and with a sense of restraint that’s equal parts good taste and good citizenship. The screen was always just the visible part. What we’re really designing now is the judgment underneath it, and soon, that judgment will be all there is.