Rethinking the conversational AI design process: Start analog to end human

How pen, paper, and playacting lead to a better bot experience

When you’re designing conversational AI — whether for chatbots, virtual assistants, or voice interfaces — it’s tempting to jump straight into building tools. After all — it’s exciting to create cool things! But, believe it or not, you shouldn’t just dive into natural language processing (NLP) and training AI models. The best way to start designing conversational AI experiences is actually with analog methods.

That’s right — good old-fashioned pen and paper.

Traditional UX design relies on low-fidelity wireframes and prototypes before high-fidelity designs. Conversational AI follows a similar path. We start with intent cards, paper prototyping, and role-playing to refine interactions before writing a single line of code.

This article explores the conversational AI design process with a focus on analog techniques to improve usability, efficiency, and user satisfaction.

Why great conversations start offscreen

Why start analog?

It might sound counterintuitive in a world obsessed with automation, but some of the best-performing conversational AI products start with nothing more than a pen, sticky notes, and a little bit of imagination.

Think about how we design apps or websites. Or—at least—how we should. We don’t open Figma and start slapping together final screens on day one. We sketch. We outline. We build wireframes to figure out how things work before we make them pretty or functional.

Conversational AI design is no different. In fact, it might need more structure upfront, because conversation — unlike an interface — isn’t always linear. People interrupt, change their minds, get confused, or say things you didn’t plan for. You need a way to map that complexity before you start training a chatbot or voice assistant.

That’s where analog methods come in. Tools like intent cards, paper prototyping, and role-playing let you explore different ways a conversation could unfold before you commit to code.

Analog uncovers intent

You’re not worried about platform constraints or whether the NLP model will recognize your utterances. You’re focused on the fundamentals: 

1. What is the user trying to do? 
2. What’s the most helpful response? 
3. Where could the interaction fall apart?

Starting analog has some serious advantages:

• You can define intents and responses clearly without the clutter of variables or backend logic.
• You can iterate fast — like, erase-and-try-again fast. No need to retrain a model or deploy a bot just to tweak a phrase.
• You can test with teammates or stakeholders early which helps catch awkward language or broken flows before they go live.

And here’s the kicker: when you do move into digital tools — whether it’s Cognigy.AI, Dialogflow, or another platform — your team isn’t guessing. You’ve already stress-tested the conversation. You’re not asking “What should the bot say here?” You’re asking “How do we implement what we already know works?”

In short, a solid conversational AI experience begins long before any model is trained.

Analog isn’t outdated. It’s foundational. And for teams building conversational AI products that actually work, it’s often the smartest place to start.

Getting to the point: Using intent cards to clarify conversations

Before your team writes a single line of bot logic or fine-tunes the tone of voice, you need to understand something pretty basic: what the user actually wants.

That’s where intent cards come in.

Intent cards are a simple, analog tool, but they pack a punch. At their core, they’re just a way to map out the back-and-forth of a conversation. One side shows what the user might say or ask. The other side shows how the bot should respond. Think of them like flashcards for conversational AI structure.

Here’s an example:

• User says: “I need to reset my password.”
• Bot responds: “Sure, I can help with that. What’s your email address?”

That’s an intent card. Now imagine you have a stack of them — one for each use case your conversational AI product supports. Suddenly, your team has a clear view of how the chatbot should behave in real-world scenarios.

Align on user goals

This isn’t theoretical. Intent cards are widely used by conversation designers at companies like Google and Amazon, and they’ve been recommended as part of best practices in multiple conversational AI design frameworks. They help designers, writers, and developers stay aligned on user goals without getting bogged down in platform specifics.

Evaluate and discuss

They also act as a great discussion tool for cross-functional teams. Designers can use them to evaluate tone and flow. Engineers can start thinking about logic and branching. Product managers can ensure that key customer needs are being met. It’s collaboration without a whiteboard war.

Catching mistakes early

Most importantly, intent cards are a safety net. They help you catch misaligned responses, incomplete flows, or moments where the bot’s logic might break down. And because they’re lo-fi, they’re easy to change. Want to test a new way to answer a tricky support question? Just write a new card.

It’s easy to underestimate tools this simple, but that’s kind of the point. Intent cards help your team stay focused on the conversation itself, not the tools or tech behind it. And when you’re designing for humans, that’s exactly where your attention should be.

Sketching the script: How paper prototyping keeps conversations human

Before bots ever speak, teams need to listen to each other, to the user, and to the flow of the conversation as it naturally unfolds. And sometimes, the best way to do that is with a stack of sticky notes and a marker.

Paper prototyping for conversational AI design is exactly what it sounds like: designing interactions with good old-fashioned pen and paper. You’re not just jotting down ideas. You’re writing full-blown conversations. Line by line. Question and answer. Twist and turn.

You might map out a single scenario on index cards: a customer trying to reschedule an appointment. Or you might sketch out an entire dialogue tree across a whiteboard wall, complete with branches, options, and fallback paths. Want to change the flow? Rip off a sticky note and rewrite the turn. It’s tactile, collaborative, and fast.

Benefits of paper prototyping

But here’s where paper prototyping really shines: it forces clarity. When you’re not relying on the magic of natural language processing to fill in the gaps, you have to write responses that make sense, that are helpful, and that move the conversation forward. There’s no hiding behind AI guesswork — just clear, structured thinking.

Role-play with humans

Teams can role-play the dialogue, reading through it like a table read for a screenplay. (And yes, it will become very clear when something sounds robotic or confusing.) You’ll hear the awkward transitions. You’ll also catch missing prompts and see where the flow breaks.

More importantly, you’ll start designing like a human talking to another human — not like a bot trying to process commands.

The beauty of paper prototyping is that it doesn’t require special tools or deep tech knowledge. It democratizes the process. Writers, researchers, product managers, engineers — everyone can contribute. And when you’re building something as complex as a conversation, that’s exactly what you want: shared understanding before shared execution.

So before you start building out flows in a platform, give yourself space to scribble. Sometimes the path to the most natural conversation starts with a Sharpie and a blank sheet of paper.

Act it out before you build it: Role-playing your way to better bots

If you’ve ever watched a play before opening night, you know the power of a rehearsal. The lines are there, the blocking is in place, but things still feel rough. Then comes the table read. The actors sit down, scripts in hand, and start reading aloud. That’s when the magic (and the awkwardness) shows up.

Conversation design isn’t so different.

Before you commit to building anything, it’s worth running your bot through its own kind of dress rehearsal. That’s where role-playing and Wizard-of-Oz testing come in — two low-tech, high-impact ways to simulate your bot’s conversations using nothing but your team and a little imagination.

So how does this work in practice?

In a basic role-play, one person acts as the user and the other as the bot. The “bot” sticks to a script or uses intent cards, while the “user” tries out different ways of asking for what they need. This back-and-forth quickly reveals how natural — or unnatural — the dialogue really feels.

Wizard-of-Oz testing takes it a step further. In this scenario, a real user believes they’re chatting with a functioning bot, but behind the scenes, a human is typing the responses. It’s the ultimate behind-the-curtain moment. The user gets a seamless experience, and the team gets a goldmine of insight into what people actually say when they’re not thinking about design constraints.

Why does this matter?

Because no matter how polished your copy or how advanced your NLP model, users will surprise you. They’ll use slang you didn’t anticipate. Or they’ll skip steps and ask for something your bot isn’t set up to handle. Role-playing gives your team the chance to catch those surprises early and respond with better design, not just better tech.

This kind of testing helps refine more than just the flow. It’s how you tune your bot’s tone, test for edge cases, and make sure the interaction feels helpful instead of robotic. It’s also a great team exercise — bringing designers, writers, PMs, and developers into the same room (virtually or otherwise) to hear the conversation out loud and improve it together.

Bottom line? Don’t wait until launch to find out your bot sounds awkward. Act it out first. It’s cheap, fast, and surprisingly fun, and it could be the difference between a bot users tolerate and one they actually enjoy talking to.

Plotting the dialogue: Storyboarding for smarter conversations

Before your chatbot ever says hello, it needs a script.

Not just a list of intents and replies — a real, working script that captures how conversations unfold in the real world: messy, nonlinear, and full of surprises. That’s where storyboarding comes in. It’s a classic tool in film and animation, and it turns out it’s just as useful when designing conversational AI experiences.

Think of it as sketching out the scenes of a conversation. Who says what? When? What happens if the user changes their mind? Where do things branch? Where might they break?

Here’s how it works:

1. Start with a script — literally. Write out a sample conversation as if you were scripting a movie or a radio play. Keep it conversational. No jargon. Just two characters: the user and the bot.
2. Highlight the forks in the road. Identify the moments where users could go off-script — change their mind, ask something unexpected, or abandon the process altogether.
3. Plan for detours. Make sure your bot can handle natural shifts in intent without getting lost or starting over. This is where a lot of bots fall flat.

Let’s take a coffee-ordering scenario as an example:

• User: “I’d like a latte.”
• Bot: “Would you like a small, medium, or large?”
• User: “Actually, make it a cappuccino.”
• Bot: “Got it! One cappuccino, coming up. Do you need anything else?”

That little moment — “Actually, make it a cappuccino” — is the kind of turn that derails a poorly designed chatbot. If the bot isn’t ready for a change in direction, it might force the user to start over or give a confusing response. But when you storyboard conversations ahead of time, you start to see these real-life detours for what they are: opportunities to make the experience smoother and more human.

Storyboarding is also a great way to visualize emotional tone, timing, and user confidence. Does the bot sound rushed? Is it overexplaining? Does it give the user room to ask follow-ups?

It’s easy to skip this step when you’re eager to start building. But just like in film, if you don’t storyboard first, you’ll likely waste time reworking scenes later. Storyboarding helps you and your team agree on the story you want your bot to tell — and how that story changes when users do what they always do: behave like real people.

From sharpies to software: Bridging the gap between analog and AI

Once your team has talked it out, sketched it out, acted it out, and rewritten it twice on sticky notes — then it’s time to go digital.

Analog methods help you shape the bones of the conversation. But digital tools are where that conversation comes to life. This is the point in the process where you start layering on the logic, connecting to systems, and training the conversational AI to actually recognize what people say.

By the time you hit this stage, the heavy lifting (the decision-making, the flow structure, the intent mapping) should already be done. No guesswork. No white-knuckle moments. Just implementing what you’ve already validated on paper (or the whiteboard, or the post-it wall).

Here’s how the transition typically plays out:

• Platforms like Cognigy.AI, Dialogflow, or Rasa let you define user intents and build response flows powered by natural language understanding (NLU). These tools take your intent cards and conversation paths and turn them into functioning chatbots or voice agents.
  
• Flowcharting tools like Miro or Lucidchart help you visualize everything from greeting to fallback intent. They’re especially useful for sharing the design with stakeholders who aren’t knee-deep in the tech.
  
• Usability testing with real users ensures that what worked in theory (and on paper) still works when someone outside the team interacts with it. This is where you catch the subtle stuff — timing, tone, hesitations, or missed expectations.
  

Starting analog doesn’t slow you down. It sets you up to move faster when it matters most — during implementation. Instead of debugging logic and rewriting conversations in the same sprint, you’re just wiring up a design that’s already been field-tested with your team.

It’s the difference between building a chatbot and launching one that people actually enjoy using.

Conclusion: Why analog-first design still wins

In a world full of smart assistants and machine-learned models, it’s easy to assume that AI-first is the only way forward. But here’s the truth: the best conversational AI design process doesn’t start with code. It starts with conversation.

Analog methods may seem low-tech, but they’re powerfully human. They give your team the space to think clearly, test quickly, and build something people actually want to talk to.

Key Takeaways:

• Intent cards keep your team aligned on what users actually need.
• Paper prototyping lets you explore ideas without being boxed in by tools.
• Role-playing helps uncover the rough spots before they frustrate users.
• Storyboarding ensures your chatbot can adapt when users change their minds (and they will).

By starting analog, you’re not slowing down, you’re laying the groundwork for a bot that feels intuitive, responsive, and genuinely helpful. It’s not just good design. It’s a good strategy.

Next Steps:

Pick one of these methods and try it out on your next project. Grab some sticky notes, a few teammates, and start talking it out. You might be surprised by how far you can get before you ever open a design tool.