Imagine you have an existing product and you want to find real product gaps:

  • what customers asked for but you don’t have,
  • what they expected to work differently than it works today,
  • where reality doesn’t match the promise.

The problem isn’t that the answers don’t exist. The problem is that they’re scattered.

They’re buried across internal communication (often the most honest and valuable source), Confluence meeting notes, customer interview write-ups, old Jira / Productboard / Trello cards created by different people at different times. Some are in Google Docs and spreadsheets. Some are in older tickets that aren’t linked to your long-term roadmap or insights anymore.

And tracking systems evolve: you change the approach, migrate tools, inherit someone else’s setup, lose links between insights and feature requests. The evidence is still there—but fragmented.

Now add the final twist: you don’t want the last few weeks. You want to search the past—a full year, for example.

So you picture doing it manually—or asking colleagues to do it—and you can already feel everyone going a little crazy.

And then you think: Ha! There is AI, so let’s leverage it. But how?

The tempting prompt that fails

In your head, the solution is obvious:

“Find product gaps in my product—use all available connections and search 1 year back.”

Yes, you can ask that. And yes, the assistant will try its best. It will process and produce something that looks impressive.

But you will probably not get what you want from one prompt.

Not because the chatbot is “bad,” but because:

  • the task is too broad,
  • success criteria are vague,
  • and you can’t verify direction early.

It becomes easy to blame the chatbot: I told you what I want, right? Or… did you?

The mindset shift: treat AI like your team

Now imagine you asked your team to do the same task.

Would you give them one vague instruction and disappear for 2–3 weeks? No.

You’d want to:

  • chunk the work,
  • verify early,
  • do a quick 15–30 minute sync to calibrate: what’s a good direction, what’s off track, whether they went too deep or too shallow.

AI works like your team—just much faster.
What a human might produce in a day, AI can produce in 10 minutes.

But here’s the trap: speed makes you think feedback time can shrink too.
That you don’t need to guide it much because it’s doing “magic.”

That’s the biggest mistake.

The playbook: chunk → verify → report → scale → connect → map

1) Start small (one source, short timeframe)

Ask AI to process one source (or two) for a short window (e.g., last month).

Keep the scope small, but keep the direction aligned with the ultimate goal.

2) Calibrate with real feedback (like you would with your team)

Treat the first output like a teammate’s first delivery.

You wouldn’t wait weeks to find out they misunderstood the task—you’d do a 15–30 minute check-in after the first chunk to calibrate. Do the same with the chatbot.

In that calibration, focus on:

  • Direction: Is it finding the kind of gaps you meant, or drifting into bugs / random complaints / generic themes?
  • Depth: Did it go too shallow (high-level fluff) or too deep (one-off edge cases)?
  • Source discipline: Is it actually using the sources you asked for, or “summarizing the idea of them”?
  • Your definition: What counts as a gap in your world (and what doesn’t)?

This is the step where you should spend real time. AI is fast at producing output, but you still need to steer the workflow with clear feedback—just like you would with a person.

3) Generate a clean “handover” report for the chunk

Once a chunk is good, ask for a structured summary/report of what it found.

If that report is high quality, it’s already valuable—because you didn’t just get output, you got a repeatable way to get output.

4) Scale using the same recipe (controlled, not explosive)

Now do the same again:

  • next 2 sources, or
  • extended timeframe.

Same method. Same quality checks.

5) Prevent source mixing

Important: verify the sources it used.

Chatbots can mix stuff. A practical way to reduce that:

  • Start a new thread for each source (or each chunk).
  • Ask very similar questions again (you already know how to ask, and what mistakes can happen).
  • Give hints based on what you learned so it avoids repeating mistakes.

6) Connect what you extracted (this becomes easier)

After a few rounds, you’ll have gaps collected from multiple chunks (2 + 2 sources, more time windows, more reports).

Now the task is no longer “data mining.”
It’s connecting: linking gaps together, comparing themes, stitching insights into something coherent.

7) Map to your current tracking system (turn it into decisions)

Final step: compare with what you already track in your primary system and map:

  • what’s already represented as an insight/feature request,
  • what should become backlog,
  • what looks completely new.

Start small here too: give it a subset of current features/insights, ask for mapping, verify it works, then scale.

Why this works (and why it prevents the “AI let me down” moment)

If your first attempt is a huge prompt that produces mediocre output, the experience feels like a failure—and it’s easy to stop right before you find the gold.

Chunking protects you from that:

  • You get early wins.
  • You validate direction fast.
  • You build reusable reports.
  • You scale with confidence instead of hope.

Key takeaways

  • Chunk your big task into smaller tasks (by source and timeframe).
  • Verify quality on one chunk before scaling.
  • Generate a report per chunk so it’s reusable.
  • Connect the reports together (synthesis is easier than mining).
  • Map gaps to your existing backlog to separate “already known” from “actually new.”

AI isn’t magic. It’s not magic. It’s not magic. It’s fast—but it still needs your direction.

Spend serious time on feedback and quality checks. Don’t assume it knows what you want or how you want it until you tell it.