An MVP in 2026 is a test of one assumption with one customer segment. A coding agent builds whatever the brief lists in days, so the build is no longer the hard part. The scope is: which belief to test, who to test it with, and which features wait.
Building and shipping got cheap, so you can validate an idea in days. Don't spend weeks debating what to build. Build it, then test it with a real user.
The workflow from idea to first user has four parts:
- Four scope decisions: the riskiest assumption (the belief whose failure ends the company), the beachhead customer (one narrow segment you can reach this month), the one job the product does, and the exclusions list
- One agent per decision: each agent writes a Markdown file, and the next agent starts from it
- One scope file:
mvp-scope.md, a one-page build brief your coding agent reads before every task - One first-user test: a real person from the beachhead does the core task on a recording, with no help from you
Skipping the decisions costs more than the build. Tanya Donska documented one case on HackerNoon in June 2026: a founder raised a $180,000 pre-seed, spent four months building, mostly in Lovable, and got about 90 people into the product. Seven returned. The app worked and shipped; nobody had decided what it was testing.
Building got cheap and the MVP split in two halves
Karan Shah of SoluteLabs put it in two sentences: "The MVP didn't die. It split."
One half is the prototype, and it costs almost nothing. YC's Jared Friedman says of a startup's product, "now 95% of it is built by an AI." The other half is the production system, and it got harder. Shah cites a Veracode finding: 45% of AI-generated code introduces an OWASP Top 10 vulnerability. Every feature the agent adds for free is code you now secure, test, and maintain.
So "minimum" changed meaning. It used to mean the least you could afford to build. Now it means the least you need to learn whether one assumption holds. Budget no longer limits scope. You do.
Search for "idea to MVP in two weeks" and you'll find build guides. Minimum viable product development is a learning exercise with a build attached, and the learning part still takes a founder's judgment.

Four decisions before code
Hand a coding agent a feature list and it builds the whole list. It has no reason to stop. These four decisions give it one.
- Riskiest assumption: the belief whose failure ends the company. Write it as a sentence a test can disprove: "Solo brand designers will connect their invoicing tool so software can chase late payments for them."
- Beachhead customer: the one narrow segment with weekly pain, reachable this month. "Freelancers" is a market. "Solo brand designers billing 5 to 15 clients a month" is a beachhead.
- The one job: the single task the product does from start to finish. One sentence, one verb.
- The exclusions list: every feature you considered and cut, written down. Team accounts, a dashboard, a mobile app, a second integration.
Founders skip the fourth, and it's the one an agent needs most. A coding agent reads silence as permission. If the brief doesn't say "no settings page," you get a settings page.
James Presbitero surveyed ten solo AI builders for Unpromptable. All ten builds started from personal friction, which is a fine source for an idea and a sample of one. One builder removed a validation score from their own tool because "scores create false confidence." The four decisions work the opposite way. Each is a plain sentence a customer can prove wrong.
Run one agent per decision
Each decision has an agent in Product Map. Connect a repository and the agents write their output as Markdown files, so each one starts from what the last one produced. The startup context playbook covers the full 12-step path; this is the short chain for scope.
- Validate the idea: Validate startup idea reads your one-pager and writes
problem-framing.mdwith assumptions ranked by risk. You pick the top one. - Define the ICP: Define ICP and segments reads the problem framing and writes
segmentation.mdplus an ICP file with hard disqualifiers. - Plan interviews: Plan customer interviews reads the ICP and writes
interview-guide.md. Then you talk to 10 to 15 people in the beachhead yourself. The agent plans; synthetic respondents can't tell you whether the pain is real. - Score the backlog: Prioritize product backlog reads your interview notes and feature ideas, then writes a scored
backlog.md.
One more agent closes the chain. Scope and challenge MVP reads all four outputs and argues for what to leave out. Its output is the scope file.

Put the scope in one file
mvp-scope.md fits on one page and has seven sections:
- Riskiest assumption: the sentence from decision one, plus the result that proves it wrong
- Beachhead customer: one sentence and a link to the ICP file
- The one job: the task, in the customer's words from the interviews
- Core task: the three to five steps a first user takes from landing to done
- In this version: three to five capabilities, each tied to a step of the core task
- Not in this version: every cut feature, the reason, and the evidence that brings it back
- First-user test: who you'll test with, the task you'll give them, and what counts as a pass
The sixth section does the work. Two entries from the invoicing example:
- Team accounts: the beachhead is solo designers. Revisit when three paying users ask.
- Stripe billing: the first ten customers get invoiced by hand. Revisit after the tenth.
Write the reason every time. An exclusion without one gets reopened whenever a new idea shows up, and with a coding agent a new idea ships the same afternoon.

Hand the scope file to Claude Code, Cursor, or Lovable
The scope file is the build brief. Where it goes depends on the tool:
- Claude Code: reference the file from
CLAUDE.md - Cursor and Codex: reference it from
AGENTS.md - Lovable: paste it into the project's knowledge settings before the first prompt
Then add three rules next to the reference:
- Read
mvp-scope.mdbefore any task. - Build only what "In this version" lists.
- If a request touches "Not in this version," stop and ask.
The third rule is there for you. Build guides miss this blind spot. On a team, an engineer answers a new idea with "three weeks," and the estimate does the filtering. A solo founder with a coding agent has nobody who says no. Cost used to be the brake on scope. Now the file is the brake, and the agent pausing to ask is the only pushback you'll get.
A short exclusions list also shrinks the security problem. Less generated code means fewer places for the 45% to land.
Keep the scope file next to the evidence behind it. Set up a product context repository holding problem-framing.md, the ICP, interview-guide.md, backlog.md, and mvp-scope.md. Connect a GitHub, GitLab, Bitbucket, or Azure Repos repository in Product Map and the agents commit their output there; the repo setup guide has the screens. Without the platform, copy the public startup-product-context template.
Then run both kinds of agent in one workspace. The Product Map plugin for Cursor and VS Code puts the PM agents in the sidebar, next to your coding agent. When a first-user test changes the scope, you update mvp-scope.md with the scope agent in the same window, and the coding agent reads the new version before its next task.

Test with one real first user
Find one person from the beachhead. Skip friends. Share a link, record the screen and their voice, give them the core task, and stay quiet. A pass means they finish without your help.
Now reread the opening numbers. Ninety arrivals mean the message reached people. Seven returns, about 8%, mean the product didn't finish a job worth coming back for. More traffic won't raise that number. A narrower scope will.
Check five items in week one:
- Completion: of five beachhead users, how many finish the core task unaided
- Stall point: the step where people stop; the recording shows it
- Return: who comes back within seven days without a reminder
- Requests: which excluded features they ask for. The same one from three of five users moves into scope. Everything else stays out.
- Verdict: whether the riskiest assumption held, failed, or needs another test. Write it into the scope file.
Metrics, launch criteria, and the channel plan come after this test; the startup product launch checklist picks up from there.
FAQ for founders
How long does an MVP take?
In 2026 the build takes days. The decisions take about a week, and the 10 to 15 interviews fill most of it. Plan two weeks from idea to the first recorded test.
What does an MVP cost?
Coding agents and app builders run about $20 to $25 a month per tool. The expensive line is time spent on the wrong version. The founder in Donska's story spent four months of a $180,000 pre-seed before learning seven people cared.
What's the difference between an MVP and a prototype?
A prototype answers "can this exist?" and you can ship one in place of a spec. An MVP answers "does this customer finish this job and return?" The first needs a coding agent. The second needs a scope file and a real user.
Start with the exclusions
Open an empty mvp-scope.md tonight and fill in "Not in this version" first. List ten features you were about to build and the reason each one waits. What survives is your one job.
Tomorrow, run the validation agent on the idea and book the first three interviews. Then find one person in your beachhead and press record.




