All articles

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.

Abhishek Kalra3 min read

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.

Keep reading

Process5 min readWhy We Build in Sprints: The Philosophy Behind Morph’s Incremental ApproachWhy Morph builds AI applications in sprints, focusing on incremental validation, system reliability, and production-ready outcomes rather than unverified speed.Nora PetersonRequirements7 min readHow to Define Requirements That Actually Get BuiltA practical guide for defining software requirements that surface critical decisions early and reduce ambiguity before building begins.Nora PetersonEngineering6 min readWhat Changes When AI Acts as Your Senior Engineering Team (Not Just a Code Generator)Most AI development tools generate code. Learn what changes when AI takes on senior engineering responsibilities like architecture, sequencing, and validation, and why that matters for production ready software.Nora PetersonEngineering5 min readWhat Morph Builds: Full-Stack, Production-Ready Applications (Not Prototypes)Many AI app builders produce prototypes, not usable software. Learn what production-ready really means and how Morph delivers full-stack applications.Nora PetersonRequirements5 min readWhy Most Software Projects Fail Before Any Code Is WrittenMany software projects fail before development begins due to unclear requirements. Learn how vague specifications lead to rework, delays, and why requirements clarity determines successful outcomes.Nora Peterson