Enterprise UX in the Age of AI (Part 1)
Part one of a series on designing the tools behind the business, and what Gen AI and agents change (and what they don’t)
I’ve spent more than 25 years designing digital experiences for complex organisations: the internal platforms, workflow tools and data-heavy systems that employees rely on to get real work done. Over the past year, I’ve been giving a talk about the principles behind that work. And no matter the audience, one question comes up every single time:
“Doesn’t AI change all of this?”
It’s a fair question. Interfaces are learning to talk and agents are learning to act, with whole workflows being rebuilt around models that didn’t exist three years ago. If software can simply do the work, why sweat the design of the screens?
Here’s the truth: AI changes the how. It doesn’t change the why. A poorly designed workflow with a chatbot bolted on is still a poorly designed workflow, now with extra latency and a brand new way to be wrong. If anything, the fundamentals of enterprise UX matter more in the age of AI, not less. AI is a multiplier, and multipliers are indifferent to what they multiply. Good UX foundations get amplified. So does chaos.
That’s what this series is about. Over the coming posts I’ll walk through the twelve principles I’ve found most valuable for designing enterprise software, two at a time: what each one means in practice, and how Gen AI and agentic interfaces are reshaping it. This first post sets the scene and digs into the two principles that set the tone for everything else.
First, a Quick Refresher: Why Enterprise UX Is Different
Enterprise UX is the design of the internal tools and platforms employees use to do mission-critical work — claims systems, call-centre software, data pipelines, scheduling tools. They differ from consumer products in a few fundamental ways:
Use is mandatory. Your users can’t churn. They can only suffer, or thrive.
The work is complex. Multi-step, multi-role workflows with deep domain logic and dense data.
Repetition is the norm. The same tasks, hundreds of times a day, often under time pressure.
The cost of error is high. A mistake here means a compliance breach, a mis-paid claim or a missed patient record, not an abandoned shopping basket.
When these tools work well, everything downstream works better. When they don’t, the business quietly bleeds time, money and talent. These internal systems are the product everything else depends on.
The Twelve Principles at a Glance
Ruthless Efficiency: slash time-on-task; delight through speed, not decoration.
Embrace Complexity, Orchestrate It Gracefully: don’t dumb it down; organise it.
Design for Real Roles: tailor the experience to actual job functions, not a generic “user”.
Automation First: remove mindless repetition so people can focus on judgement.
Insights Over Information: turn data into decisions, not dashboards.
Reliable at Scale: performance is a UX feature, especially under load.
Total Ecosystem Coherence: consistent patterns across every tool in the stack.
Smart Onboarding: help in the flow of work, not in a training manual.
Invisible Compliance: security and auditability built in, never bolted on.
Mistake Recovery: prevent errors early, and make recovery effortless.
Power-User Personalisation: smart defaults for most, deep control for experts.
Measure What Matters: productivity and outcomes, not vanity metrics.
Let’s take the first two properly.
Principle 1: Ruthless Efficiency
In consumer design, delight can be a goal in itself. In enterprise, it’s secondary. Internal users are under time pressure, and a delightful UI that slows them down is worse than a plain one that lets them work quickly.
Think of airline gate agent software. It looks dated, and it’s entirely keyboard-driven and ultra-fast. That’s by design. A flashier interface could increase boarding times. For staff doing the same task hundreds of times a day, delight is speed: fewer clicks, fewer seconds. Shave a handful of seconds off a task performed thousands of times a week and you’ve created compounding value, for the person doing the work as much as for the business.
The AI twist
Efficiency is the test every AI feature must pass — and many don’t.
Conversational interfaces are the obvious trap. Chat is a wonderful interface for ambiguity: open-ended questions and one-off requests in unfamiliar territory. But for an expert doing a known task for the four-hundredth time, typing a prompt into a text box is slower than a well-designed form with sensible defaults. Replacing a two-click workflow with a conversation is regression with better branding.
Then there’s latency. A model call that adds three seconds to a task performed 400 times a day costs that user twenty minutes. Every day. Enterprise AI needs a latency budget, exactly as interfaces have always needed performance budgets.
And the sneakiest cost of all: verification. A plausible-but-wrong AI output can be slower than no output, because an expert must check it before they can trust it. Checking someone else’s work is often harder than doing your own. Ruthless efficiency in the AI era means measuring time-to-task-complete with the AI in the loop, verification included. If the number doesn’t go down, the feature doesn’t ship.
Where AI passes the test brilliantly: pre-filling fields from context, suggesting the likely next action, drafting the routine 80% so a human can perfect the critical 20%. AI that removes steps is efficiency. AI that adds a conversation where none was needed is friction in a party hat.
Principle 2: Embrace Complexity, Orchestrate It Gracefully
Enterprise software often needs to show twenty or more data points on a single screen. The instinct, usually imported from consumer design, is to simplify: strip it back, hide the detail.
Resist it. Enterprise users don’t want less information. They want it organised better. The work is complex because the domain is complex, and an interface that hides necessary complexity just relocates the difficulty onto the user, who now clicks through six screens or keeps a second window open to find what one well-designed view could have shown.
The craft is orchestration: progressive disclosure, logical grouping, customisable views, layouts that reveal depth on demand. Respect the task. Organise, don’t obscure.
The AI twist
AI hands us a seductive new way to hide complexity: the summary. Why show twenty data points when a model can compress them into three sentences?
Summarisation is the new progressive disclosure: brilliant as a layer, dangerous as a replacement. A good summary is a map, and experts still need the territory. The moment a summary can’t be traced back to its sources, it becomes something a user must take on faith. In workflows where the cost of error is high, faith is not a design pattern. Every AI-generated synthesis needs a “show your workings” path: summary to source record in one click.
There’s a second, newer reason to keep complexity structured rather than buried: people are no longer your only users. Agents are starting to operate enterprise systems too, reading screens and filling in forms. An agent can’t reliably operate a system whose logic lives only in tribal knowledge and cluttered screens. The same discipline that makes complexity navigable for a human is what makes it operable by a machine. Graceful orchestration now serves two audiences at once.
Where This Series Goes Next
Over the coming posts I’ll take the remaining principles two at a time, each with the same treatment: the core idea, what it looks like in practice, and the AI twist.
Design for Real Roles + Automation First: why an agent is just a new kind of role, and why automation is becoming delegation.
Insights Over Information + Reliable at Scale: trust, traceability and why model latency is the new page load.
Total Ecosystem Coherence + Smart Onboarding: agents that cross tool boundaries, and AI as the always-on onboarding layer.
Invisible Compliance + Mistake Recovery: auditing what an agent did, and designing undo for actions you didn’t take yourself.
Power-User Personalisation + Measure What Matters: users building their own automations, and measuring AI-assisted productivity honestly.
I’ll follow those with some supplementary pieces, including one I’m especially looking forward to writing: what happens to all twelve principles when the user of your interface isn’t a person at all.
Because that’s where this is heading. Behind every great product is a team of people making it happen, and now a set of agents working alongside them. The organisations that win won’t be the ones with the most AI. They’ll be the ones whose foundations were strong enough to be worth multiplying.
Let’s design for that.
Patrick Mooney is a senior design leader based in Ireland, with more than 25 years’ experience in UX, product and enterprise software, and the founder of Dublin UX. He writes at patrickmooney.me..