You build an MVP with AI by keeping the scope to one core workflow, choosing a common stack that coding agents know well, and handing the agent small, testable tasks while you make the product decisions. This guide walks through scoping, stack choice, a week-by-week build plan, validation and launch, with prompts and checklists.
- AI speeds up the building; the deciding is still yours. Scope the MVP to one user, one problem and one core workflow before any code.
- Pick a popular, boring stack (for example Next.js, Postgres and Stripe) because agents have seen it the most and make fewer mistakes.
- Write a short spec and a CLAUDE.md first, then give the agent one feature at a time with acceptance criteria and a test command.
- Review every diff, keep tests on the money and auth paths, and deploy from week one so real users can try it.
- Measure one validation signal (paid signups, retained users, booked calls) and decide what to build next from it.
How do you build an MVP with AI?
You build an MVP (minimum viable product) with AI by separating the two jobs. You decide what the product is, who it serves and what is in or out. An AI coding agent does most of the typing: scaffolding, features, tests and fixes, in small reviewed steps. The result is a real app in front of users in weeks instead of months.
The process in one view:
| Phase | You do | The AI does | Typical time |
|---|---|---|---|
| Scope | Pick the user, problem and one core workflow | Challenge your scope, list edge cases | 1 to 3 days |
| Set up | Choose stack, create repo, write spec and CLAUDE.md | Scaffold the project, set up tooling | 1 day |
| Build | Write tasks, review diffs, test the app | Implement features and tests | 1 to 4 weeks |
| Validate | Recruit users, watch them, collect signals | Fix bugs, add instrumentation | Ongoing |
| Launch | Pricing, launch post, support | Landing page, emails, docs | 2 to 5 days |
AI makes the build phase much faster. It does not shorten the time you need to talk to users, and it makes scope creep easier, because adding "one more feature" feels free. The bigger risk is building the wrong thing quickly.
How do you scope an MVP so AI can build it?
Scope the MVP to one type of user, one painful problem and one workflow that solves it end to end. Everything else waits. A tight scope is what lets an agent finish features reliably, because each task stays small and testable.
Write a one-page spec before you open any coding tool:
MVP spec: ShiftSwapUser: shift managers at independent cafes (5 to 30 staff).Problem: staff swap shifts by text message; managers lose track and getunderstaffed days.Core workflow:1. Manager uploads the weekly schedule (CSV or manual entry).2. Staff request a swap; a coworker accepts.3. Manager approves with one tap; the schedule updates and both get an email.In scope: accounts (email login), one location per account, swap requests,approval, email notifications, Stripe subscription ($29/month).Out of scope: payroll, multiple locations, mobile app, SMS, integrations.Success signal: 10 cafes paying after a 14-day trial.Then ask the AI to attack it before it builds anything:
Read docs/spec.md. Act as a skeptical product advisor.1. List the 5 riskiest assumptions in this spec.2. Suggest anything in scope that could be cut without hurting the core workflow.3. List edge cases in the core workflow I haven't specified (e.g., what if nobody accepts a swap?). For each, propose the simplest acceptable behavior.Do not write code.Update the spec with the answers you agree with. The "out of scope" list is the most useful part of the document, because you will point the agent at it every time it offers to add something extra.
Which tech stack should you use for an AI-built MVP?
Use a popular, well-documented stack. Coding agents write better code in frameworks they have seen millions of times, and you will find answers faster when something breaks. A common choice for web MVPs:
| Layer | Common choice | Why it suits AI-built MVPs |
|---|---|---|
| Framework | Next.js (React, TypeScript) | Huge amount of example code; front end and API in one repo |
| Database | Postgres (for example Supabase or Neon) | Standard SQL, easy to inspect, migrations are well understood |
| Auth | A managed auth library or service | Auth is easy to get subtly wrong; don't hand-roll it |
| Payments | Stripe Checkout and Billing | Hosted checkout keeps card data off your servers |
| A transactional email API | Simple HTTP calls, good docs | |
| Hosting | A platform with git-push deploys | Preview deploys for every branch |
Rules that matter more than the specific picks:
- TypeScript over plain JavaScript. Type errors catch many AI mistakes before you run anything.
- One repo, one language where possible. Fewer moving parts means fewer places for an agent to get lost.
- Managed services for auth, payments and email. These are where mistakes are expensive.
- Avoid brand-new libraries. If a package shipped last month, the model may not know its API.
For a mobile-first product, Expo (React Native) follows the same logic. The hands-on guide to building a Next.js app with Claude Code covers this stack step by step.
AI app builder or coding agent?
Use an AI app builder to test an idea in days; use a coding agent in a normal repository when you plan to keep building. Both are valid MVP routes.
| AI app builders (Lovable, Bolt, Replit) | Coding agents (Claude Code, Codex) | |
|---|---|---|
| Setup | None, runs in the browser | Repo, local or cloud environment |
| Best for | Validating demand fast, standard app shapes | Custom logic, long-term product |
| Control | Limited to what the platform exposes | Full: any library, any architecture |
| Code ownership | Usually exportable | It's your repo from day one |
| Learning curve | Lowest | Moderate: you review diffs and run commands |
Many founders prototype in an app builder, show it to ten potential customers, and rebuild properly with a coding agent once the idea holds up. The comparison of no-code AI tools covers the builder side in more depth.
Week-by-week plan to build an MVP with a coding agent
This plan assumes a coding agent such as Claude Code, part-time effort, and the scope above. Adjust the pace, keep the order.
Week 0: setup
- Create a GitHub repository and add
docs/spec.md. - Ask the agent to scaffold the project with your stack, a linter, a formatter and a test runner.
- Run
/initin Claude Code to generate a startingCLAUDE.md, then edit it down to the essentials: commands, conventions, and what is out of scope. - Deploy the empty app so every later change ships through the same pipeline.
A short project memory file keeps the agent consistent across sessions. The Claude Code memory docs explain how it is loaded.
Project: ShiftSwapSpec: docs/spec.md. Do not build anything listed under "Out of scope".## Commands- Dev: npm run dev- Test: npm test- Lint and types: npm run lint && npm run typecheck## Rules- TypeScript strict. No `any`.- All DB changes through migrations in db/migrations.- Every API route checks the session and the user's location_id.- Run lint, typecheck and tests before saying a task is done.Week 1: data model and core workflow
Have the agent propose the database schema in plan mode first (claude --permission-mode plan, or press Shift+Tab in a session). Review it, then build the core workflow end to end with fake data: upload schedule, request swap, approve. Ugly UI is fine.
Week 2: accounts, permissions and email
Add real login, scope every query to the user's account, and send the notification emails. Ask for tests that prove one account cannot see another's data. This is the week where review matters most.
Week 3: payments and polish
Add Stripe Checkout for the subscription and a webhook that updates the account's plan. Then fix the rough edges you found by using the app yourself every day.
Week 4: users
Put it in front of five to ten real users. Watch them use it, write down where they get stuck, and turn that into the next tasks.
How do you write tasks an AI agent can finish?
Give the agent one feature at a time, with the context it needs, clear acceptance criteria and a way to check its own work. Vague tasks produce large, wandering diffs.
| Weak task | Strong task |
|---|---|
| "Add shift swapping" | "Add a POST /api/swaps endpoint that creates a swap request for a shift the user owns. Reject if the shift is in the past or already has an open request. Add tests for both rejections. Follow the pattern in app/api/shifts. Run npm test before finishing." |
A reusable template:
Task: [one feature, one sentence]Context: [files or patterns to follow; relevant part of docs/spec.md]Acceptance criteria:- [observable behavior 1]- [observable behavior 2]- [error case and expected response]Constraints: [don't add dependencies / don't touch X / out of scope items]Done when: lint, typecheck and tests pass, and you've summarized the changesand anything you were unsure about.More templates are in the guide on how to write tasks for AI coding agents. For tasks that run long, let the agent work in its own branch or worktree (claude --worktree swaps-api) so you can keep using the main checkout.
How do you keep AI-written MVP code from becoming a mess?
Keep each change small, review every diff, and protect the parts where bugs cost money or trust. AI agents write plausible code quickly; you are the one who notices when plausible is wrong.
- Review diffs, not summaries. The agent's summary describes intent. The diff shows what happened.
- Test the expensive paths. Auth, permissions, payments and anything that deletes data get automated tests. See the guide to writing unit tests with AI.
- Commit often. Small commits make it easy to revert a bad change instead of untangling it.
- Refactor on a schedule. Every week or two, ask the agent to find duplication and inconsistencies and propose cleanups, then review them like any other change.
- Never paste secrets into prompts. Keep keys in environment variables and out of the repo.
Do not let an agent run against your production database or with live payment keys while building. Use a separate development database and Stripe test mode until launch.
How do you validate and launch an AI-built MVP?
Validate with one clear signal tied to your spec, and launch as soon as the core workflow works for real users. Polishing before anyone uses the product is the most common way to waste the speed AI gives you.
- Pick the signal before launch: paid conversions, weekly active teams, or booked demos. Write it in the spec.
- Instrument it: ask the agent to add basic analytics events for signup, core action completed, and payment.
- Recruit directly: message 30 to 50 people who match your user description. Your first users usually come from direct conversations.
- Watch sessions: a short video call where a user shares their screen teaches more than a week of analytics.
- Turn feedback into tasks: each observed problem becomes one agent task with acceptance criteria.
- Decide on a date: after two to four weeks, keep going, change direction, or stop, based on the signal.
Agents can keep working while you are doing the user interviews. If your laptop is the only place your agent runs, it stops when the lid closes. A hosted box such as Orkio runs Claude Code around the clock with a ready Web/SaaS (Next.js) kit, so you can queue tasks from your phone between calls and review pull requests later. The guide to an overnight AI agent workflow shows how to plan work that finishes unattended.
MVP checklist: start this week
- Write a one-page spec with user, problem, core workflow, out of scope and success signal.
- Ask an AI to attack the spec, then cut scope.
- Pick a popular stack and create the repository.
- Scaffold, add lint, typecheck and tests, and deploy the empty app.
- Write a short CLAUDE.md with commands, rules and the out-of-scope list.
- Build the core workflow end to end before anything else.
- Add auth, permissions and payments with tests on each.
- Put it in front of real users within four weeks and measure your one signal.
Frequently asked questions
Can I build an MVP with AI without knowing how to code?
You can get a working prototype with AI app builders or a coding agent and no coding background. For anything that handles payments or user data, learn enough to read diffs, run tests and understand your database, or bring in a developer to review the security-sensitive parts.
How long does it take to build an MVP with AI?
A tightly scoped MVP with one core workflow, accounts and payments commonly takes two to six weeks of part-time work with a coding agent. Scope decides the timeline far more than typing speed, and unclear requirements cost more time than any technical task.
What is the best AI tool for building an MVP?
For a quick clickable prototype, an AI app builder such as Lovable, Bolt or Replit is fastest. For an MVP you plan to grow, a coding agent like Claude Code or Codex working in a normal GitHub repository gives you code you own and can maintain.
How much does it cost to build an MVP with AI?
The main costs are an AI subscription or API usage, hosting, a domain and any paid services such as email or payments. Many MVPs run on low monthly costs at first; the bigger cost is your time spent scoping, reviewing and talking to users.
Should I use no-code or code for my MVP?
Use no-code if you need to test demand in days and the product is a standard shape. Use code with a coding agent if the core of the product is custom logic, if you expect to iterate for months, or if you need to own and audit the code.
