We use AI in our own work, no point pretending otherwise. It speeds up code, drafts variations, and takes the repetitive production work off our hands. If a studio tells you AI plays no role in their process, they're either behind or lying.
So you'd expect us to say that building interfaces has become mostly automatic. It hasn't. The design decisions, what to build, for whom, and why this way and not another, are as human as ever. What's changed is where the craft earns its money: less time on production, more time on the two things no tool can do for you: understanding your users, and checking whether the interface actually works for them.
In AI circles this way of working has a name: human in the loop. Strip away the jargon and it means something simple: a human sets the direction, tools accelerate the production, and a human observes, corrects, and decides before anything ships, then the result goes back for another round. The machine is in service of the process, never the other way around. For interfaces and user experience, that loop isn't a nice-to-have. It's the entire difference between software people use and software people quietly abandon.
Here's why.
"It works" and "it works for your users" are two different claims
When an AI tool generates an interface, it optimises for one thing: producing something that looks like a correct interface. And it's genuinely good at that. The buttons are where buttons usually go, the form looks like forms usually look, the whole thing runs without errors.
But "looks like a correct interface" is a statement about the screen. Whether it works is a statement about people:
Does a 58-year-old warehouse manager, using this on a tablet with gloves on, find the button?
Does a first-time visitor understand what to do within five seconds, or do they hesitate?
Does the checkout flow match how your customers think, or how the average website on the internet happens to be built?
AI has no access to any of this. It has never met your users, never watched one of them get stuck, never seen the support tickets that pile up when a form label is ambiguous. Everything it knows comes from the millions of existing websites it learned from, so what it produces is a well-made averageinterface, not the one that fits your specific people doing their specific job.
The only way to close that gap is a human in the loop: someone who knows your users before the first screen is designed, puts the work in front of real people, watches where they hesitate, and feeds what they learn back into the design. Tools speed up the making. Humans do the understanding, the designing, and the deciding. Then the cycle repeats.
What the human in the loop actually catches
This isn't abstract. Here's what watching real people use an interface reveals, and what no AI tool flags on its own:
Hesitation. A user pauses three seconds before clicking, because two buttons both could be right. No error is thrown, nothing is technically broken, and yet every one of those pauses is a potential customer drifting away. Only observation catches it.
A different way of thinking than your customers'. The AI builds a filter sidebar because e-commerce sites have filter sidebars. But your customers don't think in categories, they think in problems ("something for a leaking roof"), and they leave when the interface forces them to translate. A human notices the mismatch; the AI can't, because the mismatch lives in your customers' heads, not in the code.
Context the AI has never seen. Bright sunlight on a construction site. A receptionist who keeps the app open eight hours a day and is driven mad by an animation that's charming the first time. One-handed use on a train. The AI learned from websites, not from workplaces, and real usage is full of circumstances that never show up on a screen.
The gap between feedback and behaviour. Users say the design is "fine" in a survey, and then in testing, half of them fail to complete the main task. People are polite; behaviour is honest. Someone has to be watching the behaviour.
Accessibility in practice. Automated checks catch missing labels and bad contrast. They don't catch that the site is exhausting to navigate for someone using a screen reader (software that reads the page aloud for blind users), or that error messages make no sense when you can't see the screen. That takes a human who checks, and ideally users who depend on it.
What this means for you
1. You avoid shipping a plausible interface that quietly fails
The most dangerous UI problem in the AI era isn't a bug, it's an interface that looks finished and passes every technical check while users silently struggle. Nothing crashes. There's no error to fix. There's just a conversion rate lower than it should be, and nobody knows why.
In practice: problems get caught in a testing session, where fixing them costs an afternoon, instead of in your revenue figures six months after launch, where diagnosing them costs a project.
2. Your software gets adopted instead of tolerated
For internal tools this is everything. Software that fights how your team actually works gets worked around: the shadow Excel file reappears, data quality collapses, and the investment evaporates. The gap between "the tool does what the spec said" and "the team actually uses it" is exactly the gap a human in the loop closes, by watching your team use it before it's finished.
In practice: the tool you paid for is the tool your people use, not a monument they route around.
3. AI speed without AI blind spots
This isn't a choice between AI and humans, and anyone framing it that way is selling something. In our process, a designer still makes the calls: what the interface needs to do, for whom, and why. AI compresses the production around those calls, exploring in minutes variations that used to take days, so more of the budget goes to the parts that actually decide the outcome: understanding your users, testing against real behaviour, and refining what works.
In practice: faster delivery and better outcomes, because the hours saved on production get reinvested in research, testing, and refinement, the part that was always underfunded.
4. Someone is accountable for the experience
When an AI-generated interface underperforms, who do you call? The tool has no opinion and no responsibility. A human in the loop means a person who has watched your users, understands why every screen is the way it is, can explain the reasoning, and owns the result. When something needs to change, there's judgement behind the change, not another roll of the dice.
In practice: design decisions you can question and understand, from someone answerable for them.
What it costs (because it's only fair to mention)
It takes more time than pure generation. Watching five users work through a flow, processing what you saw, adjusting, testing again, that's real hours. If you need a throwaway internal page that three colleagues will use twice, skip the testing and keep it simple. We'd tell you the same.
It sometimes tells you things you don't want to hear. Testing regularly reveals that a feature someone loved internally confuses every actual user. A human in the loop surfaces that before launch. That's the point, but it's not always comfortable.
It requires access to real users. Testing with your own team is better than nothing, but your team knows too much. The strongest results come from watching genuine customers or end users, which takes a bit of coordination. It's less effort than most clients expect, five users typically expose the majority of problems, but it's not zero.
Who this matters most for
Human-in-the-loop UX pays off most when:
The interface drives revenue directly: webshops, booking flows, quote requests, anywhere hesitation is money
Your users aren't "average": specialists, older audiences, field workers, or anyone else the internet's average website wasn't built for
Adoption is the risk: internal tools and portals where the failure mode isn't crashing, it's being ignored
Mistakes are expensive: interfaces where a confused user means a wrong order, a compliance issue, or a support avalanche
If none of these apply, if the stakes are genuinely low, generated-and-shipped can be perfectly rational. Knowing when the loop matters is part of the judgement you're paying for.
The bottom line
AI has made producing interfaces nearly free. It has made designing and validating them more valuable than ever, because the volume of plausible-but-untested UI in the world has exploded, and users can feel the difference even when they can't name it.
The loop is simple: a human sets the direction, tools speed up the making, humans observe real people, judgement decides, repeat. Only one link in that chain can be automated. Every other link requires someone who cares about your users more than the average of the internet does.
That's how we build: humans design, AI accelerates, and real users get the final word. If you have an interface, live or planned, and you're not sure whether it works for your users or just works, get in touch. A single afternoon of watching real users is often the most clarifying thing you can do for a digital product.
