The Shift Has Already Happened
Your users talk to AI every day. Then they open your product.
Google made conversational AI native to Search, Workspace, and Android. Perplexity replaced search with it. ChatGPT made it the default way people interact with software. Your users live in these experiences. Then they hit your forms and menus. They feel the gap.
A chatbot won’t close it. Rethinking how users move through your product will, starting with writing the conversation first, then designing the interface.
Users expect products to feel conversational, not transactional
Users expect AI to surface the right thing, not wait
Users expect to stay in control, even when AI leads
Our Crafts
What goes into conversational AI design.
Dialogue Design
We write the conversation before we touch a screen. Every exchange, every branch, every edge case. Most teams skip this. We start here.
AI Persona & Tone Design
How your AI speaks shapes whether users trust it. We define the persona, and where personality stops and clarity begins. We don’t over-humanise. We calibrate.
Conversation Flow Architecture
Context gets lost. Users interrupt. Sessions break. We design how the AI maintains state, handles topic changes, and recovers when users go off-script.
Error & Recovery Design
The AI will misunderstand. It will be uncertain. It will fail. Each of those moments is designed, what it says, what it offers, how it hands back control.
Conversational UI Components
Input patterns. Suggestion chips. Loading states. Confidence signals. Handoff triggers. Every component is consistent and reusable.
Trust Calibration
Over-trust leads to bad decisions. Under-trust leads to abandonment. We design for the level of trust your AI has earned.
Our Process
Inside the two weeks.
We start with a question: what is the user trying to accomplish? We map the journeys, find where conversation replaces friction, and define the AI’s role in each flow.
We write the conversation trees. Happy paths, edge cases, failures, recovery. We define the persona and the capability boundaries. The interface follows.
Real users, working prototype. We test for trust, completion, and drop-off. Then we fix what we find.
Front-end code, not Figma. Design system in the codebase. Documentation your dev team and their AI tools can build from.
Deliverables
This is for you if any of these sound familiar
Dialogue scripts & conversation trees
We write every exchange, every branch, and every edge case before a single screen is designed or built.
AI persona & capability framework
A clear framework for how your AI speaks, what it commits to, where personality stops, and what it admits it cannot do
Flow architecture
Designs how the AI maintains context, handles multi-turn logic, recovers from interruptions, and stays on track.
Failure state design
Every dead end is designed, what the AI says when it fails, what it offers next, and how it hands control back to the user.
Conversational UI component library
Input patterns, suggestion chips, loading states, and handoff triggers, reusable and consistent across your product.
Interactive prototype
A working front-end code prototype that your dev team can open, run, and build from directly without touching a Figma file.
Agent-friendly documentation
Written for AI-assisted dev teams, clear, structured, and ready for the tools your team already uses.
Two types of founders come to us for discovery.
AI You have a working model and a product idea. Maybe you’ve already built something. But the experience isn’t there yet — it lacks completeness, trust, or taste. You need a UX team that understands AI products, not one that has to be taught what a language model is.
You’re under pressure to ship AI features. You know what the AI can do technically. You don’t yet know how users will interact with it, trust it, or abandon it. Discovery gives you that clarity before dev starts — not after.
If users aren’t finishing the conversation, the design needs to change.
Start with a free trial. One use case, prototyped end to end — failure states included. No commitment.
Your questions, answered.
Yes, and this is increasingly common. Many founders come to us with something already built using AI tools. Discovery in this context means evaluating what exists, identifying completeness gaps, and redesigning with taste and trust built in.
We deliver a front-end code prototype, not a Figma file. Components and design system foundations are already set up in the codebase so your dev team can build directly from it.
Yes. Understanding what your AI can and can’t do is part of how we define use cases. We work alongside your technical team to map model capabilities and design around real constraints, not assumed ones.
Two weeks, typically. We cover two to three major use cases end to end, happy paths, failure states, and AI behaviour, with an interactive prototype and direction for the full product at the end.
Discovery feeds directly into the build phase. If you’re continuing with us, your designer is already one sprint ahead of development. If you’re taking the work in-house, your dev team has everything they need to build without ambiguity.
Connect with us
Let’s talk about your product.
Hate contact forms? Direct Contact!