Why your MVP should do less than you think

Startups get an MVP built by one of five kinds of builder: a development agency or studio, freelancers, a technical co-founder, their first in-house engineers, or the founders themselves with no-code tools or AI coding assistants. Whoever builds it, the first version should do less than you think. Reveneau builds MVPs for startups: AI writes all of its code, and every change has to pass an eval suite written from the specification before it is released.
It is tempting to build more into a first version than it needs. The team cares about the product, so every feature feels important, and cutting any of them feels like releasing something unfinished. So the "minimum" product grows, and what was supposed to be a quick first version turns into a six-month build. Then it launches, and only then does the team find out whether the core idea worked at all. By that point the money and time are already spent. Your MVP should do less than you think, and that makes it stronger.
Who builds MVPs for startups?
Each kind of builder fits a different founder, and each leaves different work with you.
| Builder | Fits when | What stays with you |
|---|---|---|
| A development agency or studio | You want design and engineering from one team that owns the build | Deciding the scope and answering the team's questions |
| Freelancers | The scope is small and you can direct the work yourself | The plan, the reviews, and putting the pieces together |
| A technical co-founder | The product is the company and you need someone to own it for years | A share of the company |
| Your first in-house engineers | You have raised enough to hire and plan to build the product for the long term | Hiring, which takes time before any work starts |
| The founders, with no-code tools or AI coding assistants | You want to test the idea before you pay anyone | Your own time, and a rebuild if the tool cannot grow with the product |
Whichever you choose, settle three things in writing before work starts:
- Who owns the code. Under US copyright law, the author of a work is ordinarily the person who created it. The US Copyright Office's Circular 30 (revised August 2024, read 4 November 2026) lists nine kinds of commissioned work that can be "made for hire" under a signed agreement, and computer programs are not among them. So the code an outside builder writes becomes yours through a transfer of the copyright, and 17 U.S.C. 204(a) (read the same day) says a transfer is valid only when it "is in writing and signed by the owner of the rights conveyed". Keep the code in a repository you control from the first day. The guide on who owns code a partner or an AI writes explains the rules.
- What the first version includes. Agree a fixed scope and a written list of what was cut, for the reasons in the rest of this post.
- How each change is checked. Ask how every change is tested before it reaches users, and who writes the tests.
Reveneau works this way. AI writes all of its code, and every change has to pass an eval suite written from the specification. We use AI instead of hiring more engineers, so the build takes a small team, and that saving goes into your price. See how we work with startups.
What is an MVP for?
Start with what an MVP is for, because the name confuses people. Minimum viable product sounds like "the cheap version of the real thing." An MVP is a tool for learning, as fast as possible, whether your idea works.
That changes how you build it. If an MVP were a small version of the full product, you would want it to be as complete as you could afford, and every feature you added would make it better. A learning tool has a different job: get you real evidence about the core idea as quickly as possible. Judged that way, extra features make the MVP slower to build and slower to teach you anything, which makes it worse at its job. Once you see the MVP as a way to reach the truth quickly, cutting features stops feeling like a loss.
Every feature you add before launch delays learning
Every feature you add before launch delays the day you learn whether the product works.
The logic is simple. Each feature takes time to build and test before you can launch. Until you launch and real users touch the product, everything you believe about it is a guess. So each feature you add is more time spent guessing and less time spent learning. A team that adds ten features to its first version has delayed the moment it learns the answer by however long those ten features took, while risking all of that time on assumptions it has not tested. If the core idea turns out to be wrong, all of that extra effort was spent making a wrong thing more elaborate.
This is why a big first version hides risk. Launching something complete feels safer, and it is riskier, because you have committed more before learning anything, and you find out later, when changing direction is most expensive. A smaller MVP feels risky and is safer, because it gets you to real feedback while you can still act on it cheaply. We made a version of this argument about custom builds in general in build vs buy: the research on large software projects is direct, and the pattern holds here too. Bigger means more risk. Smaller means more safety.
How do I decide what to cut from an MVP?
Knowing you should do less is easy. Cutting is hard, and it is a discipline you have to practice deliberately, because the pressure always pushes the other way.
The tool that helps most is a single question you ask of every proposed feature: can the product teach me what I need to learn without this? If the answer is yes, the feature waits until after launch. The decision is narrow: the feature is not required to test whether the core idea works, so it does not belong in the version whose only job is to run that test. Features that feel essential before launch often fail this question. The extra settings, the second user type, the final details on flows nobody has even reached yet, the integrations you assume people will want. Each one feels necessary, and few of them are needed to learn the one thing you are launching to learn.
A practical trick makes the cutting easier: keep a "later" list. Every feature you cut goes on it, written down, waiting for evidence. This matters because the resistance to cutting comes from fear of losing the idea. Write it down and the fear goes away, and the team stops arguing to keep features in the launch because they can see the features are safe on the list. Tie each item to the question it would help answer, and you will find that many of them are answering questions you do not even have yet.
Do one thing, and do it well
When you reduce an MVP, the one thing that remains, the core reason the product is worth using, should be done well. That is the thing you are testing, so it has to be good enough to give an honest test.
Think of it as concentrating your quality instead of spreading it across many features. A full first version spreads a fixed amount of effort across many features, so everything is rough. A small MVP puts that same effort behind the one thing that matters, so that one thing is good, and the rough or missing pieces are all in the parts that do not matter yet. Users forgive a lot of missing features if the core does its job well. They do not forgive a weak core no matter how many features surround it. So the rule is "do one thing, and do that one thing well." Find the single core action that makes the product worth using, make that excellent, and let everything else be rough or absent for now.
After launch, let evidence decide
The MVP starts a cycle. You release the small version, you watch how real users behave, you learn what they value, and you add only what the evidence says matters. Adding features after launch is fine and expected. The discipline is to wait for evidence before you add them. After launch, you have evidence, so adding is informed instead of a guess.
This is what makes doing less worth it. The team that launched small is now learning from real behavior, adding the features users use, and dropping the ones from the "later" list that nobody ever missed. The team that launched big is still discovering, weeks later, that half of what they built goes unused, and now they own all of it: the maintenance, the complexity, the code that has to keep working even though it earns nothing. Small got the answer faster and has less to maintain. That is the whole case for doing less: it is the fastest honest way to know whether the thing you are building is worth building further. If you want a team that will encourage you to cut rather than add more, that instinct is central to how we approach a full product build.
The argument for a small MVP got stronger once building became cheap. When building was expensive, "build less" was partly a budget argument, and a team with more funding could reasonably ignore it. That budget argument is gone: you can now afford to build the large version.
You still should not. Every feature in an MVP is something to explain, support, and keep working, and each one adds a place where user feedback about the core idea gets mixed up with feedback about a less important one. An MVP stays small so that what you learn from it means something.
Sources
- US Copyright Office, Circular 30, "Works Made for Hire" (revised August 2024, read 4 November 2026): https://www.copyright.gov/circs/circ30.pdf
- 17 U.S.C. 204(a), Execution of transfers of copyright ownership, Legal Information Institute (read 4 November 2026): https://www.law.cornell.edu/uscode/text/17/204


