The Mental-Model Reset: Designing Systems That Decide

Here’s where I see most design orgs right now, (including mine, which is in transition): they’ve treated AI as a feature. Somebody added a sparkle icon, a chat panel slid in from the right, the deck went to the exec team, done. The designers on those teams are still operating with fully deterministic instincts — enumerate the states, spec the flows, polish the artifacts, but apply them to a system that doesn’t hold still.

It mostly works, for a while, because a chat panel is a deterministic frame around probabilistic content. The frame behaves. And so nobody’s mental model gets challenged until the day the product roadmap says the word agent, and suddenly the thing inside the frame is taking actions, composing interfaces, making calls your team never reviewed.

Maggie Appleton called the chat-panel reflex what it is, back in 2023, in her Language Model Sketchbook:

The comparison every leader reaches for is mobile. We survived responsive design, we survived native apps, we’ll survive this. It’s a comforting analogy, and I think it’s wrong, and it’s worth being precise about why it’s wrong, because the analogy is exactly what lets teams underestimate the reset.

Mobile changed the constraints: screen size, input method, context of use. It was a hard decade. But through all of it, one thing never moved — the button you shipped did the same thing every time anyone tapped it. Your design was a contract, and the software honored it identically for every user, every session. Determinism survived mobile untouched.

Jakob Nielsen’s historical framing is the clearest I’ve found. In AI: First New UI Paradigm in 60 Years, he counts exactly three UI paradigms since 1945: batch processing, then command-based interaction from about 1964. He’s explicit that command lines, GUIs, and every smartphone platform are all the same second paradigm. Mac, Windows, iOS: one continuous era of “user issues a command, machine executes it, repeat.” The third paradigm, what he calls intent-based outcome specification, is the first genuinely new one in sixty years: the user states the outcome they want, and the system decides how to get there. As Nielsen puts it, this “completely reverses the locus of control.”

Pause here for a moment.

In Nielsen’s accounting, the mobile revolution, the one that restructured our teams, our tools, our titles, doesn’t even register as a paradigm change. It was a form factor change within the same paradigm.

Retrospectively, this rings true.

The deepest assumption in a screen designer’s head is so deep it doesn’t feel like an assumption: same input, same output. Every QA plan, every acceptance criterion, every “can I see the error state?” in every crit you’ve ever run assumes it.

A model-backed system breaks it by design. The output is a draw from a distribution: usually good, sometimes great, occasionally bizarre, and no amount of craft on your side makes it stop being a distribution.

Josh Clark and Veronika Kindred’s Sentient Design is the most complete treatment of this I’ve read, and its central move is the right one: treat AI as a design material, with a grain and a texture and characteristic weaknesses, the way HTML or ink or steel have weaknesses.

In Clark’s talks, the material properties are echoed: the system is probabilistic, not deterministic; it’s better at interpreting and transforming than at knowing. Designing with it means defensive design, accommodating failure and uncertainty as a first-class part of the work, not as an edge case cleanup pass.

I’ve found the fastest way to make this land with a team is not to explain it but to show the spread. Run the same prompt in your favorite UI generation tool twenty times and pin the outputs side by side. The reaction goes discomfort, then laughter, then somebody asking the real question, “So which one of these did we design?”

None of them…
…All of them?

You designed the possibility space — and if that sentence feels uncomfortable, good.

That’s the mental-model reset happening.

Clark and Kindred call the far end of this radically adaptive interfaces, experiences that reshape their content, structure, and interaction in real time against the user’s intent. NN/g’s less-imaginative term is generative UI, and their conclusion matches what we ran into at Mural almost word for word: when the interface is assembled at runtime, designers need to shift to outcome-oriented design, defining the goals, constraints, and rules the generation must operate within, rather than the discrete elements themselves.

There’s another thing that breaks, and it’s the one that turns this from a craft problem into a leadership problem: these systems act.

Not render. Act.

They send the email, run the code, reorganize the data. The industry noticed this in 2023 and named it “agentic,” but the design thinking is older: Christopher Noessel mapped this territory in Designing Agentive Technology back in 2017, studying systems that do things for you while your attention is elsewhere, and he’s been explicit recently that today’s agentic AI is the same discipline with a vastly more capable engine.

Noessel’s phrase for the shift is that agentive tech means “giving users a promotion”: the user moves from operator to manager of the work. And a manager needs an entirely different interface than an operator does. Working from his framework, the design surface stops being “the flow” and becomes a set of questions almost none of our existing patterns answer:

• Setup and tuning: how does a user express preferences and constraints to something that will act unsupervised?
• Visibility: how does the system expose its plan before, during, and after it acts?
• Handoff and takeback: how does the user grab the controls mid-task, and how does the agent gracefully return them?
• Decommissioning: how does someone wind down an agent they no longer trust or need?

Read that list again and notice: every one of those is a relationship problem that just happens to manifest in screens. That’s the promotion your design team is getting, whether they asked for it or not — the same promotion the user got.

But the pendulum can’t swing all the way the other direction. Deciding is not binary, and the mental model reset is not “make everything adaptive.”

Determinism is now a design decision instead of a default, which means somebody has to actively choose where the product stays fixed, predictable, boring. The primary toolbar should probably behave the same way every single time. The billing flow, absolutely. Guardrails, undo, confirmation on consequential actions. Google’s People + AI Guidebook has an entire chapter on errors and graceful failure that reads like it was written for this moment, and its core stance is the right default: assume the system will be wrong, and design the recovery path with the same care you design the happy path.

Choosing where the product does not decide is as much a part of the new mental model as accepting where it does.

This is the before/after worksheet: one column of deterministic instinct, one column of what replaces it. Run your team through it against a real surface (instructions in the next section), not as an abstract reading exercise.

Two notes on using it. First, the left column is a list of correct ideas for the last thirty or forty years of software, held by your best people most firmly, because their careers were built on being right about them. Treat the unlearning with respect or it won’t happen. Second, rows 5 and 10 are organizational, not craft. They will create new questions about ownership and staffing that a worksheet can’t answer. Capture those and take them offline. Don’t let them derail the session.

As a profession, we’re all working through this reset. I’m in the midst of it with my org, and here’s my plan: This is a 60 to 90-minute working session plus about an hour of prep. I’m writing it as instructions you can share.

1. Pick one real surface. A live AI feature in your product, or the roadmap item closest to shipping. Decision point: if the only AI you’ve shipped is a chat panel, use the chat panel — but review what happens inside and after it, not the frame around it. Do not use a hypothetical. Hypotheticals let everyone stay comfortable.

2. Prep: run it twenty times. If the feature is live: Before the session, have one designer run the same realistic input through the surface twenty times and screenshot every output. (If you’re pre-ship, use the staging build or even raw model outputs — fidelity matters less than variance.) Pin all twenty on a board, unlabeled. Trade-off: twenty runs of one input beats five runs of four inputs. You’re teaching the team to see a distribution, and a distribution needs depth to be visible.

3. Open with the spread. First ten minutes: everyone looks at the twenty outputs and individually sorts them into three piles — great, acceptable, not okay (a product like Mural is great for this). No discussion yet. If the twenty outputs are essentially identical, you picked a surface that isn’t actually probabilistic — swap it now, or the whole session becomes theater.

4. Fight about the piles. Next thirty minutes: compare sorts. The disagreements are the entire point . They expose that your team has no shared quality bar for a distribution, because they’ve never needed one. Write down every disagreement as a draft rubric line (“an analysis that omits the data source is not okay, even if the summary is good”). You will leave this session holding your first informal eval spec, and most teams don’t realize that’s what they built until you tell them.

5. Run the table above against what they just saw. Next twenty minutes: go through the ten rows above and, for each, ask “where did we watch this assumption break in the last hour?” Rows that connect to a specific pinned output will actually stick. Rows that don’t connect, skip without guilt.

6. Rewrite three crit questions. Last twenty minutes, and this is the piece that makes the reset durable instead of a nice workshop: pick three questions your team asks in every design review and rewrite them for probabilistic surfaces. Ours: “Can I see the error state?” became “What’s the worst plausible output, and what happens in the next ten seconds after it appears?” “Why this layout?” became “What rules generated this layout, and what else could they generate?” “Is the copy final?” became “What are the boundaries on what the system is allowed to say here?” Trade-off: rewriting the crit changes behavior faster than any training deck, but it only works if you, the leader, actually ask the new questions in the next review. The first time you ask “can I see the screen?” out of habit, the old model reboots itself.

7. Assign the two follow-ups. One: someone turns the pile-sorting rubric into a real conversation with your engineering partner about evals — the draft you made in step 4 is the input. Two: someone maps where the product should stay deterministic — the surfaces where adapting would be a bug, not a feature. Both have owners and dates before anyone leaves the room, or neither happens.

That’s it. One Mural board, one enlightening (and possibly fun) meeting. What you’re buying is a team that stops bending AI work back into screen-shaped thinking — which is the prerequisite for every tactical skill you’ll want to build next.

• AI: First New UI Paradigm in 60 Years — Jakob Nielsen, NN/g The historical argument that this shift is categorically bigger than mobile. Useful for big group conversations.
• Designing Agentive Technology — Christopher Noessel, Rosenfeld Media The 2017 playbook for systems that act on the user’s behalf. The setup/handoff/takeback framework holds up remarkably well.
• Agentive Tech and Agentic AI: Cousins Not Adversaries — Christopher Noessel Noessel connecting his 2017 framework directly to today’s agents.
• Sentient Design — Josh Clark & Veronika Kindred, Rosenfeld Media The richest treatment of AI as a design material and radically adaptive interfaces. This is the book I’m recommending for this moment.
• Sentient Design: AI and the Next Chapter of UX — Big Medium Clark’s talk version: a faster on-ramp than the book for a team lunch-and-learn.
• Language Model Sketchbook, or Why I Hate Chatbots — Maggie Appleton The best short piece for jolting a team out of chat-panel defaults. And I generally lover her writing.
• Generative UI and Outcome-Oriented Design — NN/g Practical framing of runtime-generated interfaces and what “outcome-oriented” design work actually consists of.
• People + AI Guidebook — Google PAIR Especially the errors and graceful-failure guidance. The most actionable material on designing for a system that will sometimes be wrong.

Back to the design review. We’re in a world where there is nothing to mock up. What teams will eventually bring back instead are a set of rules: What an agent-built analysis must always include, what it may never claim, which pieces of the interface stay fixed no matter what the agent decides, and what the user grabs when they want the controls back.

These will be the least screen-like design deliverables we’ve approved as leaders. And I’m increasingly convinced this output will be the most designed — because every rule in it is a decision about someone’s experience, made deliberately, ahead of time, exactly like our craft has always demanded.

Like jazz, or improv, the performance changes every night now. Embrace the riff. Design the stage.