The prototype is not the milestone anymore. When an agent can build a clickable version of your idea in a few days - and with Claude Code and Cursor it can - the build stops being the hard part. So the workflow has to change. Here is the loop I actually run now, building MERIDIAN solo.
Generate breadth before you commit
The old move was to pick one idea and write a PRD. The new move is to generate many and pressure-test them cheaply, because generating is almost free now. When I was searching for the flagship, I ran around 350 ideas through nine passes with agents in a month - parsers for brokerage statements, doc-gen, relocation copilots, fifteen named candidates. Most died fast. That is the point. You are not looking for the idea you like. You are looking for the one that survives contact.
Build to learn, not to ship
A prototype used to cost weeks, so you only built what you were already committed to. Now I build the thing in days specifically to find out what is wrong with it. MERIDIAN is 27 screens and clickable not because it is ready - it is not launched - but because a real artifact surfaces the real problem faster than any document. The prototype is a research instrument. Treat it like one and you stop getting attached to it.
Interrogate the spec, because AI will build the wrong thing perfectly
This is the part that catches people. An agent does not push back. Give it a vague spec and it will build exactly that, polished, and you will not notice the assumption was wrong until you are staring at a finished screen. So the work moves upstream: before anything gets built, every requirement gets questioned, and every “we want this to be true” gets a test attached instead of a green light. I wrote about the grid I use for that in the previous piece.
Your job is orchestration and taste now
Add it up and the role has changed. You spend less time producing - writing the spec, drawing the flow, even writing the code - and more time directing the things that produce, then judging what comes back. The bottleneck is no longer how fast you can make one artifact. It is whether you can tell a good output from a plausible one, and whether you are pointing the machine at the right problem.
That is the whole shift. Cheap to build, expensive to be wrong. The workflow is just what you do about it.
How do you run product discovery when AI writes the code?
When an agent can build a clickable prototype in days, the prototype becomes a research instrument, not the milestone. The loop: generate breadth and pressure-test ideas cheaply, build to learn rather than to ship, interrogate every spec before it is built (an agent builds the wrong thing perfectly), then spend your time orchestrating and judging what comes back. Cheap to build, expensive to be wrong.
Does AI replace the product manager?
No - it moves the job upstream. The bottleneck stops being how fast you produce an artifact and becomes whether you can tell a good output from a plausible one, and whether you are pointing the machine at the right problem. Taste and judgment become the work.
What does an AI-native product manager do differently?
They ship with agents like Claude Code and Cursor as the method, not a buzzword - using a real prototype to surface the real problem fast, attaching a test to every assumption, and treating discovery as orchestration. The edge is a real engineering background plus the judgment to direct the tools.