Writing specifications is the new bottleneck of implementing software

One of the primary drivers behind the shift from Waterfall to Agile was the sheer inefficiency of trying to freeze requirements. Requirements are in a constant state of flux; they evolve and are discovered anew. During the implementation phase, unforeseen challenges inevitably emerge, forcing us to incorporate elements into the specifications that were never previously considered.

This phenomenon intensifies with the scale of the software. It’s the same logic as a long vector: even a minuscule shift in angle results in a massive displacement at the tip. The further away your target, the more precise your aim must be. In this analogy, aiming angle represents the specification, the flight path is the implementation, and the destination is the final software product.

We are seeing this exact problem repeat in the realm of AI agent coding. The core of the recently hyped “Ralph Loop” is the idea that if a user simply provides a solid plan and test cases, an agent can toil away overnight and present a perfectly implemented piece of software. It feels remarkably similar to the Waterfall model, where specs are locked in, coders grind away, and software magically appear. But is this truly scalable?

I don’t believe it is. Just as we moved from Waterfall to Agile, humans must remain in the loop to continuously verify that the agent is heading in the right direction. If the specification is a clear optimization goal that can be infinitely refined, this approach might work. However, for goals that are difficult to specify—such as “creating a website with great UI/UX”—a human must intervene to monitor the agent’s direction and refine the specs as the project evolves.

To put it simply: the biggest bottleneck in software development is that humans don’t actually know what they want. We discover our true needs only by building and interacting with the product, realization by realization. This is why it is impossible for an agent to implement software end-to-end with total independence. The goal is, after all, to build something that a human wants.

Our future task is not to replace humans 100%, but to assume a Human-in-the-loop workflow and focus on reducing the cognitive load involved. A prime example is automated software verification. This technique mathematically proves that software satisfies its specification. In this model, the agent’s output becomes a tuple of $(\text{code, specification, proof})$. When this happens, humans no longer need to manually check if the code is correct or if it harbors potential vulnerabilities like Buffer Overflows or Use-After-Free errors.

We are entering a world where implementation and formal proof are essentially “free.” It is time we shift our focus to the art of writing specifications and the science of code review.