Skip to content
Article

Prototype is the New Discovery

For most of the history of software, we built last. We discovered, we designed, we wrote requirements, and only then, after weeks of documents describing a thing nobody had touched, did we finally build. That order wasn’t a philosophy. It was a workaround. Building was the most expensive thing you could do, so you did it last, and you did everything possible to be sure before you started. It felt responsible. We were gathering the voice of the customer and designing the best experience we could imagine.

AI just removed the expense, and most of the risk with it. When the most expensive step becomes one of the cheapest, the old order stops making sense.

This is the real shift under all the noise about AI and code. It isn’t that engineers type less. It’s that a working prototype using AI now takes days instead of months, and you build it by iterating in plain language, the same medium you think in. The step we saved for last is now the fastest way to understand the problem at all.

Amazon noticed from the inside. For twenty years its gospel has been “Working Backwards”: write the press release and the FAQ before you build anything, so you are forced to think about the customer before a line of code exists. Werner Vogels made it famous for good reason. Then late last year, one of their own engineers, Clare Liguori, published “Prototypes Before PRFAQs”. Her argument: in ambiguous spaces, the fastest path to clarity is no longer a document, it’s a quick prototype. Her team couldn’t have written a PR-FAQ for the products they were chasing; they didn’t yet know what they were building. So they built first, used the rough thing daily, and let it tell them what the document should say.

When the people who invented “write it down before you build it” start saying “build it first,” that isn’t a trend. It’s the ground moving.

Discovery, Design, Develop Was a Response to a Constraint that’s Gone

At ABT we’ve run engagements like most good shops: Discovery, then Design, then Develop. Research the problem, design the experience, build the solution. Nothing is wrong with that sequence; it produced real work. But it’s worth being honest about why it exists. It manages risk in a world where building was slow and expensive. You front-load the thinking because building is the part you can’t afford to get wrong.

Take that cost away and the gates start to look less like rigor and more like delay. You can spend the first weeks of an engagement describing a product no one in the room has seen, or you can spend two days putting a working version in front of them. Requirements written about an idea age badly. A prototype doesn’t: it either works or it doesn’t, and everyone can tell.

Prototype-first is not “skip the thinking.” Research still matters. User experience is still the north star, more than ever, because when anyone can generate a working screen in an afternoon, the scarce thing becomes judgment about what’s worth building. The prototype doesn’t replace discovery. It is discovery, in the most honest medium available. Same hard questions. You just answer them with something you can click instead of something you have to imagine.

The Conversation Changes, Not Just the Process

The part I care about most isn’t internal. It’s what happens in the room with a client.

The old conversation was a negotiation over a document: tell us your requirements, we’ll scope it, we’ll come back with a plan. The new one is shorter and stranger. Let’s build a rough version right now, together, and see how it feels. Because we iterate in plain language, the client isn’t on the far side of a requirements doc anymore; they’re in the build with us, reacting, redirecting, catching the thing they could never name in a kickoff but recognize the instant they see it.

I watched it happen. Once the prototype was on the screen and the client could see their own idea reflected back, the conversation went from “can you build this?” to “when can we have it?”

That shared artifact does what a statement of work can’t. It turns a pitch into a working session. It surfaces disagreement early, while it’s cheap. And it hands the client the rarest thing in our business: something to react to instead of a promise to evaluate.

We’ve started winning work this way, and I don’t think it’s luck. People don’t buy certainty about a document. They buy confidence that you can build the thing, and nothing shows that like building it in front of them.

Where This Goes Next

If the prototype is the new entry point, the most valuable thing we can build is the surface where those first rough ideas get captured and turned into something clickable: fast, cheap, before anyone has committed to a scope. That’s what I’m working on next, and I’ll write about it when it’s real.

For now the claim is simple, and I’ll make it at full confidence: the cheapest way to understand a problem is to build a rough version of the answer. Teams that internalize that won’t just ship faster. They’ll think faster, because they finally stopped saving the most useful tool for last.

The Atlantic BT Manifesto

The Ultimate Guide To Planning A Complex Web Project