How to build a quick and dirty prototype to validate your idea

Most of us still build for weeks before anyone actually uses the product.

You don’t need to do that. Here’s how people can start using a “fake” version of your product in a day using AI.

The example we’ll use

To make this easy to follow, we’ll use a sample product. We'll call it ReplyBuddy.

ReplyBuddy takes a long, angry email from a customer and turns it into a short, calm reply you can send.

• You give it: an angry email
• It gives you: a reply that is calm, clear, and ready to paste into Gmail, Help Scout, or Intercom

You can replace ReplyBuddy with your own idea. The steps are the same.

Step 1: Pick one core action

Take your full feature list and cut it down to this one action: user going from X to Y.

For ReplyBuddy, that is: “In this demo, a founder goes from a long angry customer email to a short, calm reply they can send.”

If something does not help that X → Y change, don’t include it in the demo.

Step 2: List what your tool needs to know

Next, write down the data your tool needs for that action.

Keep it very simple. No code. Just a list.

For ReplyBuddy, it needs:

• The product name
• A one-line description of the product
• The angry email text
• The tone of the reply
• One key thing the founder wants to say in this reply - if any (they type this in for each email)
• Things they do not want to say

Later, the demo will output:

• The reply text
• Maybe a small header (“what this reply is based on”)

Write it like this:

Inputs:
- product_name
- product_one_line
- angry_email_text
- reply_tone
- key_point
- do_not_say
Output:
- reply_text

That’s the “shape” of your demo. You will keep this shape the same, no matter how you build it.

Step 3: Write the conversation as if you are the product

Now, write the exact messages your fake product will say. Do this in a doc first.

Here is a full script for ReplyBuddy. Use it as an example from which to base your own script.

1. Welcome

“Hi, I’m ReplyBuddy. I turn long, angry customer emails into short, calm replies. We’ll do this in 2–3 minutes. Ready to start? (yes / no)”

2. Ask what the product is

“First, tell me about your product. What is your product called?”

(wait for answer)

“And in one short sentence, what does it do?”

3. Ask for the angry email

“Now paste one real angry customer email. Paste the full message. No need to clean it.”

4. Ask for reply tone

“How do you want to sound in your reply?

• Calm and formal
• Calm and friendly
• Direct, but not rude”

5. Ask for their key point

“What is one thing you want to make sure is said?”

Examples might include, “We fixed the bug” or, ‘We’ve initiated a refund.”

6. Ask what not to say

“Is there anything you do NOT want to say?

Example: ‘Do not offer a refund here’ or ‘Do not promise a date for a new feature.’

Now you have all the data you said you’d need. Time to show the “magic”.

Step 4: Design one simple “result screen”

Now decide how the answer will look.

Even if it’s plain text, treat it as a screen.

Shape first, content later.

For ReplyBuddy, you might use this layout:

Here's a draft of your reply:
-----------------------------------------
Product: SimpleBoard
Tone: calm and friendly
Key point: We fixed the bug already

Reply:
Hi [Customer Name],
[short calm opening written with empathy\]
[short explanation of what happened and what you did\]
[clear next step or offer]
Best,
[Your Name]
-----------------------------------------

Would you send this as-is?
1) Yes  
2) Almost - I'll tweak a few words 
 3) No - this doesn't feel right

This layout is always the same:

• Header: Product, tone, key point
• Body: The reply
• Final question: Do they like it or not?

Later, when you call the AI, you tell it: “Use this template. Don’t change the layout.”

That way, your demo feels like a real tool.

Step 5: Add feedback questions inside the demo

We want the demo to teach you, not just impress users.

After the reply, ask:

“Four quick questions:

1. On a scale of 1–10, how likely would you be to use this output?
2. What didn’t work for you?
3. If I build this into a full product, what is one thing it must do for you to pay for it?
4. Do you want to hear if/when I build it? If so, drop your email.”

Step 6: Put the demo into a tool

The demo steps don’t change. Only where it runs changes.

You can put it in:

• A chat-style AI agent
• A form with a small automation
• A small custom app

We’ll begin with the chat-style AI agent, since that’s what most people mean when they say “AI agent”.

1. Chat demo with an AI agent

You can use any chat AI tool, for example:

• Custom GPT
• Voiceflow
• Botpress
• Flowise
• Jotform AI Agents
• Other similar tools

The idea is the same in all of them.

a) Create the agent

Open your agent builder tool. Start a new agent (add your instructions into the system).

Tell it this (Staying with our example):

You are ReplyBuddy.

 You help solo founders turn angry customer emails into calm replies.

Your job:

*   Use the script from Step 3.    
*   Ask each question exactly as it is written.    
*   Ask the questions in the same order.    
*   After you get all the answers, write the reply in the layout below.    
*   Then ask the four feedback questions from Step 5.    
*   Then say goodbye to the user.    

Rules:

*   Use very simple language.    
*   Ask ONE question at a time.    
*   Stay on one topic.    
*   Do NOT say that you are an AI or a prototype.
    

Layout for the reply:
"Here's your reply draft:
Product: [product_name] 
Tone: \[reply_tone] 
Key point: [key_point\]
Reply: 
Hi [Customer Name], 
[full reply text here] 
Best, 
[Your Name]
 -----------------------------------------"
Tell the agent: always use this layout.

b) Add steps / blocks

In the flow editor:

• Block 1: Welcome message
• Block 2: Ask product name and one-liner
• Block 3: Ask for angry email
• Block 4: Ask for tone
• Block 5: Ask key point
• Block 6: Ask what not to say
• Block 7: LLM block that generates the reply using the layout
• Block 8: Ask the four feedback questions

Save each answer in a variable (product_name, angry_email, and so on). Use those variables in the LLM block.

Publish the agent. You’ll get a link.

Users can then:

• Click the link
• Chat with “ReplyBuddy”
• Paste a real email
• Get a reply that feels like it is from a real product

No backend needed. You just used an AI agent with your script.

2. Form and automation (form-first version)

If you don’t want chat, you can use a simple form.

1. Build the form

• Use Jotform or any form tool
• Add these fields:
  • Product name
  • One sentence about the product
  • Angry email (big text box)
  • Reply tone (choice list)
  • Key point (short text)
  • “Do not say” (short text)
  • Email address (optional)

In Make / Zapier:

1. Trigger: “New form submission”
2. Action: “Call OpenAI (or a similar AI tool)"
3. Action: “Send email to user” (reply draft and feedback questions)

In the AI step, send a prompt that:

• Includes all the form fields
• Asks for the reply in your fixed layout

Then email that reply to the user.

At the bottom of the email, you can add a small link to another form with the 3 feedback questions.

3. Small custom app (for devs)

If you write code, you can do this:

• Make a small HTML or React form with the same fields as above
• Add one API route that sends these fields to the model with your prompt
• Show the reply text in a simple <pre> or <div>

Under the reply, add a second small form with:

• Usefulness (1–10)
• What felt wrong
• What it must do for you to pay

Send this feedback to a simple endpoint. Save it in a database or even in a CSV file.

Nothing more is needed for v0.

Step 7: Get real people to use it – and capture what happens

Give your demo to:

• 5–10 founders you know
• People in your SaaS / indie hacker communities
• Your small audience on X / LinkedIn

The main value of this demo is what it can teach you. So, log:

• Input (in a safe way; you can hash or truncate emails if needed)
• The answer your demo gave
• How helpful they felt it was
• What felt off
• What it must do for them to pay money
• Their email address

Then look for patterns. If you get preliminary validation, your v1.0 roadmap should come directly from this.