---
name: sales-leanspark
description: "LEANSpark (leanspark.ai) platform help — an AI startup-validation system by Ash Maurya, creator of the Lean Canvas, built on Lean Canvas + Continuous-Innovation PDCA cycles, not a one-shot score: a free Lean Canvas builder stress-tested across seven dimensions, persistent memory, a Contradiction Detection engine that flags where plan and evidence stop agreeing, and two-week Plan-Do-Check-Act cycles ending in a Persevere / Pivot / Pause call. Exposes an OAuth MCP server (leanspark.ai/mcp) that reads your validated canvas, positioning, and voice profile into Claude Code or Cursor. Use when building or stress-testing a Lean Canvas, acting on a flagged plan-vs-evidence contradiction, deciding persevere/pivot/pause, setting up the MCP server, weighing free tier vs a paid credits plan, or asking whether it has a REST API. Credit-metered; no REST API. Do NOT use for comparing idea validators or the validate-before-building method (use /sales-idea-validation), or the smoke-test landing page (use /sales-funnel)."
argument-hint: "[describe what you need help with in LEANSpark]"
license: MIT
version: 1.0.0
tags: [sales, idea-validation, platform]
---

# LEANSpark Platform Help

LEANSpark (leanspark.ai) is **"the decision layer for founders"** — an AI startup-validation *system*
by **Ash Maurya** (creator of the Lean Canvas, author of *Running Lean*), built on his Lean Canvas +
Continuous-Innovation framework. Unlike the one-shot "score my idea" validators, it keeps **persistent
memory** of your model, interviews, and experiments, runs **two-week Plan-Do-Check-Act cycles** over
~90 days, and has a **Contradiction Detection engine** that flags where your plan and your evidence stop
agreeing — ending each sprint in a **Persevere / Pivot / Pause** decision. It also exposes an **OAuth
MCP server** so Claude Code / Cursor can read your validated model.

## Step 1 — Gather context

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

Ask only what you can't infer from the user's prompt:

1. **Where are you?** (a) building/stress-testing a Lean Canvas, (b) staring at a seven-dimension result
   or a flagged contradiction and unsure what to do, (c) mid-cycle and deciding persevere/pivot/pause,
   (d) wiring the MCP server into Claude Code / Cursor, (e) weighing free tier vs a paid credits plan,
   (f) asking whether it has a REST API / how to get data out.
2. **What's the idea, in one sentence?** (helps interpret the canvas and the seven-dimension stress test).
3. **What evidence have you got so far** — a hunch, customer interviews, an experiment result, a landing
   page, a waitlist, or someone offered to pay?

Skip-ahead rule: if the user's prompt already contains enough context, skip to Step 2.

## Step 2 — Route or answer directly

LEANSpark is one validation *system*. Much of the thinking a founder needs is tool-agnostic — route it:

| The user's real question | Route to |
|---|---|
| Should I trust this? How do I actually validate? The evidence ladder, comparing validators | `/sales-idea-validation` |
| Build the smoke-test / fake-door landing page the demand test runs on | `/sales-funnel` |
| Grow a pre-launch waitlist and capture signups | `/sales-audience-growth` |
| Run the ~10 customer interviews that feed the evidence side | `/sales-idea-validation` |
| Reddit-based real-demand signal to cross-check the model | `/sales-trendseeker` |

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

Answer **directly** only for LEANSpark-specific mechanics (the 12-block canvas, the seven dimensions,
the contradiction engine, PDCA cycles, persevere/pivot/pause, credits & modes, the MCP server).

## Step 3 — LEANSpark platform reference

**Read `references/platform-guide.md`** for the full reference — the 12-block canvas and seven-dimension
stress test, the persistent-memory / contradiction-detection / PDCA loop, credits & the Reactive /
Attentive / Proactive modes, pricing/plan gates, the MCP server (setup, scopes, the one write-back tool),
and how to get data out. **Read `references/leanspark-api-reference.md`** for the MCP surface verbatim.

Answer using only the relevant section — don't dump the whole guide.

## Step 4 — Actionable guidance

- **The canvas, seven-dimension score, and contradiction flags are coaching over *your* inputs — not demand.**
  LEANSpark's edge over pure-LLM validators is that it's built around running *real* experiments and
  interviews and tracking that evidence over 90 days — but a well-organized canvas with no real customer
  evidence fed in is still just a plan. Keep the structure and the flagged contradictions; take the
  go/no-go from a real behavior test (smoke test / pre-sale). Route that to `/sales-funnel` + `/sales-audience-growth`.
- **The Contradiction Detection engine only checks things you told it — it can't see that your evidence base is imaginary.**
  It flags where your plan and your logged evidence disagree (e.g. positioning vs. interview feedback),
  which is genuinely useful — but "no contradictions" means your inputs are internally consistent, not
  that strangers want it. Treat a flagged contradiction as your next thing to go resolve with real customers.
- **Feed it real evidence, then let it compound.** Its whole value proposition is persistent memory —
  log actual interviews and experiment results, not guesses. Tell the user the system is only as good as
  the evidence they put in; thin or invented inputs yield confident but empty coaching.
- **Read persevere/pivot/pause as a cycle verdict, not a final grade.** Each two-week PDCA cycle ends in
  Persevere (evidence supports the current model — keep testing), Pivot (a core assumption failed — change
  the model), or Pause (stop/park). It's a checkpoint against pre-set success criteria, so anchor it on
  whether the *experiment* hit its threshold, not on how the AI "feels" about the idea.
- **Present all pricing as best-effort, and explain credits + modes.** Plans are **credit-metered** (Free
  ~25 credits/mo, paid tiers up to ~1,600) and pricing may have changed — point to leanspark.ai/pricing.
  The "mode" scales with tier: **Reactive** (you drive) → **Attentive** (proactive nudges) → **Proactive**
  (daily briefings, autonomous campaigns, background watchers). The free Lean Canvas builder is usable
  without a card.
- **The MCP server is the only programmatic surface — there's no REST API or webhooks.** To use LEANSpark
  data in Claude Code: `claude mcp add --transport http leanspark https://leanspark.ai/mcp`, then authorize
  via OAuth in the browser and pick which idea to expose. It's **read-mostly** (validated canvas,
  positioning, competitive evidence, voice profile) plus **one write-back tool** to save deliverables into
  your active experiment; each connection is scoped to a single idea and revocable in Settings → MCP.
- **Don't confuse it with the free five-minute canvas generators or one-shot scorers.** LEANSpark is
  deliberately a *longitudinal 90-day process* **built by Ash Maurya, the creator of the Lean Canvas**
  (persistent memory + two-week PDCA cycles + contradiction detection), not a 60-second verdict — and it's
  **credit-metered** (always present its pricing as best-effort and point to leanspark.ai/pricing). When a
  user weighs it against a fast/free canvas generator, lead with that longitudinal-vs-one-shot contrast and
  the creator-of-the-Lean-Canvas authenticity, note the free Lean Canvas builder needs no card, and point
  them to `/sales-idea-validation` for the full comparison.

If you discover a gotcha, workaround, or tip not covered in `references/learnings.md`, append it there.

## Gotchas

*Best-effort from research (2026-07) — the AI-validator tool set churns fast; verify tiers, the modes, credits, and the MCP scopes at leanspark.ai.*

- **A tidy canvas is not validated demand.** Even from Ash Maurya, the creator of the Lean Canvas, LEANSpark
  coaches and tracks *your* evidence — it doesn't manufacture demand. Follow every green light with a real-behavior test.
- **Contradiction detection is bounded by your inputs.** It surfaces conflicts between what you *logged*;
  it can't tell you that the whole evidence base is thin or imagined. Garbage in, confident coaching out.
- **It's a 90-day commitment, not an instant score.** The value is the persistent memory + PDCA cadence
  over weeks; a founder wanting a one-shot number will find the deliberate pace a mismatch.
- **Credit-metered with tiered "modes."** Free is ~25 credits/mo in Reactive mode; proactive/autonomous
  behavior (daily briefings, background watchers) is top-tier only. Confirm current credits/prices at leanspark.ai/pricing.
- **No REST API or webhooks — MCP only.** The automation surface is the OAuth MCP server (read-mostly +
  one write-back tool), scoped to one idea. Don't plan a REST integration; there isn't one.
- **Persevere/Pivot/Pause depends on pre-set success criteria.** If you don't define what "success" for a
  cycle looks like up front, the verdict drifts toward an AI opinion — set the threshold before the sprint.

## Related skills

- `/sales-idea-validation` — the tool-agnostic validate-before-building method and the full idea-validator comparison (start here to decide whether to trust any score or system)
- `/sales-funnel` — build the smoke-test / fake-door landing page the real demand test runs on
- `/sales-audience-growth` — grow a pre-launch waitlist and capture signups once you're testing demand
- `/sales-trendseeker` — Reddit-based real-demand signal to cross-check LEANSpark's model
- `/sales-juma` — the other tool in this cluster with a callable MCP server, if you're comparing MCP surfaces
- `/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: "LEANSpark flagged a contradiction between my plan and my interviews — now what?"
**User says**: "The Contradiction Detection thing says my positioning conflicts with my customer feedback. What do I do?"
**Skill does**: Explains the engine compares what you *logged* (positioning vs. interview evidence) and that
the flag is your top thing to go resolve with real customers — not a verdict on the idea. Suggests re-running
the affected experiment with a sharper customer/problem, and reminds the user that "no contradiction" only
means internal consistency, not demand — the go/no-go still comes from a smoke test / pre-sale
(`/sales-funnel` + `/sales-audience-growth`).
**Result**: The founder treats the contradiction as a concrete next experiment instead of a pass/fail grade.

### Example 2: "Is LEANSpark worth it over a free five-minute lean-canvas generator?"
**User says**: "I can get a lean canvas in five minutes elsewhere for free — why pay for LEANSpark?"
**Skill does**: Frames LEANSpark as a *longitudinal system* (persistent memory + two-week PDCA cycles +
contradiction detection over ~90 days from the Lean Canvas creator), not a one-shot canvas or score — so
its value only shows up if you actually run experiments and log evidence over weeks. Notes the free Lean
Canvas builder is usable without a card, explains credits/modes as best-effort, and points to
`/sales-idea-validation` to compare it against the fast/free scorers.
**Result**: The user picks based on whether they'll commit to the process, not the price tag.

### Example 3 (automation): "Can I pull my LEANSpark model into Claude Code — is there an API?"
**User says**: "I want my validated canvas and positioning available in Claude Code / Cursor. Does LEANSpark have an API or webhook?"
**Skill does**: States there's **no REST API or webhooks** — the only programmatic surface is the **OAuth
MCP server**: `claude mcp add --transport http leanspark https://leanspark.ai/mcp`, then authorize in the
browser and select which idea to expose. Explains it's read-mostly (validated canvas, positioning,
competitive evidence, voice profile) plus **one write-back tool** to save a deliverable into the active
experiment, scoped to one idea and revocable in Settings → MCP — so you can generate on-brand copy grounded
in the validated model, but you can't script a full data export.
**Result**: The user connects the MCP server and reads their model into Claude Code instead of hunting for a REST endpoint.

## Troubleshooting

### The seven-dimension result / coaching feels generic
**Symptom**: The stress test or the AI's guidance reads bland and could apply to any idea.
**Cause**: LEANSpark coaches over the evidence you've logged; with only a one-line idea and no real
interviews or experiments in memory, it has nothing specific to reason from.
**Solution**: Feed it real evidence — log actual customer interviews and experiment results, answer the
canvas blocks concretely (especially early adopters and the problem), and let the persistent memory
compound over a cycle. Then cross-check the model against a real-demand signal (`/sales-trendseeker`) and
a smoke test.

### "I connected the MCP server but can't get my full data out"
**Symptom**: The MCP tools read the model but there's no bulk export / no REST endpoint.
**Cause**: LEANSpark is **UI + MCP only** — the MCP server is read-mostly with a single write-back tool, and
there is no public REST API or webhooks.
**Solution**: Use the MCP reads for what they're for (grounding content/positioning in Claude Code/Cursor)
and the one write-back tool to save deliverables into your active experiment. For anything the MCP doesn't
expose, copy from the UI. Don't design a pipeline around a REST API that doesn't exist.

### Ran out of credits / confused by Reactive vs Proactive
**Symptom**: The tool stops doing work, or the "mode" behaves differently than expected.
**Cause**: Plans are credit-metered and the *mode* is tier-gated — Free (~25 credits/mo) is Reactive
(you initiate); proactive nudges and autonomous/always-on behavior are higher tiers only.
**Solution**: Confirm current credits and tier behavior at leanspark.ai/pricing. Budget credits for real
work (logging evidence, running cycles) rather than idle chat, and upgrade only if you genuinely want the
Attentive/Proactive daily-coaching behavior — the free Lean Canvas builder needs no card.