Instant Prototype Agent: From Customer Request to Clickable Prototype in Minutes

The short version

The Instant Prototype Agent listens for customer feature requests across Slack, Zendesk, Gong, and Salesforce. For every validated request, it generates a working prototype in minutes, deploys it to a preview URL, opens a GitHub branch, files a Linear ticket, and drafts a Notion doc with the customer context. The PM goes from "interesting signal" to "clickable artifact the customer can react to" in one cycle, usually the same day.

The request that used to take a quarter

Tuesday, 4pm. Acme Corp's CSM pings #product: "Can we bulk-reassign translation tasks when a linguist is out sick?"

The old PM loop: triage the request, add it to the board, rank it against 40 others, write a PRD, get eng sign-off, file tickets, build it, ship it, launch it. Eight weeks if you're fast, twelve if you're not. By the time Acme sees the feature, their ops team has moved on, hacked around the problem with a spreadsheet, and the CSM has forgotten they asked.

The new loop: the agent reads the Slack DM at 4:01pm. By 4:08pm there's a clickable prototype running on a Vercel preview URL. The CSM sends it to Acme's ops manager before she goes home. She clicks around, tells the CSM what's missing, what's extra. By 9am Wednesday the PM has concrete feedback and a scoped backlog item, not a vague "they asked for bulk reassign."

The agent doesn't skip engineering. It front-loads the learning. Engineering still reviews and ships the real thing. They just start from a prototype the customer has already validated, not a spec the PM argued into shape in a vacuum.

What the agent does

Five moves, in order.

1. Ingest the signal. Webhook fires when a customer request lands in any tracked channel: Slack DM to @product, Zendesk ticket tagged "feature-request", Gong moment flagged by Support Signal Processing, or a Salesforce opportunity note. The agent ingests the full context: who asked, account tier, history of similar requests.

2. Cross-reference. Semantic search over the last 90 days of tickets, calls, and Slack threads. If this request has come up before (it usually has, four times in 90 days is typical), the agent bundles the previous context too. If it's a first-ever request, flag it for PM review before generating.

3. Generate the prototype. Claude Code with your design system, your source code repository, and your production analytics events loaded into context. The agent drafts the feature: new component, wiring, basic state management, a realistic data fixture. Three to five minutes for typical requests.

4. Deploy and scaffold. The generated code gets committed to a feature/<slug> branch. A Vercel preview deploys automatically. A GitHub PR opens in draft status with description, reviewers, and a running checks widget. A Linear ticket files with the customer context as the description and the AC list. A Notion doc drafts with the request history, the JTBD, and links to all of the above.

5. Notify. Slack post to #product or the CSM's channel with the preview URL front and center. The CSM can forward it to the customer in one click. The PM can open the PR to review the approach, the Linear ticket to adjust priority, or the Notion doc to sharpen the ACs.

All five steps in about 7 to 10 minutes.

What the customer sees

A clickable preview URL. They click it, they use it as if it were real, they tell you what's missing. The feedback loop is compressed from weeks to the same afternoon.

The thing that changes is what you're arguing about. In the old loop, the PM and the customer argued about a spec. Each side read the words differently, each side walked away with a different mental model, the first time the customer saw the real thing was after 12 weeks of engineering work. In the new loop, the PM and the customer argue about a prototype. The spec is discovered by reacting to the working thing, not by negotiating text.

What's still human

The PM decides which requests are worth prototyping at all. The agent flags first-time requests for approval before generating. The PM reviews the generated PR and decides whether to merge, iterate, or scrap. The customer decides whether the prototype is close enough to their real problem. Engineering decides how to turn the prototype into production code. Everyone who was already doing PM, CS, and engineering work is still doing it. They're doing it on a 7-minute cycle instead of an 8-week one.

Pick one thing this week

1. Pick one product surface where customer feature requests land regularly. Most teams have three: support, sales, and the account team's Slack channel.
2. Wire a webhook from that surface to a Claude Code project with your design system and source code in its context.
3. When the next request lands, manually trigger the prototype generation. Time it. The first run will be slow because you're still figuring out the prompt. The fifth will be under 10 minutes.
4. Send the preview URL back to the customer the same day. Notice how different the conversation is when they're reacting to a working thing instead of a description.

The compounding effect: once customers know you respond with prototypes, they start describing their problems differently. More specific, more concrete, more willing to engage. The agent doesn't just speed up the loop. It changes what gets said in it.

Build yours.

See it running in the Agent Sandbox. Click into the Instant Prototype agent on the Build stage, run the simulation, then click the "Open Bulk Reassign prototype" pill in the output. The preview is live and interactive.