The build got cheap. Being wrong didn't.

The prototypes arrive before the questions now

The person I work with most closely can take an idea from a sentence to a working prototype in days. Not a mockup - something you can click, with plausible data behind it. These are weekend explorations, built to think with; none of them is a product and none of them needs to be. Most die quickly, several of them at my hands.

That last part is my job. For years I've been the person who kills ideas before they get built, by asking the question founders don't want to hear: who actually pays for this, and why now? What's changed is the sequencing. The kill conversation used to happen over a document. Now it happens over a working demo - the build gets there before the question does.

And the conversation got harder, not easier. Which is the opposite of what the new playbook promised.

Why the old playbook asked first

The old validation playbook asked the hard questions before code for one reason: building was expensive. A wrong idea cost months of engineering, so you spent days interrogating it first. That wasn't philosophy. It was economics.

A founder once asked me to look at his product before committing to the big build. Working prototype, genuine enthusiasm from everyone who saw the demo. I asked who would actually pay, and what made this the moment they would. Not who liked it - who signs. We went through the answers honestly, and they weren't there. The idea never found traction, and some time later he told me I'd been right.

That prototype took months. Today it would take a weekend. The questions it failed haven't changed at all.

What actually got cheap

Be precise about what collapsed, because something real did.

"Can we build it" is now nearly free to answer. For most B2B software ideas, the honest answer is yes, in days, to demo quality. "Will people click it" got cheap too - put the prototype in front of users and watch.

Something else happened alongside, and it gets less attention: demos got better faster than products did. A vibe-coded prototype now looks like a product. Polished interface, sensible flows, convincing data.

So polish reads as progress to stakeholders, and as traction to boards.

The signal everyone instinctively trusts got less trustworthy at exactly the moment the discourse decided that building was the validation. A working demo answers the questions that were already cheap. It says nothing about the one that was always expensive.

What didn't get cheap

"Just build it and let the market answer" is a playbook borrowed from consumer software, where the market actually does answer - in weeks, through launch metrics, at the cost of some ad spend.

In B2B, and especially in industrial and regulated B2B, the market's answer arrives through a sales cycle. A champion who stakes internal credibility on you. A budget line that has to exist. Procurement. A security review. An integration commitment from people with no time for experiments. Six to eighteen months, end to end. You cannot A/B test your way to a signature.

So the cost of being wrong didn't shrink when the build got cheap. It moved - out of engineering, where it was visible and budgeted, into places where it's neither: sales capacity spent on a thing nobody signs for, credibility spent with customers who gave you a meeting, and the calendar, which is the one cost no tooling discounts.

A prototype, meanwhile, manufactures momentum faster than it manufactures evidence. Once a thing exists and demos well, it recruits defenders. Sunk-cost attachment used to take months of build to form. Now it forms in a weekend.

From gatekeeping to triage

The kill questions used to be a gate. One expensive bet, interrogated before the money moved. That was the old job.

The new situation is different in kind. The volume of buildable ideas has exploded - every team, every founder, every co-founder with a free weekend can now produce working software. The volume of ideas someone will actually sign for has not moved. The gap between those two numbers is the defining product problem of the next few years, and it lands on whoever does the killing.

So the questions changed role: from gatekeeping to triage. Most ideas I kill now already exist as prototypes. The kill is no less necessary for arriving late - just more expensive, because the demo has already done its work. Attachment has formed, momentum has gathered, and the person across the table isn't defending an idea anymore. They're defending a thing.

Killing a document costs a conversation. Killing a prototype costs a fight.

The questions, unchanged

Who signs, and what makes this the moment they do? What happens to your sales capacity, your credibility, and your year if the answer is nobody?

These questions were valuable when building was expensive, because they protected the build. They're more valuable now that building is cheap, because they're the only filter left - the scarce input in a pipeline where everything else got abundant. Skipping them was never free. It used to cost you the build. Now it costs you everything that comes after the build, which was always the larger number.

The market will still answer the question if you don't. It just charges more than I do.