Many founders I talk to have the same problem. They have an idea they believe in, a rough sense of who it is for, and a deadline that is closer than it should be. What they do not have is a clear path from that idea to something real people can use.
After 30+ years in technical UX, front-end engineering and product strategy, and 50+ shipped platforms, I have settled on one process that gets a v1 out the door in weeks rather than quarters. AI makes it faster. It does not make it different. The steps are the same ones that worked before AI; each one just takes a fraction of the time it used to.
The seven steps
- Discover. Calls and walk-throughs of how it works today.
- Compile. Everything in one requirements brief.
- Specify. Deep research turns the brief into a detailed spec.
- Build. Design and development with the latest AI models.
- Test. Real users try every preview.
- Iterate. Refine from what testing showed.
- Ship. Release, measure, then test and iterate again.
The last step loops back to the fifth. Launch is the start of a cycle, not the end of a project.
Discover
I start with the people who do the work, not only the people who sign off. On recorded calls they walk me through the current process screen by screen: the spreadsheets, the email threads, the workarounds, and the moments where it breaks.
An hour of watching someone fight a spreadsheet tells me more than a week of reading a pitch deck.
Compile
Transcripts, the process map, sample files, constraints, regulations and the one metric that matters go into a single brief. Nothing important is left in someone's head or inbox.
The brief is written in plain language. If the founder cannot read it and say "yes, that is the problem," it is not done.
Specify
The brief goes into Perplexity's deep research, which comes back with a detailed specification: users and roles, core flows, data model, integrations, edge cases, security and acceptance criteria, with sources behind every assumption about the market or the rules.
We review it together and lock version one before any design starts. Locking matters. Without it, scope drifts every time someone has a new idea, and "weeks" quietly becomes "months."
Build
Design and code happen together, in the stack that goes to production. I work with the latest models from Anthropic, OpenAI and Google inside Cursor and Claude Code, picking the model for each task.
You get a working preview link every few days instead of static mockups. A clickable, deployed preview answers questions that a picture never will: does it feel fast, does the flow make sense, does the data look right.
Test
Before anything ships, the people who will use it try the preview on real tasks. I run moderated sessions where they think aloud, add quick unmoderated tests for wider coverage, and watch where they hesitate. Task success, time on task and the moments people get stuck become a ranked list for the next round.
Iterate
Findings from testing and your feedback on each preview become the next round of changes, worst problems first. The spec is updated as decisions change, so it stays the source of truth.
Ship
Nothing reaches production until it passes automated tests, a security review and your sign-off on the preview. Then it deploys, we watch the metric we agreed on, and what real users do starts the next round of testing and iteration.
Why it is fast
The speed does not come from cutting steps. It comes from three things.
- The spec is done before the code. AI coding tools are only as good as what you tell them. A locked, sourced spec means far less rework.
- Previews replace mockups. Every few days there is something real to react to, so decisions happen in hours, not weeks.
- Testing never waits for "done." Problems surface while they are still cheap to fix.
Two ways to get it live
Not every founder needs the same thing from me, so the same seven steps run two ways.
I build it. I design, build and ship it myself, as a live working app on your accounts. This is best when you need a v1 fast and do not have a team yet. You own the code, the docs and the accounts from day one.
With your team. I lead the product and AI work alongside your designers and developers, and stay until it is implemented and live. Your product, design and engineering leads join the discovery calls, your tech lead reviews the spec against your architecture, and I set up the AI workflow in your repo and review every pull request. This is best when you have a team and need senior direction.
What this looks like in practice
My own products go through the same steps. Mentor Intelligence moved from a static prototype to production in seven shippable steps, each one usable on its own. BlastRocket went from specification to version 1.16 between September and October 2026. In both cases the order mattered more than the tools: discover, write it down, lock the spec, then build and test in short loops.
AI does the heavy lifting. People make the calls.
That line sums up the whole approach. The models write a lot of the code, research the spec and draft the tests. A person still decides what gets built, what ships and when it is good enough.
If you are a founder with an idea and a deadline, email me with where it is today. I will tell you honestly whether a v1 in weeks is realistic, and what it would take.