Why your agentic product still feels like a regular app.

Most of us have read the same essays on agentic UX, sat through the same kickoffs, written briefs that genuinely promised something AI-first. We know what we're trying to do. Then a month into the work you look at the build, find yourself staring at a CRUD form with a chat box bolted onto the side, and have a hard time explaining how you got there.

What pulled you back is a pattern worth naming. I've started calling it the deterministic default: an unconscious gravity that drags every interaction toward forms, buttons, and view-edit-save loops, even when the brief was explicit about wanting the AI to take initiative. This happens to careful people. Every designer I know who has actually shipped serious AI work has felt it pulling at them at some point, and most of us have lost a round or two to it before learning to recognise the moment it's happening.

The rest of this piece is about what the pattern actually is, why it pulls so hard on teams that should know better, and how to spot the slip in your own work without throwing out the rest of your judgment along the way.

What I mean by "the deterministic default."

A deterministic surface is one where the user makes a choice and the system carries it out exactly as instructed. Click "send invoice" and the invoice goes. Click "generate report" and the report appears. The interaction is predictable, contained, and demands very little trust from the user, which is one of the reasons software has looked like this for most of the last fifty years. Every designer working today learned the craft inside that paradigm, and the conventions that come with it are the most well-rehearsed muscle most of us have.

An agentic surface has a fundamentally different shape. The user expresses an intent, sometimes ambiguously, and the AI takes initiative to satisfy it. The AI might ask a follow-up question, might make a decision inside its lane, might surface what it did and let the user accept or reject or refine the result afterward. Authorship is genuinely shared, and trust is something the product earns over many small competent moves rather than something it asks the user to grant up front before anything has happened.

The deterministic default is what shows up when you sketch an agentic surface and unconsciously translate it back into determinism without realising you've done so. The chat input quietly becomes a glorified search bar. The thing labelled as an AI suggestion turns into a button you press to populate a form field. The whole flow routes itself back to deterministic patterns because those are the only patterns your hand has finished sketches for, and the agentic equivalents are still being figured out by the field at large.

Why even AI-first teams slip back into it.

Three forces pull every team back toward deterministic patterns, and they tend to stack rather than cancel each other out.

The first is mental models. After roughly a decade of internalising GUI conventions like nav on the left and primary action top-right and undo via cmd-z, your hand reaches for those patterns automatically. Those models are good ones, and a meaningful part of why software is usable at all. The trouble is that agentic patterns don't have settled equivalents yet, and the moment you stop deliberately reaching for new vocabulary, your hand finds the old vocabulary because that's where the muscle memory lives.

The second is stakeholder bias. PMs and executives naturally ask for screens they can show in a demo, and screens are far easier to demo than agency. So when you bring a real agentic flow to review, the kind where the AI actually takes a non-trivial action without confirming first, half the room reaches for some version of "but how does the user know what just happened?" That question is fair, and at times genuinely important. The trouble is that the version of the answer that ships fastest involves adding a confirm dialog, while the version that respects the original intent requires designing the trust signal so well that the confirm dialog becomes the wrong move, and the second version is harder to defend in the moment.

The third is engineering velocity. Patterns whose APIs have matured ship faster than patterns that haven't. Auto-complete shipped years ago and the framework primitives exist for it; multi-step agent loops with mid-flight clarification are still being figured out across the industry. Choosing the unfamiliar pattern carries a real cost, while choosing the familiar one carries a real reward, and that's a structural pull rather than a moral failure on anyone's part. Pretending it doesn't exist is the surest way to lose to it.

These forces stack, and none of them is bad on its own. Taken together they make the deterministic default feel like good engineering hygiene rather than a slip, which is precisely what makes the slip so difficult to notice while it's happening to you.

A quick aside on what this isn't.

Two failure modes are worth naming before going any further, because they're symmetric and easy to confuse with each other.

This piece isn't an argument that every product should be agentic. Most shouldn't. A bookkeeping tool, a calendar app, a CRUD admin panel: these are deterministic by design and the user actively wants them that way. Forcing agentic patterns onto a product where the user values exactness and direct control is its own slip in the opposite direction, and the field already has a name for it: AI-washing. You can spot AI-washing the same way you spot the deterministic default, by asking whether the new pattern actually serves the user better than the one it replaced. If the honest answer is "no, but it lets us call this an AI product," you're on the wrong side of the line.

The point of this piece, then, isn't that agentic patterns belong everywhere. The point is that they belong somewhere, and the slip I'm naming happens specifically when you set out to design an agentic surface and quietly end up shipping a deterministic one anyway, without noticing the trade and without making it on purpose.

How to spot the slip in your own work.

Three diagnostic questions help me find this slip in my own designs and in team reviews.

The first is whether the AI is taking initiative or just acknowledging button presses. If every AI action sits downstream of an explicit user click, what you've actually built is a deterministic surface with AI labels stuck on top. The AI isn't doing anything that the user couldn't have triggered with a regular function call somewhere else in the product. Real agentic surfaces have moments where the AI moves first, drafting or flagging or summarising or suggesting a next step, without being explicitly asked to do so each time.

The second is whether the chat input is doing real work or just running search. Chat is the most over-designed surface in modern software, and it deserves more scrutiny than it usually gets in design review. If your chat input mostly returns content the user could have found in two clicks of regular nav, what you have is a search bar with a typing indicator. Agentic chat does things rather than showing things. The Salsify work I led on Angie reframed the chat surface around action verbs like review, fix, and flag, rather than around noun lookups, and the difference in how the surface read to users was substantial.

The third is whether the AI's authorship is visible anywhere in the design. On a deterministic surface, the user owns every output by default. On an agentic surface, the AI owns some of them, and the design has to make that visible if it wants the trust contract to hold up over time. If your design has nowhere for the AI to say "I drafted this" or "I changed this attribute, and here's why," with no audit log, no provenance markers, and no trust-building seam at all, what you've built is a surface that pretends the AI isn't really there. Which means the AI isn't really doing anything in any meaningful sense.

I missed all three on a flow I'd been working on for weeks. The brief said agentic; my surface had quietly become a parade of confirmation dialogs. The catch came from a teammate during a casual review, who said the line that reset the entire design: "so the AI just asks permission for everything?" The next pass replaced four confirms with one audit panel, and the surface finally read as a copilot rather than a checklist.

The reversibility rule I drew on Angie sits next to this lens. AI auto-fixes when consequences are reversible, surfaces things for human judgment when consequences are reputational, and stays out entirely when consequences are regulatory. That rule turns out to be a prerequisite for letting the AI take initiative without a confirm dialog at every step. Without it, you reach for confirms because you don't actually trust the AI enough to let it move; with it, the confirms quietly drop away on their own as the trust contract starts doing the work that the dialogs used to do badly.

A pre-AI version of the same instinct shows up on the OneClick shift-management redesign, where the new product surfaces opinionated smart defaults rather than asking users to pick from every available choice on every screen. The new defaults out-performed the old power-user shortcuts by a clear margin, and the team gained roughly 18% market share in the period that followed. Letting the system make a sensible first move when the cost of being wrong is a click to revert is the agentic instinct in deterministic clothing, and the principle was travelling well before the technology caught up enough to make it look like an AI feature.

The fix. Accept feedback gracefully, then prototype rapidly.

The first step is the unglamorous one. Accept the feedback gracefully when it comes, whether it lands during your own mid-design pause, in a PM review, or from a teammate squinting at the prototype on a Tuesday afternoon. The deterministic slip isn't a craft failure on your part; it's a default that everyone working in the field is fighting at the moment. Pretending you're somehow above it is what makes it harder to spot the next time it happens to you, which it will.

The second step is the move that actually unsticks the design. Prototype rapidly, and use AI as a moodboard rather than as a producer.

The workflow I use looks roughly like this. Take the design file you're stuck on, the 90-percent-agentic flow that keeps slipping the last ten percent into deterministic patterns. Hand it to Claude or another capable model and ask it to redesign the flow from scratch, agentic-first, without borrowing any conventions from the existing surface. Run three or four variants from genuinely different framings, and resist the urge to critique each one as it appears; let them all surface before you start picking. Then treat the variants as inspiration rather than as source material. The AI's first agentic instinct is often as overcooked as your first deterministic one, but the overcooked version surfaces patterns you wouldn't have reached on your own, which is the entire point of the exercise. Pull the moves that work, drop the rest, and make the next version yours.

The point isn't to ship the AI's design. The point is to use the AI to break the loop that your own pattern memory has put you in. Once the canvas of your mind has new sketches on it, the deterministic gravity weakens. Not gone, never quite gone, but weakened enough that you can make the next call on purpose rather than by reflex.

One more counterargument, resolved.

The critique I take most seriously is that agentic UX doesn't have proven patterns yet, which means that designing it is at least partly guessing. That's true, but the same has been true of every paradigm shift in interaction design before this one, including direct manipulation in the eighties, the mouse, the touch screen, and the conversational interface itself. The skill that travels across those shifts isn't pattern memorisation; it's recognising when conventions are guiding you well and when they're quietly holding you back from a better answer.

What I'd add to the critique is that principles travel even when specific surface decisions don't. The reversibility rule from Angie is a principle, while the specific button placement on the suggestion card is a surface decision. The principles you write down while shipping AI work are the asset that keeps compounding for you and your team, because the surfaces themselves will get redesigned next quarter when the model improves anyway. Build for principles to outlive surfaces, and the deterministic-slip problem gets quietly smaller every cycle.