The old workflow was painful. I'd spec something in a doc, maybe mock it in Figma, hand it to a developer, wait a week, see something that wasn't quite right, iterate, wait again. Expensive. Slow. Frustrating for everyone.
The problem wasn't the developers — they're brilliant. The problem was the gap between what I could describe and what they could build. I was working in abstractions. They were working in code. Every iteration cost real money and real time.
AI changed that equation completely.
Now I can explore in code. Not production code — I'm not pretending to be an engineer — but real, working interfaces that I can click, feel, and validate experientially. The feedback loop went from weeks to minutes.
"I can get to experiential sign-off before a single line of production code is written."
Engine One: Explore
The first engine is pure exploration. I describe what I want, AI generates it, I react. Not "is this correct?" but "how does this feel?" Does the interaction make sense? Is the flow intuitive? What happens on mobile?
This is where AI shines. It can generate ten variations in the time it used to take to spec one. I'm not evaluating mockups anymore — I'm using the thing.
The code from this phase is throwaway. That's the point. I'm not trying to ship it. I'm trying to learn what we should ship.
- → Generate variants fast
- → Feel the interaction
- → Code is throwaway
- → Product owns this
- → Apply constraints
- → Build for maintainability
- → Code is production
- → Engineering owns this
Engine Two: Produce
Once I know what we're building — really know, because I've used it — the handoff to engineering is different. I'm not handing over a spec. I'm handing over a validated direction with working code that demonstrates the intent.
The second engine rebuilds it properly. This is where the hard stops come in — the constraints that force quality. Line limits. Prop limits. No loading states inside components. The rules that turn exploration code into production code.
Developers aren't rebuilding my guesses anymore. They're implementing validated decisions. That's a completely different conversation.
Why This Works
The magic isn't AI generating code. It's the separation of concerns.
Engine One is about answering "what should we build?" — that's a product question. Engine Two is about answering "how should we build it?" — that's an engineering question. Mixing them up is where projects go wrong.
AI lets product explore without expensive engineering cycles. Constraints let engineering build without inheriting product's exploration debt. Everyone works in their zone, but the gap between zones is smaller than ever — and each cycle makes the next one faster.
The Handoff
What does engineering actually receive? Not a Figma file. Not a PRD. A working prototype with clear notes on what matters and what's throwaway.
"This interaction is validated — users loved it. This layout is a guess — feel free to improve. This animation is critical to the feel — please preserve the timing."
The conversation changes from "can you build this?" to "here's what we learned, here's what matters, make it production-ready."