# Survey design patterns across product demos

> Collect demo videos across your space and query interaction patterns — a design review across the whole market.

- For: Product designer
- Category: Product & UX Research
- MCP tools: deep_search, library_import_youtube_video, deep_context
- HTML version: https://veridive.com/mcp/use-cases/design-pattern-survey

## The problem

Before designing the flow, every designer does the same furtive research: open five competitor products (the ones with free tiers), click around, screenshot, guess at the reasoning. The survey is limited to what you can access, biased toward what you already knew, and shallow on the *why* — you see the pattern but not the narration.

Product demos fix all three limits, unofficially: companies demo their best flows constantly — launch videos, webinars, conference walkthroughs — narrating the reasoning as they click. "We redesigned this so users wouldn't have to..." is design rationale, spoken aloud, about the exact pattern you're weighing. The whole market's design decisions, demonstrated and explained, sitting in public.

## How veridive MCP helps

**deep_search** collects the pattern corpus: demos and walkthroughs across your space — including products you can't access, in markets you don't work in — found at the transcript level, so "demos showing how products handle <interaction>" returns those moments precisely.

**library_import_youtube_video** and **deep_context** turn it into a queryable pattern library: import the relevant demos and ask across them — *"how do these products handle <flow>? what reasoning do presenters give? where do the approaches split?"* — answered with **citations to the demos**. The design review stops being five screenshots and a hunch; it's the market's approaches, with their narrated rationale, compared in one pass.

## How to run it

1. **Connect veridive MCP** — One-time setup: add the veridive MCP server to Claude, ChatGPT, Cursor or any MCP client and generate your API key. Takes about two minutes.
2. **Collect the pattern corpus** — Demos showing the interaction you're designing — across your space and adjacent ones.

   ```
   Find product demos and walkthroughs showing how products handle <interaction/flow> — across <space> and adjacent categories — use veridive's deep_search.
   ```
3. **Build the pattern library** — Import the relevant demos; the corpus becomes queryable by design question.

   ```
   Import these into my library, tagged '<flow>-patterns': <video URLs>
   ```
4. **Run the survey** — Approaches, rationales and splits — the market-wide design review, cited.

   ```
   Across the '<flow>-patterns' demos: what approaches appear, what reasoning do presenters narrate, and where do products diverge? Cite the demos and moments.
   ```

## Problems it solves

- Pattern research is limited to products you can access and free tiers you can click.
- Screenshots capture the pattern but never the narrated reasoning behind it.
- Adjacent-market solutions to your exact problem stay invisible from inside your category.
- Design reviews rehash the same five references everyone already knew.

## Why it's valuable

- The survey covers the market, not your login list — including enterprise products behind sales walls.
- Narrated rationale comes attached: the why, in the designer's or PM's own words.
- Adjacent-category patterns import cleanly — the freshest solutions usually live one space over.
- The pattern library persists: next quarter's flow question queries the same corpus.

## Example prompts

```
Demos showing how products handle <flow>, including adjacent categories — use veridive's deep_search.
```

```
Import these, tagged '<flow>-patterns': <URLs>
```

```
Approaches, narrated rationale, divergences across the corpus — cited.
```

## FAQ

**Demos show the happy path — isn't that misleading?**

It's the pattern at its best, which is exactly what you're surveying: the intended design. Pair with the friction layer (user-pain and tutorial mining) for how patterns survive contact with users — the two passes together are the full picture.

**Why import instead of just watching the demos?**

The library makes it comparative: deep_context queries across all demos at once and cites the moments, which is how splits and rationales become visible. Watching serially, you'd hold five patterns in memory and compare vibes.

**Does this help design-system and component decisions too?**

Anywhere the market has demonstrated solutions — onboarding, permissions, data tables, AI-feature UX (currently the fastest-moving pattern space). The narrower the question, the sharper the survey.

## Related use cases

- [Benchmark your onboarding against rivals' tutorials](https://veridive.com/mcp/use-cases/onboarding-benchmark.md) — Collect competitors' getting-started videos and query them side by side: where do users need hand-holding your flow avoids — or shares?
- [Mine public demos for win/loss signals](https://veridive.com/mcp/use-cases/demo-mining-win-loss.md) — Watch how rivals demo the features you lose deals on and get a cited summary of the exact claims they make.
- [Import winning formats from other languages](https://veridive.com/mcp/use-cases/cross-language-format-scouting.md) — Filter by spoken language to find formats crushing in Japanese or German that nobody has localized to yours yet.

---

Part of the veridive MCP use-case library: https://veridive.com/mcp/use-cases.md
Server docs for agents: https://veridive.com/mcp.md