When Apps Get Built Faster, Unclear Requirements Cost More
Recently, AI has made it much faster and cheaper to build software. What it has not made cheaper is building the wrong thing.
Recently, AI has made it much faster and cheaper to build software. What it has not made cheaper is building the wrong thing.
Arguably, faster building can make that problem worse.
When you can go from an idea to a working application in hours, it is tempting to start building before some basic decisions have been made. But the application still needs those decisions.
If you don't make them, AI fills the gaps with assumptions.
And because it can build so quickly, those assumptions can become code, screens, data structures and business logic before anyone stops to question them. This is one reason AI slop isn't only about how something looks or reads. It can also exist underneath the application: software that works, but was built without enough thought about how the business actually works.
Every Gap Becomes an Assumption
Take Sarah, who wants to sell natural, organic, Ayurveda-inspired health supplements online. She wants customers to discover products, place an order, pay and have them shipped.
Sounds straightforward. But there are decisions hiding underneath it.
Can customers buy individual products and bundles? Are there different sizes? Where does Sarah ship? What happens when something is out of stock? Can an order be changed after it is placed? Will customers eventually be able to subscribe?
If these questions aren't answered, the application still has to behave somehow. So the gaps get filled with assumptions.
Now imagine the first version is built around one-time purchases, and Sarah later decides customers should be able to subscribe to products they use regularly.
That isn't just another button. Orders now need frequency and future dates. Payments need to recur. Customers may need to skip or cancel shipments. Inventory and fulfillment need to account for future orders.
The original decision can be sitting underneath many parts of the application.
The code may have been cheap to write. Changing the assumption underneath it is what becomes expensive.
Not Everything Should Be Decided Up Front
This doesn't mean Sarah should spend months specifying everything before she builds.
There is an important difference between something you cannot know yet and something you haven't decided yet.
Sarah may discover after launch that customers prefer monthly bundles. That's learning.
But she can decide where she ships, what happens when an item is out of stock and whether customers can cancel an order. That's not discovery. That's deciding how the business works.
Good requirements aren't about predicting the future. They are about removing avoidable ambiguity before it becomes software.
For most applications, I find four areas useful:
- Users: Who uses the application, and what can each person do?
- Data: What does the application need to remember, and how do those things relate?
- Journeys: What needs to work from beginning to end?
- Rules: What business decisions govern those journeys?
These don't need to become a 50-page requirements document. They need to be clear enough that the system building the application isn't making important business decisions for you.
Structured Autonomy
This becomes more important as software development becomes autonomous.
When you work with a developer, unclear requirements often get caught through conversations during the build. Someone asks, “What should happen here?” That creates a natural safety net.
With autonomous development, much of that back and forth goes away. That's part of the value. But removing the conversation doesn't remove the decisions.
I think the better model is structured autonomy.
You spend time defining what needs to be built and resolving the important questions. You review the plan. Then the system takes on more of the design, engineering, testing and deployment.
Better requirements don't mean less autonomy. They make more autonomy possible.
This is why, in Morph, we work through requirements in a conversation before the autonomous build begins. You can refine what you need and review Morph's understanding before committing to the build.
But whatever tool you use, I would spend more time on this step than might initially feel necessary.
Before something is built, changing a decision is cheap. After the same decision is embedded in the data model, screens and workflows, changing it can mean reworking all of them.
As building gets faster, that difference matters more.
The cost of writing code is falling. The value of knowing what should be built isn't.