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.
How we work
How a conversational AI design engagement works.
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.
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.
The questions every team has.
A chatbot is a UI component. A conversational experience is a design approach rethinking how users move through your product using natural language and context. The difference is whether users come back after the first session.
Yes this is the most common starting point. We audit the existing flows, find where trust breaks down, and redesign from the conversation up.
We design every failure mode before the product ships: what the AI says when it doesn’t understand, when it’s uncertain, when the request is out of scope. Users who know what to do when the AI fails keep using the product.
CDI gives us the workflow sample dialogue first, then flowcharting, then testing. Erika Hall gives us the philosophy write the conversation before you design the screen. We never open a design tool until we know what the AI is going to say.
Two to four weeks, depending on the number of use cases. We start with the highest-impact flow, deliver a working prototype, and expand from there.
A front-end code prototype not a Figma file with a conversational design system, dialogue documentation, and agent-friendly handoff notes your dev team can build from.
Connect with us
Let’s talk about your product.
Hate contact forms? Direct Contact!