Continuous Discovery

What hasn't changed

Before I blow this up, let me be clear about what still matters.

Talking to customers matters. Understanding their world matters. Empathy matters. The discipline of asking "why" five times until you get to the real problem, that matters. Teresa Torres was right about the habit of continuous discovery. Nothing I'm about to say replaces the human act of sitting across from a customer and listening.

But everything around that conversation has changed.

The way you find signals has changed. The way you process what you hear has changed. The way you validate whether it matters has changed. The speed at which you can go from "I think this is a problem" to "here, try this" has changed. And most importantly, the ratio of signal to noise has flipped. You used to have to hunt for insights. Now you have to filter them.

If you're still doing discovery the way you did it two years ago, you're leaving speed on the table. And speed to insight is the only competitive advantage a PM has left.

The old model is too slow

Here's how discovery worked before AI. You'd schedule two customer interviews a week. Good PMs did this consistently. Great PMs synthesized the patterns monthly. You'd do this for a quarter, build an Opportunity Solution Tree, design some experiments, run them over weeks, and eventually decide what to build.

That cycle took four to eight weeks from signal to decision. Sometimes longer.

The problem isn't that it was wrong. It was right. The problem is the world moves faster now. Your competitor is shipping prototypes while you're still synthesizing interview notes. Customers are switching to whoever solves their problem first, not best.

And here's the uncomfortable part: while you were doing two interviews a week, your company was generating thousands of customer signals every single day. Support tickets. Sales call recordings. Customer emails. NPS responses. App reviews. Slack threads. Product analytics. Every one of those is a customer telling you something. And 99% of it sat in different systems, unread by anyone on the product team.

Two interviews a week was the best we could do with human bandwidth. It's not the best we can do anymore.

The new discovery loop

Here's the model I'm running now. It looks nothing like what I was doing 18 months ago.

Step 1: Ingest everything. Every customer touchpoint your company generates flows into an AI processing layer. Every sales call gets auto-transcribed and analyzed. Every support ticket gets categorized and pattern-matched. Every customer email gets scanned for pain signals. Every NPS response, app review, and Slack mention gets processed. You're not reading any of this manually. Agents do it.

Step 2: Extract the signal. AI doesn't just transcribe. It extracts. From a 45-minute sales call, it pulls: what problems the customer described, what they're currently using, what they asked about, what made them hesitate, what competitor they mentioned, what timeline they need. From 200 support tickets this week, it surfaces: the top 5 emerging pain points, which customer segments are affected, how severity compares to last week, and whether anything new is trending.

Step 3: Surface opportunities. Every Monday morning, before I've opened Slack, I have a synthesized view of what customers are struggling with. Not from two interviews. From every customer interaction the company had last week. Thousands of data points, compressed into the 5 to 10 things that actually matter. Patterns I'd never catch manually because they span sales calls, support tickets, and usage data simultaneously.

Step 4: Prototype immediately. This is the radical part. When you spot an opportunity, you don't write a spec. You don't schedule a design review. You don't estimate engineering effort. You build a working prototype. Today. In hours, not weeks. AI coding tools make this possible. Describe the solution, get something clickable, and put it in front of a customer by Wednesday.

Step 5: Give it to the customer. Not a mockup. Not a wireframe. Not a concept drawing. A working prototype they can actually use. "Here, try this. Does this solve your problem?" Their reaction to a real thing is worth more than ten interviews about a hypothetical thing.

Step 6: Get feedback, iterate, scale. The customer's reaction tells you everything. They use it and their eyes light up? Scale it. They use it and shrug? Iterate. They don't use it at all? Kill it. You've spent hours, not months. The cost of being wrong dropped to near zero.

That's the loop. Signal, prototype, customer, feedback, scale. It runs in days, not months.

Auto-transcribing everything your company generates

Let me get specific about Step 1, because this is where most PMs stop before they start. "I can't process all that data" is the excuse. You can. Here's how.

Sales calls. Tools like Gong, Chorus, and Fireflies already transcribe every call. But transcription isn't the point. The point is extraction. Set up an agent that reads every sales call transcript and pulls out: customer problems mentioned, features requested, competitors compared, objections raised, and commitments made. You don't read the transcripts. You read the extraction. Five minutes instead of forty-five.

Support tickets. Connect your Zendesk, Intercom, or Freshdesk to an AI agent that runs weekly. It reads every ticket, categorizes by problem type and customer segment, identifies trending issues, and flags anything that spiked versus the prior week. When "export is broken" goes from 3 mentions to 30 in a week, you know about it Monday morning, not when a VP escalates it Friday afternoon.

Customer emails. Your CS team gets hundreds of emails a week. Most contain useful signal buried in polite language. An agent scans them for pain indicators: phrases like "we're considering alternatives," "this has been a problem for months," "our team is frustrated with," "when will you support." These get flagged and categorized. You see the patterns across all customer communication, not just the loudest complainers.

NPS and surveys. Open-ended NPS responses are a goldmine that nobody reads. An agent processes every response, extracts the core sentiment and specific product areas mentioned, and groups them by score band. Your detractors are telling you exactly why they're unhappy. Your passives are telling you what would tip them to promoters. Read the synthesis, not the raw responses.

App reviews and social mentions. G2, App Store, Trustpilot, Reddit, Twitter. An agent monitors all of them, extracts product-relevant mentions, and surfaces anything new. When three people on Reddit mention switching from you to a competitor for the same reason in the same week, you want to know.

Product analytics. This one's different because it's behavioral, not verbal. An agent monitors your key flows and flags anomalies. Onboarding completion dropped 12% this week. The export feature usage spiked 40%. Users who hit the billing page are bouncing 3x more than last month. These are signals that no interview would surface because customers don't always know their own behavior.

All of this runs automatically. You set it up once. It runs every day or every week depending on the source. Monday morning, you have a unified view of what your customers are experiencing. Every single one of them, not just the two you talked to.

From signals to opportunities (automatically)

Raw signals are useless without synthesis. This is where the second layer of agents comes in.

A synthesis agent takes the extracted signals from all sources and does what you used to do manually on Friday afternoons: looks for patterns.

It asks: What problems are showing up across multiple channels? If "export is slow" appears in 40 support tickets, 3 sales call objections, and 2 NPS detractor responses, that's not three separate issues. That's one opportunity with strong signal across channels.

It also asks: What's new this week versus last week? Trending problems matter more than chronic ones because trending means something changed. Maybe you shipped a release that broke something. Maybe a competitor launched a feature that's making your users jealous. Maybe a customer segment is growing and hitting a scale wall you didn't anticipate.

And it asks: Which customer segments are affected? "Export is slow" is generic. "Export is slow for enterprise customers processing more than 10,000 records" is actionable. The agent breaks down patterns by segment so you know who cares and how much revenue is at stake.

The output is a weekly opportunity brief. Five to ten opportunities, ranked by signal strength and business impact. Each one includes: what the problem is, who's affected, how we know (which channels surfaced it), how severe it is, and whether it's getting better or worse.

You used to build this picture over weeks of interviews and analysis. Now it arrives in your inbox Monday morning.

Rapid prototyping as the core of discovery

Here's the idea that changes everything: the prototype is no longer the output of discovery. It's the tool of discovery.

In the old model, you'd discover a problem, validate it through more interviews, design a solution, spec it, build it, test it, ship it. Discovery and delivery were sequential phases with a handoff in between.

In the new model, discovery and delivery merge. You discover a signal on Monday. You prototype a solution on Tuesday. You put it in front of a customer on Wednesday. Their reaction is the validation. The prototype did the job of weeks of interviews and specs and designs, in hours.

This works because AI coding tools have collapsed the cost of building a working prototype from weeks to hours. When I say prototype, I don't mean a Figma mockup. I mean a functional thing. Something the customer can click through, enter data into, and react to as if it were real. Something that provokes an honest reaction because it feels real.

Describe the problem and your hypothesis to an AI coding agent. "Build me a dashboard that shows freelancers their top 10 job matches, ranked by fit score, with a one-click apply button." Two hours later, you have something to show.

That prototype is worth more than a spec document, more than a mockup, and more than an interview where you describe the idea. Because people react to real things differently than they react to hypotheticals. They find edge cases. They reveal their actual priorities. They show you, through how they use it, what matters and what doesn't.

I've had customers use a prototype for five minutes and reveal an insight that would have taken me a month of interviews to surface. "Oh, I wouldn't use the fit score. I'd just sort by deadline because I need work this week." That one sentence kills the recommendation algorithm and replaces it with a much simpler deadline-sorted view. Five minutes, one prototype, one insight that saved months.

Agentic discovery: Ideas that will feel radical

Let me push further. Here are things I'm building toward or actively experimenting with. Some of these will sound extreme. That's the point.

The auto-interviewer. An AI agent that conducts asynchronous interviews with customers via chat. Not a survey. An actual conversational interview that follows up, asks "why," and probes deeper based on responses. It runs 24/7. It can interview 100 customers in a week instead of 2. The PM reviews the synthesized patterns, not the raw transcripts. You still do live interviews for the hardest problems, but 80% of your discovery volume is handled by the agent.

The opportunity radar. An agent that doesn't wait for you to ask "what should we build?" It monitors all signals continuously and proactively surfaces emerging opportunities. "Three enterprise customers mentioned HIPAA compliance this week. None of them mentioned it last month. Two of them have renewals in Q3. This is a new signal worth investigating." You didn't ask for this analysis. The agent brought it to you because it noticed the pattern.

The prototype factory. When the opportunity radar surfaces a signal, a second agent automatically generates a prototype that addresses it. By the time you read the opportunity brief on Monday morning, there's already a clickable prototype attached. You review the opportunity, open the prototype, and decide: is this worth showing to a customer today? If yes, you're in front of a customer with a working solution before lunch. If no, you've lost nothing.

The feedback loop closer. After a customer uses a prototype, an agent follows up automatically. "You tried the new export feature yesterday. Quick question: did it solve the problem you were having?" The response gets fed back into the signal processing layer. The loop closes itself. Signal, prototype, customer, feedback, back to signal.

The competitive shadow. An agent that monitors competitor product changes, pricing updates, G2 reviews, job postings, and social mentions. When a competitor launches a feature your customers have been requesting, you know within hours. When a competitor posts job listings for ML engineers, you know they're investing in AI before they announce it. The synthesis includes: "Competitor X launched feature Y. 14 of our customers have requested something similar in the past 90 days. Here are the three most relevant customer requests."

The churn predictor. An agent that combines usage data, support ticket sentiment, NPS scores, and engagement trends to predict which customers are at risk of churning. Not after they've left. Before. "Customer ABC's usage dropped 30% this month. They submitted 4 support tickets about the same issue. Their NPS score went from 8 to 5. Their contract renews in 60 days. Recommended action: reach out this week with a prototype that addresses their specific issue." You're not reacting to churn. You're preventing it with a targeted prototype delivered before they even consider leaving.

What your week looks like now

Let me make this concrete with what my actual week looks like.

Monday morning. I open my laptop and review three things: the weekly opportunity brief (auto-generated from all signals), the agent health dashboard (are all my data pipelines working), and the prototype queue (any auto-generated prototypes worth reviewing). This takes 30 minutes. I now have a clearer picture of my customer landscape than I used to get from a month of manual work.

Monday afternoon. I pick the top two opportunities from the brief and decide how to validate them. For one, I schedule a customer call. For the other, I build a prototype. The prototype takes two hours. I share it with two customers via async message: "Hey, we're exploring a solution for the issue you mentioned. Mind taking a look?"

Tuesday. I do my live customer call. But unlike the old model, I'm not exploring blindly. I already know, from the signal analysis, exactly what this customer is struggling with. The interview is targeted. I show them the prototype. Their reaction tells me more in 10 minutes than an hour of open-ended questions would.

Wednesday. Customer feedback is in from the async prototype shares. One loved it. One said "close but I'd need X instead of Y." I iterate on the prototype in an hour. I share the updated version. Meanwhile, the feedback loop agent is processing new signals from this week's support tickets and sales calls.

Thursday. Decision day. Based on the prototype feedback and signal data, I decide: we're building this. Not the original version. The iterated version that customers shaped. I brief engineering with the prototype as the spec. They can see exactly what we're building because it already works.

Friday. Engineering starts building the production version. I review next week's opportunity brief draft. I check the assumption tracker to see which hypotheses are still unvalidated. I plan what to prototype next week.

Five days. From signal to validated solution to engineering kickoff. That used to take eight weeks.

The human parts that matter more, not less

I need to say this clearly because it's easy to misread what I'm arguing: AI makes the human parts of discovery more important, not less.

The reason is simple. AI handles volume. It processes thousands of signals. It generates prototypes. It tracks patterns. But it can't do the things that actually make a great PM.

It can't sit across from a customer and feel the frustration in their voice when they describe a workaround. It can't read body language. It can't build the relationship that makes a customer honest with you instead of polite. It can't make the judgment call about which opportunity matters most when the data is ambiguous.

It can't ask the follow-up question that nobody thought to ask. "You said you use Slack to find work instead of our search. What is it about Slack that works better?" That question, and the answer, led to one of our best features. No agent would have asked it because it requires human curiosity and context.

The new model doesn't eliminate customer conversations. It makes them 10x more powerful. You show up to every conversation with full context. You know what this customer's been struggling with because the agents already analyzed their support tickets, usage patterns, and NPS scores. You bring a prototype to react to instead of hypotheticals to discuss.

Your interviews go from "Tell me about your experience" to "I noticed you've been exporting large datasets three times a week and hitting timeout errors. We built something that might fix that. Want to try it?" That's a different caliber of conversation.

Setting up your discovery engine

Here's the practical path. You don't need to build all of this at once.

Week 1: Turn on transcription. If your sales and CS calls aren't being transcribed, start there. Gong, Fireflies, or even Otter.ai. Get every customer conversation into text. This is the raw material for everything else.

Week 2: Build your first signal agent. Pick your highest-volume channel, probably support tickets. Set up an agent that reads last week's tickets, extracts the top 10 problems, and sends you a summary every Monday. This alone will change how informed you are. See the setup guide for the technical details.

Week 3: Add a second channel. Expand to sales call analysis or NPS responses. Now you have two signal streams feeding your Monday brief. Patterns that span both channels are gold.

Week 4: Build your first prototype in response to a signal. When Monday's brief surfaces an opportunity, don't schedule more research. Build a prototype. Show it to a customer. Get feedback. Close the loop in a week.

Month 2: Add the synthesis layer. Connect your signal agents to a synthesis agent that cross-references patterns across channels. Add the opportunity radar. Start getting proactive alerts instead of weekly summaries.

Month 3: Scale the loop. Add the prototype factory. Add the feedback loop closer. By now, you're running 3-5 discovery cycles per week instead of 1-2 per month. Your learning velocity has increased by an order of magnitude.

For the full agent fleet and scheduling details, see Your AI Agent Fleet.

Start this week

Pick one.

Turn on transcription. If you're not transcribing every customer call, that's step one. You're sitting on thousands of insights locked in audio files nobody will ever replay.

Build one signal agent. Support tickets or NPS responses. Whichever you have the most of. Get a weekly summary of what customers are telling you. Follow the setup guide.

Prototype something today. Take the most common customer complaint you know about. Don't research it further. Build a working prototype that addresses it. Show it to one customer. See what happens.

Run the full loop once. Signal on Monday. Prototype on Tuesday. Customer on Wednesday. Feedback on Thursday. Decision on Friday. Do it once and you'll never go back to the old way.

The discovery fundamentals haven't changed. Understanding customers, finding real problems, testing before building. What changed is the speed at which you can do all of it. And in a world where the PM who learns fastest wins, speed is everything.