Portfolio
Aura — a UX Agent for a Prompt-First Team
The shift came gradually at first, then all at once. Product managers built their own prototypes and showed the functional scope of their vision instead of describing it. Developers shipped features faster than classic design cycles could keep up with. In parallel, a 2.0 of the product started: a new language, no hand-written code, a broad and bold product vision – and nothing but prompts and agents in between.
For UX this raised an uncomfortable question: where does design quality happen when nobody is waiting for a design any more? My answer wasn't to defend the old process, but to translate it. I built a UX agent fit not only for an AI-driven world, but for a world without a UX designer in it.
Process
Phase 01
Reading the Stack Before Judging It
An agent that judges interfaces has to know what they are made of. So the first step wasn't a review but an analysis: tech stack, routing, template and style idiom, plus the design system and the brand. Only on that foundation can you judge what an interface actually does – and in which idiom a fix has to be written.
Phase 02
A Constitution Instead of a Feature List
Principles came before capabilities – and the agent had to hold itself to them. Human-centred and ethics-first: no critical decision, no assumption without looping in a human. No silent failure, nothing changed without notice. Escalate rather than guess when the evidence is thin. Review itself. Work efficiently, delegating lighter work to cheaper models. And when it talks to a human: structured, with options, a recommendation and the reasoning behind it.
Phase 03
First Iteration Meets First Use
The first version reviewed exactly what it was built for: one document, one feature, one page. The first developer to use it wanted something else – a review of the entire app. A neatly bounded task turned into a far harder one: discovering surfaces in the first place, ranking their risk, agreeing on review depth, and being able to show afterwards what was checked and what wasn't.
Phase 04
Consolidating Findings Instead of Stacking Them
Reviews run many criteria at once: heuristics, WCAG, dark patterns, motion, content. The same problem regularly gets flagged by several of them – and initially landed in the report several times over. Instead of passing duplicates downstream, a gated system took over: a finding hit by three independent lenses is escalated one severity level. Corroboration becomes signal instead of noise.
Phase 05
The Mistake: Commands Built Around Agents, Not People
The command structure initially followed the architecture. You typed /ux and something happened – without you really knowing what. For an agent whose core principle is transparency, that was a contradiction in itself. It needed specialised entry points for the situations people actually have – one feature, a merge request, the whole app, building something new – and feedback on what it understood and what it was about to do.
Phase 06
From Reviewing to Building
Every agent was critique-shaped at first: it ran a discipline backwards, looking for violations in something that already existed. For prototypes coming out of product management, that was too late. So the agent got the inverse: elicit intent in an interview, produce one complete UX specification, run it through the agent's own review cascade until nothing critical is left, and hand it to the developers' coding superpowers. A specification, never production code.
Phase 07
Knowledge That Doesn't Go Stale
Then something changed in WCAG – and it became obvious that the knowledge inside the skills has to be maintained, eventually by someone without a UX background. The agent gained a routine that checks the standards it cites against their live sources and presents any drift as an auditable proposal. It never edits its own knowledge silently; a human approves.
Methods
Knowledge Separated from Pipeline
Skills are pure knowledge with no control flow; agents are procedures with no knowledge. Separating the two from day one was the decision that made every later extension cheap.
Human-in-the-Loop by Design
The agent proposes, the human decides. Ethics findings always require per-finding sign-off – even when someone chose "fix all".
One Severity Contract
Three levels, defined in a single rubric and used identically everywhere. No criterion may invent a fourth – otherwise prioritisation turns into a matter of taste.
Portable, Not Project-Specific
Every very specific request from the team was solved in a way that works in any environment, with any product and any technology. Company-specific rules live in a swappable overlay.
Visuals
In the end the agent got a name and a face: Aura – and a decision menu where understanding comes before acting and the bulk action is never the default.
Manipulative countdowns, dishonest button labels, contrast failures: the findings nobody would catch once UX is gone from the team.
Key Takeaways
Process Is a Design Problem
When the team changed how it worked, the real design problem wasn't the next interface – it was the process itself.
Principles Before Capabilities
What an agent must not do matters more than what it can do. A system that acts unasked loses trust faster than it creates value.
An Agent Needs UX, Too
The command structure was the first place where I failed my own standards: built around the architecture rather than around the user's situation.
Knowledge Has a Shelf Life
Standards move. If knowledge can't be maintained without being an expert, the system goes stale exactly when nobody is watching any more.
Aura is in use in the team and still growing – currently around the question of how findings condense into a picture across many reviews, and how the agent learns from declined findings without ever hiding anything. The core stays the same: Aura is written entirely in Markdown, with no service and no black box. Every rule it judges by is readable in a diff – and therefore changeable by a team that no longer has a UX designer.