AI Workflow: Build Fast. Test Faster.
A framework (+ prompts!) on how to use AI to create a prototype, run interviews, and spot insights before you waste time building the wrong thing.
We’re all moving faster.
With AI, you can jump from idea to something tangible by the end of the day.
And it’s not just designers or developers anymore. Founders, product managers, marketers, and anyone with ideas can create a prototype in hours with vibecoding.
But building fast isn’t the real advantage.
The real edge is testing faster, putting your idea in front of people, capturing feedback, and learning what’s worth building before you burn time and money going all in.
That’s why I prepared a simple framework for anyone who wants to build fast and test faster with the help of AI.
Skipping This Step Is Where Most Projects Burn Time And Money
Most teams skip testing.
Not because they don’t care, but because it feels slow, expensive, and optional.
When you’re in the excitement of building, you convince yourself you’ll figure it out later:
“I already know the problem.”
“It’s faster just to launch and see what happens.”
“Research is for big companies.”
Now that building is faster with AI, there’s no excuse not to test. If you can create a prototype in hours, you can get feedback just as quickly. A few short conversations today can save you months of rework tomorrow.
A Simple Framework Powered by AI:
You don’t need a complicated process.
Here’s a lightweight flow that I usually use on my projects:
Build a prototype with AI
Use AI to prepare for 1:1 interviews
Talk to 5-7 people
Use AI to analyze the feedback
Implement the learning
Let’s get into the details.
Building Something with AI
Before you can test, you need something people can react to.
It doesn’t need to be perfect, just real enough to get valuable feedback.
AI prototyping tools like Lovable or Replit are great at creating clickable front-end apps. That’s usually more than enough to test your idea with real people.
Be mindful of features that need backend or integrations (like authentication, payments, or APIs). These often require extra setup or services and can break your flow if left unclear. For early testing, it’s totally fine to simulate those features.
I usually start with a PRD (Product Requirements Document) to define and structure in detail what I want to build.
Specification Generation Prompt
Here’s a PRD prompt you can use in your favorite AI tool. Replace the placeholders with your own details and additionally upload any available documents, sketches, or design files:
Please help me design and generate a specification document that an AI prototyping tool (like Lovable or Replit) can use to build a clickable application.
PRODUCT NAME: [Your Product Name]
CONTEXT:
[Describe in 3–7 sentences:
- What the product does
- Who it’s for
- The problem it solves
- Style and design notes (fun, minimal, emoji-friendly, etc.)
- Any specific content you already know (titles, questions, button labels, menu items, footer text, sample recommendations)
- Constraints (e.g. 3 steps only, no backend, mobile-first)]
STRUCTURE THE OUTPUT LIKE THIS:
1. **Product Overview**
- Short description of purpose and main user goal
2. **User Flow**
- Step-by-step path from entry to exit
- For each step, describe actions, system response, and any error/validation states
3. **Screens (with complete text and content)**
For each screen, include:
- Title/header text
- Body content or questions
- All buttons/links with exact text labels and actions
- Menu/footer text
- Option labels with emojis or icons
- Microcopy for errors and validations (e.g. “Please select an option before continuing”)
- Empty states (e.g. “You haven’t saved anything yet”)
- Interaction feedback (highlight selected, disabled states, hover text)
4. **States and Data**
- What data is tracked (answers, selections, saved items)
- Example mock outputs (e.g. exactly 3 recommendations with titles, descriptions, emojis, price, and placeholder images)
- How saved items are stored and displayed (session only, in-memory)
5. **Edge Cases**
- No selection made → Next button disabled + error text
- Empty results or empty saved list → show friendly message
- Restart or exit behavior
6. **Style & Accessibility**
- Design tone (e.g. playful, colorful, emoji-heavy)
- Layout rules (mobile-first, responsive, grid/list where relevant)
- Accessibility basics (keyboard navigation, focus states, ARIA labels)
RULES FOR UNDEFINED FEATURES:
- Never leave dead links or undefined buttons.
- If a feature is mentioned but not fully defined, represent it explicitly with either:
- a **placeholder screen** (for nav/buttons) OR
- an **empty state** (for lists).
- Avoid vague ranges or optional wording. Always specify exact numbers, labels, and content.
- Default to in-memory only (no backend/database). If backend features are required, the spec must include exact endpoints, services, and fields. Otherwise simulate them with placeholders.
- Every data object must include enough fields to look realistic in a prototype (at least title + description + emoji/icon, and preferably price + placeholder image or status field).
FINAL OUTPUT:
Return everything in a clear, structured text block with ready-to-use content, error messages, and placeholders, so it can be dropped directly into Lovable or Replit to generate a working clickable application.Check-up Prompt 👀
When you write a product spec with AI, it’s easy to miss small details that break when you drop it into Lovable or Replit: buttons that lead nowhere, vague numbers, or features that need more information.
That’s why you always need to review everything the AI generates.
I also run the document through a check-up prompt before dropping it in Lovable/Replit:
Please review this product specification and refine it so it’s ready to use with an AI prototyping tool (like Lovable or Replit).
Check for:
- Undefined nav items or dead links
- Vague ranges (e.g. “2–3 items”)
- Missing text (buttons, labels, error messages, empty states)
- Data objects that are underspecified (e.g. a “product” without title/description/image/price, a “task” without status/priority/due date)
- Features that require backend logic or 3rd-party services when only in-memory behavior is defined
- Interaction or confirmation states that are not clearly described (what happens after a click)
- Gaps in flow, such as:
- What happens if a user clicks nav items during a flow (e.g. mid-quiz)
- What Saved/History screens show (if in nav)
- Whether saving an item shows confirmation (toast, inline message)
- Any extra screens or messages needed to make the flow smooth
Fixes:
- Replace vague ranges with exact numbers.
- If a feature is mentioned but not fully defined, always represent it explicitly with either a placeholder screen or an empty state (never remove features).
- Default to in-memory only (no backend/database). If backend features are mentioned (e.g. login, payments, APIs), simulate them with placeholder flows unless endpoints and services are explicitly defined.
- Every button, option, and screen must have a clear label and action. If a button has no real action, link it to a placeholder screen.
- Every data object must include enough fields to look realistic in a prototype (at least 3–4 fields).
Final Output:
1. A short review summary (issues or risks found)
2. A corrected and refined version of the spec, ready for Lovable/Replit Run the prompt. Check results and refine!
Gather Feedback Through User Testing Interviews
Let’s test what you’ve built! ✨
It’s tempting to keep tweaking your prototype in isolation, but real progress happens when you put it in front of people. Testing with people isn’t about proving you’re right; it’s about discovering how your solution behaves in real life.
Interviews are one of the simplest ways to do this. They give you raw, unfiltered reactions: what makes sense, what feels awkward, and what sparks interest.
“You can’t design for people without understanding people” — Erika Hall
How to run a quick test:
Find 5–10 people who match your target audience.
Book a 30–45 min chat with each.
Share your prototype (screen share or link).
Ask your prepared questions while they try it.
Record the session (with permission).
Take notes on what they say and do.
General notes:
Use one customer persona per research goal.
Have a fixed list of questions to ask every participant.
Allow space for open conversations with each person.
Keep the session no longer than 45 minutes.
Always prepare a script; it ensures you don’t miss essential questions.
Prepare your interview script 💬
Copy the template below and fill in your details to generate an interview script:
Please help me prepare a user testing interview guide.
Context:
[Paste your PRD, include prototype screenshots, or write a short description of your product/feature]
Persona Description:
[Who you’re testing with]
Research goal:
[What you want to learn, e.g. validate an assumption, test usability, check value]
Assumptions to validate:
[List the key things you want answers to]
Deliverables:
1. 10 open-ended interview questions tailored to my goal, product flow, and persona.
2. 3 follow-up prompts I can use if participants give short answers.
3. A short reminder list of at least 5 common mistakes to avoid (e.g. leading questions, yes/no traps). Analyze the Results
You’ve built, you’ve tested.
Now you get to discover what people actually thought.
User interviews are full of hidden gems: little comments, moments of hesitation, sparks of excitement. Finding patterns is what gives you clarity and shows you where to go next.
What AI is great at:
Turning recordings into clean transcripts.
Summarizing each session into simple bullet points.
Spotting patterns across people (where they got stuck, what they loved)
Surfacing surprises or contradictions you might overlook.
Pulling out quotes you can reuse.
What still needs you:
The cultural references or language shortcuts that only make sense in context.
The way someone’s body language contradicts what they’re saying.
Distinguish between polite feedback and genuine excitement.
Weigh which issues actually connect to your product goals.
Prompt for Analyzing the Results
Drop your recorded interview transcripts into ChatGPT, Claude, or NotebookLM, paste the prompt below, and you’ll get clean, structured, and analyzed results.
Here’s the prompt 👇
Please analyze the following user interview transcripts and output the results in **four tables** using the structure below.
---
1. **Participant Notes Table**
| Participant | Demographics & Background | Key Notes (per screen/topic) | Quotes |
Rules:
- One row per participant.
- Summarize key observations in plain language.
- Include at least 1–2 direct quotes per participant.
---
2. **Patterns & Themes Table**
| Pattern | Supporting Quotes | Users |
Rules:
- Extract up to 6 major themes across all participants.
- Each pattern must include at least one direct quote and list which participants mentioned it.
---
3. **Assumptions Validation Table**
| Assumption | Validated? (Yes/No/Mixed) | Evidence / Quotes |
Rules:
- Use the list of assumptions I provide (or extract implied ones if none are given).
- Mark each assumption as ✅ Yes, ❌ No, or ⚠️ Inconclusive.
- Always include at least one supporting quote.
---
4. **Questions & Answers Table**
| Screen / Step | Question | Answer (Summarized) | Supporting Quotes |
Rules:
- For each of my research questions, summarize what participants said.
- Keep answers short and grounded in quotes.
---
General Rules:
- Always include quotes alongside summaries (don’t paraphrase only).
- If something is unclear or missing, write “Needs human interpretation.”
- Stay grounded in the transcripts (no invented insights).
- Output must be clean, formatted Markdown tables only.
The real shift isn’t about tools.
It’s about mindset.
AI makes it easy to build fast, but the real win is when you also test fast.
This framework is just a starting point.
Use it, adapt it, make it yours.
Just don’t skip the testing!
A proper AI-enhanced product development process, not just jumping straight into the dopamine-rushing instant UI. Makes me think of the 5-step Design Thinking process (Understand, Define, Ideate, Prototype, Test), but with an AI twist :)
Outstanding framework! Your step-by-step AI prototyping and testing guide is essential for anyone serious about building the right product fast.
For AI trends and practical insights, check out my Substack, where I break down the latest in AI.