Reasoning Models Changed How We Prototype

Something shifted in our product design practice over the past few months, and it took me a while to name it. The new class of reasoning models, the ones that visibly think before answering, did not just make our AI tooling smarter. They changed which stage of the design process the tools are useful in. Autocomplete-era models helped at the end, polishing and producing. Reasoning models help at the beginning, which is a much bigger deal.

From "make me a screen" to "poke holes in this flow"

The old workflow: design the thing, then ask a model to generate variations, copy, or code. Useful, narrow. The new workflow starts earlier. Before I have designed anything, I describe the problem space to a reasoning model and ask it to work through the logic: What are the states this flow can be in? Where will users arrive with wrong assumptions? What edge cases does this onboarding create for the account system?

The model actually walks the paths. It catches the empty state I forgot, the permission case that breaks the happy path, the way step three silently assumes the user completed a setup they may have skipped. It reasons about flows the way a thorough, slightly pedantic design partner would, and it never gets tired of the exercise.

On a recent workflow redesign for Aperture, we ran every proposed flow through this interrogation before a single high-fidelity screen existed. The model found two dead-end states in a batch-processing flow that, historically, we would have discovered in usability testing three weeks later. Finding them at the whiteboard stage cost us an afternoon. Finding them in testing would have cost us a sprint.

Prototypes are now conversations that compile

The second shift: working prototypes have become almost disposable. Describe a flow with enough precision and a reasoning model will produce a functioning prototype, real state, real logic, not a click-through of static frames. This changes what we put in front of users. Testing a prototype with actual conditional logic gets you dramatically more honest signal than a linked mockup where every path is secretly the happy path.

It also changes the design-engineering handoff, mostly by shrinking what needs handing off. The prototype is a living spec. Engineers throw away the code, usually, but they keep the behavior, and arguments about "what should happen when" now get settled by clicking rather than by meeting.

Some ground rules we have landed on:

• Interrogate before you generate. The model as critic comes before the model as builder. Reversed, you just get faster versions of your blind spots.
• Prototype code is compost. It exists to learn from and gets rebuilt properly. The moment prototype code sneaks toward production, quality debt compounds.
• The model reasons; users decide. Simulated critique is a filter, not a substitute for research. It catches logic errors brilliantly and misreads human motivation constantly.

What this does not change

Let me be clear about the ceiling, because the discourse needs it. Reasoning models are superb at coherence: does this flow hold together, are these states complete, is this logic sound. They are mediocre at desirability: should this exist, will anyone care, does this feel right. They will happily help you build a rigorous, complete, internally consistent product that nobody wants.

Taste, problem selection, and the felt sense of an interaction remain stubbornly human, and I would argue they are now more valuable, because everything downstream of them got cheap. The models handle the plumbing of thought. Choosing what is worth thinking about is still the job.

The net effect: our first week on a product engagement now produces what used to take three. Not because we design faster, but because we get to the real questions faster. That is the trade I always wanted from these tools.