May the Best Product Win
Coding agents make it cheaper to compare working alternatives. Build each one far enough to answer a question before committing to a product direction.
A team has two plausible answers to the same product problem. It can guide users through a fixed sequence or give them a workspace where they choose what to do next. Both look reasonable in a design review. One gets implemented, and the other stays a sketch.
That first choice acquires weight quickly. It gets a repository, a model, an interface, tests, and a roadmap. Each iteration adds evidence about how to improve the chosen path, but it also makes a fundamentally different path more expensive to consider. The first implementation can win simply because it was first.
Coding agents lower the cost of keeping both ideas alive. A team can build enough of each to watch people attempt the same task, then commit with a better understanding of the tradeoff. The product direction should earn that investment through what it helps people accomplish, rather than inherit it from the order in which the code was written.
Enough To See The Difference
The original iPhone’s development offers a useful example of how much a prototype needs to establish. Tony Fadell, who led the iPod organization and later the iPhone division, described it as “a competing set of ideas, not teams”. He recalled 16 or 17 concepts, with exploration spanning click wheels, touch interfaces, and hardware keyboards.
The alternatives became concrete enough to expose their consequences. Dialing a number with the iPod click wheel was cumbersome. Once enough of the touch interface and software worked on real hardware, Fadell said the team had the “winner design.”
He was careful not to call it the winner product. Turning that design into something Apple could ship remained, in his words, a “brutal slog.” The comparison established which direction deserved the remaining investment. It did not require finishing every alternative, and it did not eliminate the work of finishing the winner.
More Alternatives Within Reach
Teams have long used sketches, spikes, and competing prototypes to explore alternatives. The constraint is how far they can afford to take each one. A mockup can expose a confusing layout, but testing recovery from a failed operation or the consequences of a data model may require substantial working software.
That work competes with delivery. Even when the same team builds both alternatives, it spends time on implementation it expects to discard. The more infrastructure each comparison requires, the stronger the pressure to choose a direction before testing it.
Agents can create that repeated infrastructure, translate shared requirements into different designs, generate fixtures, and revise separate branches concurrently. The economic change is that a comparison previously too expensive for a team’s schedule may now fit inside it. Compute and review still cost something, but fewer implementation hours need to be committed before the alternatives become useful.
Give The Alternatives The Same Task
Consider a tool for scheduling a field visit. One prototype asks for the customer, location, time, and assigned person in a guided sequence. Another puts those choices in a single editable workspace. The unresolved question is whether guidance prevents mistakes or gets in the way when plans change.
Give both versions the same task: arrange a visit, discover that the assigned person is unavailable, and change the booking without losing the rest of the work. Now the comparison has something to reveal. Watch where users hesitate, whether they notice the conflict, and what they have to redo.
Decide what would count as better before running the comparison. If the intended customers handle frequent schedule changes, successful reassignment may matter more than the speed of the initial booking. If occasional users are the audience, guidance may deserve more weight. “Best” has to refer to a customer’s work and the product’s priorities, not an abstract contest between interfaces.
- Understand the problem
- Identify plausible solutions
- Build enough to compare
- Test the same tasks
- Choose or reconsider
- Finish it
Customer research establishes whose work matters and which situations are representative. Include the current way of doing the task in the comparison, even if it is a spreadsheet or a manual process. A prototype can beat the other prototype without improving on what people already have. Neither alternative has to win.
“Build three versions” is not a useful instruction by itself. Each alternative needs a reason to exist. In the scheduling example, both prototypes need enough state and validation to exercise the reassignment. Neither needs a finished billing system to answer the workflow question.
The same principle applies beneath the interface. Competing data models can be exercised against the same expected changes. Service boundaries can be tested against the same cancellation and failure scenarios. Each branch should become decision-complete: sufficient to support the comparison, with its shortcuts understood.
Keep the alternatives at comparable fidelity. Giving one version polished transitions and realistic data while leaving another full of placeholders makes preference hard to interpret. The intended difference should be what people encounter.
Set a time budget and a stopping rule as well. If both versions let people recover equally well, the simpler one may be enough. If neither works, revisit the approach. If the result is inconclusive, name the missing evidence before extending the experiment; another round of generation is only useful if it can help resolve the choice.
Keep The Choice Reversible
This fits within iterative development. A team can use a spike or a short discovery cycle to compare alternatives, then continue learning from the selected version. Cheaper implementation expands the experiments that can fit inside that cycle.
The practical risk is accumulated commitment. Once an approach has integrations, customer expectations, tests, and a roadmap built around it, changing direction carries costs beyond rewriting code. A useful comparison happens before those commitments become the argument for keeping the design.
The choice can reopen when a consequential uncertainty appears. A new workload might justify comparing storage designs. A new kind of customer might expose the limits of a workflow. Keep the experiment focused on that question rather than treating every change as a reason to generate another application.
The Bottleneck Moves To Evaluation
Producing four implementations does not create the capacity to understand four implementations. Someone still has to inspect their assumptions, involve users, run the scenarios, interpret the tradeoffs, and take responsibility for the selection. Shallow evaluation turns cheaper generation into more persuasive noise.
The alternatives may not even be meaningfully different. Agents using the same prompt, context, libraries, and examples can reproduce the same hidden assumption. Useful divergence requires explicit hypotheses, not a request to “try something different.” One branch might preserve the existing architecture while another can replace it; one might prioritize operational simplicity while another explores interface flexibility.
Selection also does not require combining every appealing feature from every branch. That produces a new design the comparison has not tested. Pick a direction, preserve what the other branches taught, and validate any combination on its own merits. The code may be disposable, but the evidence should not be.
Choose What Deserves The Remaining Work
Parallel prototyping is one way to spend cheaper implementation on product evidence rather than software output, the distinction behind Cheap Software Still Needs Product Judgment. It is useful when several approaches remain plausible and working software can reveal something that discussion has left unresolved.
The selected branch still has to survive integration, testing, real use, failure, and maintenance. Some evidence, such as the burden of operating a system for months, cannot arrive inside a short comparison. The experiment should resolve the uncertainty it can actually expose.
An implementation that loses can still justify the time spent on it. It may show why a tempting workflow breaks, which assumption was wrong, or what the chosen design must preserve. Build far enough to learn that, then commit the remaining effort where the evidence points.