Guide · tools compared on the question other lists skip
AI prototyping tools for product managers — and what happens after the prototype
Written for PMs, and just as much for product designers and founders who prototype to think. Every list of AI prototyping tools ranks the same thing: how fast an idea becomes a clickable demo. Fair — but it ranks only half the decision. The half that costs you a quarter is what the prototype becomes afterwards: a throwaway, a handoff artifact for engineers, or the first version of the product itself. This list adds that column.
First, the sorting insight, because it reframes the whole list: "prototype" is not one artifact — it is three, with different fates. A throwaway exists to answer one question (do users understand this? which direction wins?) and should die young, guilt-free. A handoff exists to align engineers — it carries intent into a codebase someone else builds. A shippable is the rarest kind: the prototype that hardens into the actual product. Most tool lists implicitly assume the first two and never say so. Once you ask "and then what?", tools that look interchangeable turn out to be built for different fates — and picking by demo speed alone is how validated ideas end up rebuilt from zero. (Why that rebuild stopped being mandatory is the argument of the series opener; this page is its practical companion.)
The design-native prototypers: Figma Make
Figma Make is prototyping in its purest, most design-team-shaped form: "prompt your way to a functional prototype, fast", inside the ecosystem where product designers already live. Its two exits say exactly what it is for — copy the result back "as design layers to continue iterating in Figma Design", or connect Supabase to "turn your idea into a web app that's ready to ship". Its page doesn't state which Figma plans include it — check yours.
And then what? Mostly throwaway-by-design, and that is praise: the fastest route from a design discussion to a testable thing, with the output flowing back into the design system rather than toward an app store. For design-org alignment work, this is the tool the meeting deserves.
The web-app prototypers: v0, Bolt, Lovable
Three tools, one fate profile: describe → get a working web app → share a link today.
v0 by Vercel — "design, iterate, and scale full-stack applications for the web", with one-click deploy to Vercel and push-to-GitHub. Pricing isn't on the homepage; see their pricing page. Its natural home is teams already on React/Vercel — which makes it the strongest handoff tool here: the prototype lands in the exact stack many web engineering teams will keep.
Bolt — "create stunning apps & websites by chatting with AI"; websites, apps, prototypes, even slides; imports from Figma and GitHub; hosting through Bolt Cloud. Free tier to start; prices not disclosed on the homepage. The pitch is staying in one ecosystem end-to-end — prototype and hosting under one roof.
Lovable — the one your team has probably already used: React web apps with GitHub sync and a Supabase-default backend, Pro from $25/month. For a web product, Lovable's output is genuinely shippable — plenty of real products run on it, and this site treats it as the reference web builder.
And then what? For web products: shippable — the honest answer, and these tools deserve it. For a phone product: this is where the ceiling from the series opener lives. The output is web code; the App Store wants native. The classic path — validate on Lovable, then rebuild for mobile — at least lets you keep the backend, but the front is a rebuild, and no column in the usual listicles warns you.
The agentic full-stack builders: Emergent
Emergent sells the step past prototyping: agents that build deployable full-stack products, with "You own all the code Emergent generates" as an explicit promise. Credit-metered: free tier with 10 credits, Standard at $20/month for 100, Pro at $200/month for 750.
And then what? For web products, shippable-with-ownership — the code-ownership sentence matters and few prototypers say it that plainly. For mobile: their pages do not state what their mobile output is built on — no framework named. That's not a gotcha; it's the exact question this article says to ask, unanswered. If mobile is your destination, ask it before the credits start.
The mobile-output tier: Rork and Modaal
Two tools whose prototypes are phone-shaped from the first prompt — and a fork inside the tier that matters more than the tier itself.
Rork — describe an app, get React Native/Expo output: cross-platform JavaScript that runs on iPhone and Android. Pro is $20/month for 100 credits. As a mobile prototyper it does what the web tools do, but on the right device. The two asterisks for the "and then what" column: the output is cross-platform rather than platform-native (a translator between your app and the phone), and the credit meter prices each iteration — fine for a bounded prototype sprint, worth arithmetic for the long build after.
Modaal (ours) — the entry that exists because of this article's column. You describe the product; it writes real Swift/SwiftUI for iPhone and real Kotlin/Jetpack Compose for Android, both from one project, with the code on your own disk. The workflow is the product-person workflow made literal: a PRD at project start, then a reviewable spec for every feature before code is written — the spec-driven loop — and the free plan is one project with unlimited prompts, so iteration isn't metered. Pro is €9/month annual for both platforms and store distribution.
And then what? This tier's answer is the point: the prototype and the product are the same artifact. You don't validate and then rebuild — the thing testers hold on TestFlight in week two is the thing that ships. The honest trade: Modaal is Mac-only, mobile-only, and spec-first — a structure that rewards product people and is deliberately not a toy.
How to pick: match the tool to the prototype’s fate
Skip the feature comparisons; decide the fate first, then the tool picks itself.
Fate: answer one question and die. Figma Make (design-org questions) or any web prototyper (demand and flow questions). Optimize for speed, feel zero guilt, budget nothing.
Fate: align engineers who will build in their own codebase. v0 if they live in React/Vercel; Lovable or Bolt otherwise. The prototype is a communication artifact — its code quality is nobody's problem.
Fate: become the product — on the web. Lovable, v0, Bolt or Emergent, judged now as builders, not prototypers: ownership, backend, export.
Fate: become the product — on phones. Decide web app or native app first. If native, prototype in the tool that ships native — Rork if a JavaScript team inherits the code; Modaal if the goal is platform-native output from a spec. And if you're choosing among mobile builders generally, the stack-first chooser is the fuller map — this page is the PM's cut of it.
One meta-rule from watching product teams adopt these tools: the expensive mistake is not picking a weak prototyper — they are all good now. It is validating a phone-shaped product on a web-shaped tool and only then reading the "and then what" column. Read it first and the quarter goes differently.
Seven tools, one honest column
| Tool | Output | Entry price (their pages) | And then what? |
|---|---|---|---|
| Figma Make | Functional prototype in the Figma ecosystem | Plan inclusion not stated on its page | Throwaway by design; back into Figma, or Supabase web app |
| v0 (Vercel) | Full-stack web apps (React/Vercel) | Not shown on homepage — see pricing page | Handoff to React teams; shippable for web |
| Bolt | Web apps & sites, hosted in Bolt Cloud | Free tier; prices not on homepage | Shippable for web, in-ecosystem |
| Lovable | React web apps, Supabase backend, GitHub sync | Pro from $25/mo | Shippable for web; phone product = rebuild (backend survives) |
| Emergent | Agent-built full-stack products; "you own all the code" | Free 10 credits; $20/mo for 100 | Shippable for web; mobile framework not stated on their pages |
| Rork | React Native/Expo cross-platform mobile | $20/mo Pro, 100 credits | Shippable cross-platform; credit-metered iteration |
| Modaal (ours) | Native Swift + Kotlin from one project, code on your disk | Free: 1 project, unlimited prompts | Prototype and product are the same artifact |
All claims from vendors’ own pages, checked 4 September 2026 (Lovable, Emergent, Rork verified earlier this quarter, dates in text). Where a page doesn’t state a fact, the cell says so — check current pages before budgeting.
Frequently asked questions
It depends on the prototype’s fate, not on rankings. For design-org exploration: Figma Make. For fast web demos and user tests: Lovable, v0, or Bolt. For agent-built full-stack web products: Emergent. For phone-shaped products, prototype in a tool whose output ships on phones: Rork (React Native) or Modaal (native Swift and Kotlin from one project). All entry prices and gaps are in the table above, from the vendors’ own pages.
Sometimes — and knowing when is the whole game. Web prototypes from tools like Lovable can genuinely ship as web products. For mobile, most prototyping tools output web code, which the app stores and the phone’s capabilities don’t accept as a native app — that prototype becomes a rebuild. Tools with production-grade mobile output (native code, tests, code ownership) close the gap: the prototype hardens into the shipping app instead of being thrown away.
Four things, in order: the prototype’s fate (throwaway, handoff, or shippable); the output (web, cross-platform, or native — and whether that matches where the product will live); the meter (credit-priced iteration taxes the try-again loop that makes products good); and ownership (does the code land somewhere you control). Speed, which most lists rank first, is now roughly table stakes across all of them.
No — they moved the line. Static design exploration and design-system work stay in Figma, and Figma Make extends that world with functional prototypes. What changed is the next step: questions about real behavior — retention, notifications, daily use — are now cheap to test with working software instead of clickable mockups, which is why prototyping and building are converging into one loop.
- Vibe coding in 2026: the complete guide
The series hub — the loop, the limits, and the full tool landscape by output.
- Vibe coding for product managers
The series opener: why prototype stopped being the ceiling.
- How to choose an AI mobile app builder
The general stack-first chooser — this page’s wider map.
- Migrate a Lovable app to a mobile app
Already validated on web? What survives the move to native.
- Spec-driven mobile app development
The loop that turns a prototype habit into a shipping habit.