My AI UX Approach

My process, patterns, and principles for designing trustworthy AI experiences.

Image

My (evolving) AI-augmented process

AI compresses the pass. The judgment, the taste, and the read on what the user actually needs — that part's still mine.

Understand
Is this actually the right problem to solve? I pressure-test the brief, surface assumptions, dig into research, study what competitors get right and wrong, so the problem is sharper than how it arrived.
Receive PRD
Pressure-test the brief
Synthesize research
Competitive analysis
Define problem, goals, success metrics, hypotheses
Map
I map the territory — JTBD, user stories, the workflows that connect them, the blockflows underneath — to decide what the product needs to do, in what order, and what good looks like when we ship it.
JTBD, user stories, tasks
Workflows
Blockflows
Design principles
Product requirements / priorities
Iterate
This is where the work becomes visible: low-fi, hi-fi mocks, and prototypes. The goal isn't the first idea, it's exploring enough directions that the right one becomes obvious.
Low-fidelity wireframes
Hi-fi mocks against the design system
Prototypes & motion
Critiques & iterate
Usability testing
Build
Designs aren't done when the file is pretty — they're done when they're shipped and working. I write specs, hand off to engineering, and increasingly produce real product code myself.
Spec & engineering handoff
Ship-ready design code
QA against mocks
Launch
Measure & learn
AI & Tools
Claude Custom Research Agents
AI & Tools
Claude FigJam
AI & Tools
Figma / Figma AI Claude
AI & Tools
Cursor + Figma MCP Claude Code
Where AI actually helps
Surfacing gaps, edge cases, and assumptions in the PRD before a pixel is drawn. Generate prioritized hypotheses.

Synthesizing research notes into themes.
Where AI actually helps
Helps craft first pass user stories, flows, and edge-case maps.

Drafting blockflows I refine rather than starting from a blank canvas.
Where AI actually helps
Exploring ten directions in the time it used to take for one.

Generating variants I react to and refine — often surfacing options I wouldn't have considered.
Where AI actually helps
Shipping designs as real code, not just images.

The handoff gap between design and engineering shrinks, and I stay closer to how the product actually behaves in users' hands.

The patterns underneath

A few interaction patterns show up again and again once you're paying attention — not tied to one product, but to the stage of the exchange between a person and a system. Adapted loosely from Aiverse's five-phase framework for AI design, here's the shape I watch for, and where I've actually seen it done well.

Discovering
How do users discover what AI can do in the first interaction?
Instructing
How does the user instruct the AI and provide context?
Observing
Can someone tell what the AI is doing while it's doing it?
Refining
How easy is it to correct or undo afterward?
Adapting
When does the AI earn the right to do more on its own?
Stated boundaries
A plain, upfront description of what the agent can and cannot do, before the person commits to using it.
Disclosed involvement
A clear signal of where AI is involved and what its limits are, so expectations are set before anything happens.
Suggested first moves
A handful of concrete example prompts shown up front, so people know what to try before they've typed anything.
Starter templates
Pre-filled examples people can adapt instead of starting from a blank page, useful for showing the range of what's possible.
Live preview while typing
A rough draft of the result updates as the person types, so they can tell early whether they're headed somewhere useful.
Visual signal for AI moments
A consistent icon, color, or motion treatment marking anywhere AI is acting, so it's always clear what came from the system versus the person.
Quiet suggestions
The system offers a suggestion only when it's confident, and only in a way that's easy to ignore rather than interrupt.
Natural-language search
Describing what you want in plain language instead of learning a filter UI, with structured filters still available as a fallback.
Named modes
A small number of labeled modes (quick vs. thorough, for example) so people can set expectations about speed and depth before they start.
Plain-language permission summary
A short, upfront list of what the system is and isn't allowed to touch, shown once rather than buried in settings.
Confidence disclaimer at the point of use
A clear note about where the output is uncertain or where human review still matters, shown right where the person is looking, not just in a terms page.
Guided first run
A short, skippable walkthrough that shows one real example end-to-end, so people learn by watching it work once rather than reading instructions.

Designing for Trustworthy AI

The friction people feel with AI isn't primarily a capability problem. It's a shared-understanding and alignment problem.

Any effective working relationship depends on knowing what's being handed over, why decisions are made, and how to correct course when something goes wrong. Most AI products haven't been designed around those mechanisms yet.

The AI needs to demonstrate understanding

Good delegation isn't built in a single handoff. You establish how you work, what's important, where the boundaries are, and what success looks like. Trust builds through demonstrated understanding.

Most AI products skip this step. They execute immediately and hope the output matches what you intended.

The AI needs to earn trust through transparency

People ask AI to triage email, book travel, or draft reports — then hover over every action and double-check every output.

That's not user resistance. It's appropriate caution for a relationship that hasn't earned trust.

The AI should evaluate how best to balance understanding and speed

AI products are still optimized for speed to output rather than speed to understanding. Demo culture rewards instant answers, while small cues like "thought for 5 seconds" reinforce the idea that faster means smarter.

But speed doesn't create the shared understanding required for delegation.

So what does trustworthy AI actually look like?

Building the clarity, control, and confidence needed for people to delegate to AI.

Scope: Who does what?

Before anyone hands work to an AI system, they need what they'd need from a new hire: an explicit scope of what it will and won't do, which actions require approval, where the checkpoints sit before anything consequential happens, and the zones it won't enter on its own. Most AI products skip straight to execution instead, and ask the user to define boundaries after the fact, one correction at a time.

In practice: Superhuman drafts emails but won't send without approval. OpenAI's Operator pauses before financial transactions. GitHub Copilot shows a proposed change before applying it. Linear only starts auto-assigning labels after trust has been earned through repeated correct suggestions.
Transparency: What is it doing?

Once the system acts, the person needs visibility into what it's doing and why — not just the result. That means real-time visibility into current state, the reasoning behind a given choice, clear progress signals, and an honest confidence marker when the system itself is uncertain. An output with no visible reasoning is a black box, however good the output turns out to be.

In practice: GitHub Copilot Workspace shows its reasoning before it generates code. Perplexity displays its search process and sources as it works. Cursor shows a diff preview before applying a change. Operator narrates its own browser actions in real time.
Error Prevention & Recovery: What happens when it goes wrong?

Refinement only feels safe when it's cheap to get wrong. That means quick undo grouped by task rather than by individual click, clear restore points, high-stakes actions staged in phases instead of executed in one shot, and honesty about what recovery actually costs. Without that, every refinement carries the weight of a decision that can't be taken back — so people stop refining and start avoiding.

In practice: Notion AI groups a whole set of AI edits into a single undo. Figma keeps version history with restore to any point. Gmail's 'undo send' extends the recovery window. Rewind AI keeps a complete activity history for rollback.