---
name: sales-validatethat
description: "ValidateThat (validatethat.io) platform help — a low-cost, self-serve UX-research and idea-validation micro-tool: an idea-validation engine (fast market verdict + competitor read + research plan) plus card sorting, tree testing, first-click/prototype tests, surveys, and interviews, with studies embeddable on your own site, Prolific recruitment, a Figma plugin, and — rare for this class — an MCP server to run research from Claude or Cursor. Use when running a card sort or tree test on a budget, validating a product idea before building, embedding a study on your website, recruiting testers via Prolific, reading a similarity matrix or dendrogram, choosing between its Free, Starter, and Pro tiers, setting up its MCP server, or comparing it with Optimal Workshop, UXtweak, or Lyssna as a cheaper option. Do NOT use for the tool-agnostic validate-before-building method or comparing research tools across the market (use /sales-idea-validation), or an API/webhook-native research pipeline (use /sales-userintuition)."
argument-hint: "[describe what you need help with in ValidateThat]"
license: MIT
version: 1.0.2
tags: [sales, pre-launch, platform]
---

# ValidateThat Platform Help

ValidateThat (validatethat.io) is a **low-cost, self-serve UX-research + idea-validation micro-tool** —
the budget, indie answer to Optimal Workshop / UXtweak. It bundles an **Idea-Validation Engine** (idea →
market verdict + competitor breakdown + prioritized research plan) with the full battery: **card sorting**
(open/closed/hybrid → similarity matrix / dendrogram), **tree testing**, **first-click / prototype tests**,
**surveys**, and **interviews** — plus studies you **embed on your own site** (one-line snippet),
**Prolific** recruitment, and a **Figma plugin** (frame → card sort). Its one genuinely differentiating
surface in this cluster: an **MCP server** ("run UX research from a chat" in Claude / Cursor) — every peer
here (Optimal Workshop, UXtweak, Lyssna, Useberry) is UI-only with no automation surface at all.

**Two things to say almost every time:**
- **A clean card sort or tree test proves the *structure works*, not that anyone will *pay*** — and the **Idea-Validation Engine's verdict is an AI opinion, not demand.** If the user is still deciding whether to build, keep the findings/research plan but take the go/no-go to a **real behavior test** via `/sales-idea-validation`.
- **ValidateThat has NO public REST API or webhooks.** The only programmatic surface is the **MCP server** (plus the Figma plugin and embed snippet); a "pipe results into my CRM/warehouse" ask is MCP-from-an-agent or manual **CSV export** (Starter+), not REST — for a documented pipeline, route to `/sales-userintuition`.

## Step 1 — Gather context

If `references/learnings.md` exists, read it first for accumulated platform knowledge.

Ask only what you can't infer:

1. **What do you want from ValidateThat?**
   - A) **Validate an idea** — the Idea-Validation Engine (market verdict + competitor read + research plan)
   - B) **Pick/run a study** — card sort vs tree test vs first-click/prototype vs survey vs interview
   - C) **Embed a study on my site** — the one-line snippet
   - D) **Recruit participants** — via **Prolific** ($40 free credit) vs sharing a link to your own users
   - E) **Automate** — the **MCP server** (Claude/Cursor) or **CSV export** (no REST API)
   - F) **Choose** — ValidateThat vs Optimal Workshop / UXtweak / Lyssna, or Free vs Starter vs Pro
2. **Are you testing something you've already built/designed, or still deciding whether to build?** The
   second is an idea-validation question — flag it in Step 2.

Skip-ahead: if the prompt already names the study type or the question is specific, go to Step 3.

## Step 2 — Route or answer directly

| If the user's question is about… | Route to |
|---|---|
| The tool-agnostic **validate-before-building method**, or comparing research/idea tools across the whole market | `/sales-idea-validation {question}` |
| A documented **API / webhook-native** research or interview pipeline (ValidateThat has none) | `/sales-userintuition {question}` |
| Running a **real behavior** demand test (smoke-test page, waitlist, pre-sale) instead of an IA/usability test | `/sales-idea-validation` or `/sales-funnel` `{question}` |
| The deep-IA **reference-standard** peer (benchmark card-sort/tree-test analysis) | `/sales-optimalworkshop {question}` |
| The broad self-serve **all-in-one usability** peer (own panel, session recording) | `/sales-uxtweak {question}` |
| Recruiting participants **at scale via the Prolific panel itself** (API/webhooks/CLI) | `/sales-prolific {question}` |

When routing, give the exact command: "This is a {domain} question — run: `/sales-idea-validation {original question}`"

Otherwise, answer ValidateThat-specific questions using Step 3.

## Step 3 — ValidateThat platform reference

**Read `references/platform-guide.md`** for the full reference — the module/automation-surface table (what's
MCP-accessible, embed-accessible, or UI-only), best-effort pricing and plan gates (which research methods are
Pro-gated, the free-tier 3-study limit, Prolific recruitment cost), the Idea → Study → Participant → Response
data model with JSON shapes, the MCP-server setup + Figma-plugin + embed-snippet recipes, and the no-REST-API
data-out playbook. ValidateThat has **no public REST API**, so there is no API-reference file.

Answer using only the relevant section — don't dump the full reference.

## Step 4 — Actionable guidance

- **Say the caveat: an IA/usability result — and the AI verdict — is not demand.** Make explicit that a card
  sort / tree test proves a *structure* **works** (findability, category agreement) and the Idea-Validation
  Engine's verdict is an **AI opinion**; neither proves strangers will **pay**. If they're still deciding
  whether to build, keep the findings but take the go/no-go from a **real behavior test** (smoke test, pre-sale)
  via `/sales-idea-validation`.
- **Flag it as MCP-only when any automation/export comes up.** ValidateThat has **no public REST API or
  webhooks** (verify — it may change). The programmatic surface is the **MCP server** (run/list studies, pull
  stats from Claude/Cursor), the **Figma plugin** (frame → card sort), and the on-site **embed snippet**;
  bulk data-out is **CSV export** (Starter+). "Sync results to HubSpot/Snowflake on a schedule" is MCP-from-an-agent
  or a scripted CSV job, not REST — if a documented pipeline is required, route to `/sales-userintuition`.
- **Match the tool to the question.** Recommend by job: **card sort** = how users *group/label* content (open =
  discover, closed = validate → **similarity matrix / dendrogram**); **tree test** = can users *find* things in
  your nav (findability, no visuals); **first-click / prototype test** = where users click first; **survey /
  interview** = attitudes and *why* (Pro-gated). Design the tree with a card sort, then validate it with a tree test.
- **Steer recruitment by budget.** Recruiting via **Prolific** is billed **per response** (~$3.50, best-effort;
  a **$40 free credit** seeds every account) — for a handful of testers, **sharing a study link to your own
  users is free**. Present the Prolific rate and the free credit as best-effort.
- **Warn about the plan gates before they hit them.** **Free = 3 studies** (analytics limited to the first ~3
  respondents); **Starter** unlocks unlimited card sorts / tree tests / first-click + full analytics + AI
  insights + CSV export + hide-branding; **surveys, interviews, and competitor analysis are Pro+**. Present all
  pricing as best-effort and point to **validatethat.io/pricing**.
- **Set participant counts realistically.** Quantitative IA (card sort / tree test) needs ~30+ for a stable
  similarity matrix / findability score; qualitative (interviews) surfaces most themes with a handful. Say it's
  a rule-of-thumb, not a guarantee.

If you discover a gotcha or tip not in `references/learnings.md`, append it there with today's date.

## Gotchas

*Best-effort from research (2026-07) — pricing, the Pro-gated method split, the Prolific per-response rate and
free credit, and the exact MCP-server config move; verify at validatethat.io.*

- **IA/usability success — and the AI verdict — ≠ demand.** ValidateThat proves a *structure/design* works and
  the engine gives an *AI opinion*; the build-or-not go/no-go still belongs to a real behavior test. Route that
  to `/sales-idea-validation`.
- **No REST API, no webhooks.** The only automation surfaces are the **MCP server**, the **Figma plugin**, and
  the on-site **embed snippet**; bulk data-out is **CSV export** (Starter+). Don't design a live REST/webhook
  pipeline around it — route pipeline needs to `/sales-userintuition`.
- **The exact MCP config is not in public docs.** ValidateThat's site confirms the MCP server (Claude Desktop /
  claude.ai / Claude Code) but the marketing pages are JS-rendered; **don't invent an endpoint URL, auth method,
  or tool names** — have the user copy the connect string from validatethat.io's integrations/settings page and
  discover the tool list at runtime.
- **Surveys and interviews are Pro-gated.** The Free and Starter tiers cover card sort / tree test / first-click
  only — a user who needs surveys, interviews, or competitor analysis has to be on **Pro+**. Check the plan before
  promising a method.
- **Free caps studies AND analytics.** Free is **3 studies** with analytics limited to roughly the **first 3
  respondents** (responses beyond that are collected but not analyzed) — it's a real evaluation limit, not just a
  study count. Starter unlocks full analytics.

## Related skills

- `/sales-kardsort` — The **closest budget twin**: the same indie card-sort/tree-test battery at an even lower,
  **one-time** price (no subscription) with **rich-media / participant-created cards** — but with **no MCP server,
  Figma plugin, embed, or idea-validation engine** (export-only: CSV / Casolysis / SynCaps + the `cardsort` Python
  package). Route here when one-time pricing or rich cards matter more than automation. Install: `npx skills add sales-skills/sales --skill sales-kardsort -a claude-code`
- `/sales-provenbyusers` — Another **budget twin**: a cheap *full-battery* IA/usability suite (card sort/tree test + first-click/five-second/preference/surveys) with one-time pricing and CSV export, but **no MCP, no idea-validation engine, and no Figma/embed** — recruit-your-own-participants only. Route here when method breadth matters more than an automation surface. Install: `npx skills add sales-skills/sales --skill sales-provenbyusers -a claude-code`
- `/sales-optimalworkshop` — The **IA "reference standard"** peer: deep, specialist card sorting (OptimalSort) +
  tree testing (Treejack) + first-click (Chalkmark) with benchmark analysis and an own panel — route here when the
  job is **pure information architecture** and rigor matters more than price, or to compare; note it's UI-first
  (no API/MCP) and higher-entry-priced. Install: `npx skills add sales-skills/sales --skill sales-optimalworkshop -a claude-code`
- `/sales-uxtweak` — The broad self-serve **all-in-one usability** peer (card sort + tree test + first-click /
  five-second / preference + prototype/website tests + session recording + surveys) with its own 130-country
  panel — route here when you want breadth and a built-in panel; also UI-only/no API. Install: `npx skills add sales-skills/sales --skill sales-uxtweak -a claude-code`
- `/sales-lyssna` — The ex-UsabilityHub usability + IA twin with a **larger panel** and a **usable free plan** plus
  AI follow-ups/summaries — route here to compare, or when free-tier generosity / panel size matters. Install: `npx skills add sales-skills/sales --skill sales-lyssna -a claude-code`
- `/sales-idea-validation` — The tool-agnostic validate-before-building method + the full research/usability/validator
  landscape (use this to decide build-or-not; a passing IA test or an AI verdict is not demand). Install: `npx skills add sales-skills/sales --skill sales-idea-validation -a claude-code`
- `/sales-userintuition` — The API/webhook/MCP-native real-human interview peer — the pick when you need a documented programmatic research pipeline ValidateThat can't offer. Install: `npx skills add sales-skills/sales --skill sales-userintuition -a claude-code`
- `/sales-prolific` — The developer-native recruit panel ValidateThat recruits through — route here to drive recruitment at scale via a real REST API + webhooks + CLI. Install: `npx skills add sales-skills/sales --skill sales-prolific -a claude-code`
- `/sales-funnel` — Build the smoke-test / fake-door landing page that turns an IA/design hypothesis or an AI verdict into a real demand test. Install: `npx skills add sales-skills/sales --skill sales-funnel -a claude-code`
- `/sales-do` — Not sure which skill to use? The router matches any sales objective to the right skill. Install: `npx skills add sales-skills/sales --skill sales-do -a claude-code`

## Examples

### Example 1: "I need to fix my app's navigation but I'm on a tiny budget — what do I run?"
**User says**: "Users can't find settings in my app. I want to test the menu structure but I can't afford Optimal Workshop."
**Skill does**: Recommends a **tree test** in ValidateThat (findability without visual design), optionally preceded
by an **open card sort** if the *labels/categories* are in doubt (read via the **similarity matrix / dendrogram**).
Notes the **Free tier's 3-study / 3-respondent-analytics** limit and that **Starter (~$19/mo)** unlocks full analytics
and unlimited tests, so a real 30-participant study needs Starter. Suggests **sharing the link to your own users
(free)** before paying Prolific. Adds that a clean tree test proves the nav *works*, not that the product sells.
**Result**: The user runs a Starter-tier tree test with the right participant count for a fraction of the peer price.

### Example 2: "How do I run a ValidateThat card sort from Claude / automate this?" (developer/automation)
**User says**: "Can I spin up card sorts and pull results into my workflow without clicking around the dashboard?"
**Skill does**: States plainly that ValidateThat has **no public REST API or webhooks** — the automation surface is
its **MCP server** ("run UX research from a chat" in Claude Desktop / claude.ai / Claude Code — create studies, list
studies, pull stats), plus the **Figma plugin** and on-site **embed snippet**, with **CSV export** (Starter+) for
bulk data-out. Tells the user to copy the MCP connect string from validatethat.io's integrations page (the exact
endpoint/auth **isn't in public docs — don't guess it**) and discover the tool list at runtime. If they need a
documented REST + webhooks pipeline, routes to `/sales-userintuition`.
**Result**: The user wires up the MCP server in Claude instead of hunting for a REST API that doesn't exist.

### Example 3: "Should I trust ValidateThat's 60-second idea verdict, and is Starter enough?"
**User says**: "I ran my SaaS idea through their validation engine and it says 'go' — do I start building? And which plan?"
**Skill does**: Cautions that the Idea-Validation Engine's verdict + competitor breakdown are an **AI opinion, not
demand** — keep the research *plan* it hands you, but earn the go/no-go with a real behavior test (smoke test,
pre-sale) via `/sales-idea-validation`. On plans (best-effort): **Free = 3 studies**, **Starter (~$19/mo)** = unlimited
card sorts/tree tests + full analytics, but **surveys, interviews, and competitor analysis are Pro (~$49/mo)**, so if
the research plan calls for interviews the user needs Pro. Points to validatethat.io/pricing and flags every figure
as best-effort.
**Result**: The user treats the verdict as directional, runs the recommended studies, and picks the tier matching the methods.

## Troubleshooting

### "Which do I run — a card sort or a tree test?"
**Symptom**: The user isn't sure whether to test *categories/labels* or *navigation findability*.
**Solution**: Use a **card sort** when the question is how users *group and name* content (open = create/label to
discover a structure; closed = sort into *your* categories to validate them → read via **similarity matrix /
dendrogram**). Use a **tree test** when the structure exists and the question is whether users can **find** an item
(findability + first-click path, no visual design). Run the card sort to *design* the tree, then the tree test to
*validate* it — and remember a passing test proves the structure works, not that anyone will pay.

### "The validation engine said 'go' — is my idea validated?"
**Symptom**: The user is treating the 60-second AI verdict as a green light to build.
**Solution**: No — the verdict, competitor breakdown, and market read are an **LLM opinion** (it can invent market
sizes and encourage almost any idea). Keep the **prioritized research plan** it produces (it's a good to-do list) and
the competitor map for positioning, but take the build-or-not go/no-go from a **real behavior test** (smoke-test page +
pre-sale) via `/sales-idea-validation`. A passing card sort or tree test you run next proves the design works — still
not demand.

### "How do I get ValidateThat results into my stack / automate exports?"
**Symptom**: The user wants results flowing into a CRM, warehouse, or Slack automatically.
**Solution**: ValidateThat has **no public REST API or webhooks**. Programmatic surfaces are the **MCP server**
(drive studies + pull stats from Claude/Cursor), the **Figma plugin**, and the on-site **embed snippet**; bulk
data-out is **CSV export** (Starter+). Copy the MCP connect string from validatethat.io's integrations page (the
exact endpoint/auth **isn't published — don't invent it**), or glue a scheduled CSV export into your ETL. If an
automated documented pipeline is required, route to `/sales-userintuition` (REST API + HMAC webhooks + MCP).