# Validation Canvas

> >

- **Type:** Skill
- **Install:** `agentstack add skill-sorawit-w-agent-skills-validation-canvas`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [sorawit-w](https://agentstack.voostack.com/s/sorawit-w)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [sorawit-w](https://github.com/sorawit-w)
- **Source:** https://github.com/sorawit-w/agent-skills/tree/main/skills/validation-canvas

## Install

```sh
agentstack add skill-sorawit-w-agent-skills-validation-canvas
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Validation Canvas

Produce a rigorous **Lean Canvas + Value Proposition Canvas** combined artifact from
founder inputs. Each block is a stress-tested *belief*, not a template field. The
canvas is the primary deliverable; the interview that produces it is where most of
the value lives. The job here is declarative — *what do we believe?* — and is the
upstream half of validation. The downstream half (*what have we proven?*) is owned
by the `riskiest-assumption-test` skill that runs after this one.

## What this skill produces

Always produced under the resolved canvas root (see Phase 0.0 for path
resolution; default is `docs/canvas/` for solo runs,
`docs/startup-kit/canvas/` when invoked via orchestrator):

1. **`validation-canvas.md`** — canonical, editable Markdown with two top-level
   sections: `## Lean Canvas` (nine blocks per Maurya) and `## Value Proposition
   Canvas` (six blocks per Osterwalder), plus a `## Stress Tests` section listing
   the assumptions most likely to fail. Headings are load-bearing — `pitch-deck`,
   `riskiest-assumption-test`, and `startup-grill` grep them by name.
2. **`validation-canvas.html`** — single self-contained HTML file rendering the
   Lean Canvas grid (top) and the VPC fit diagram (bottom) visually. Opens in any
   browser, prints cleanly to PDF, zero network dependencies.

Both files carry the same content — the HTML is the visual primary; the Markdown is
the source of truth founders edit as the business evolves.

## What this skill is NOT

- **Not a 9-block Osterwalder Business Model Canvas.** That's a Series-A operating
  plan tool. This skill ships the Lean Canvas (Maurya) — Problem, Customer Segments,
  UVP, Solution, Channels, Revenue Streams, Cost Structure, Key Metrics, Unfair
  Advantage — because that's the right altitude for an idea-stage founder. If a
  board or grant explicitly requires the Osterwalder grid (Key Resources, Key
  Activities, Key Partners, Customer Relationships), use `team-composer` with
  `@startup_strategist` for a discussion-grade fill.
- **Not an assumption-testing skill.** Naming what you believe is half the job.
  Naming what you've *proven* is `riskiest-assumption-test`'s job — a separate
  step that runs after this one. Do not bundle the two.
- **Not a pitch deck builder.** Pitch construction belongs to `pitch-deck`.
- **Not a financial model.** Revenue Streams and Cost Structure are *structural*
  (how money flows), not *quantitative* (how much and when).
- **Not market research.** The canvas records the founder's current thinking. It
  does not go validate it. Validation is the next step.
- **Not a competitive-analysis skill.** SWOT, Porter's Five Forces, and Wardley
  mapping are explicitly out of scope — wrong altitude / wrong stage / overlap
  with `startup-grill`.
- **Not a substitute for domain expertise.** In regulated domains (fintech, health,
  education with minors), the canvas surfaces the right questions but does not
  answer regulatory ones — escalate to `team-composer` with
  `@legal_compliance_advisor`.

## Skill Boundaries

This skill intentionally overlaps with `team-composer` (`@startup_strategist` is
active there too) but differs in deliverable:

- **Use `validation-canvas` when:** the founder wants a *persistent artifact* they
  can return to, edit, and share. The Lean Canvas + VPC structure is the
  load-bearing feature.
- **Use `team-composer` with `@startup_strategist` when:** the founder wants a
  *discussion* on one narrow question (pricing model, channel strategy, partner
  selection) without committing to a full canvas. Discussion-grade, not
  artifact-grade.

> **Companion plugin:** `brand-workshop`. If a brand artifact exists at
> `/DESIGN.md` per the conventions doc, the HTML canvas adopts
> the brand's color tokens from it. If not, falls back to neutral defaults.
>
> **Design token spec:** `DESIGN.md` follows the [Google Labs spec](https://github.com/google-labs-code/design.md) (version: alpha, current as of 2026-05). Read `colors.primary` from the YAML front matter at the top of the file to extract the brand's primary color for `--canvas-accent`.

> **Pipeline placement.** This skill is step 2 of 5 in the startup pipeline:
> `brand-workshop` → **`validation-canvas`** → `riskiest-assumption-test` →
> `pitch-deck` → `startup-grill`. See [`references/folder-contract.md`](references/folder-contract.md)
> for the inter-step contract, gate weights, and loop-back protocol.

---

## The Two Canvases

Claude must internalize the structure of both canvases before interviewing.

### Lean Canvas (Maurya) — nine blocks

The right altitude for an idea-stage founder. Replaces BMC's Key Activities / Key
Resources / Key Partners / Customer Relationships with **Problem**, **Solution**,
**Key Metrics**, and **Unfair Advantage** — the things that actually decide
whether the idea survives contact with reality.

```
┌───────────────────┬──────────────────┬──────────────────┬──────────────────┬───────────────────┐
│ Problem           │ Solution         │ Unique Value     │ Unfair Advantage │ Customer          │
│                   │                  │ Proposition      │                  │ Segments          │
│ (top 3 problems)  │ (top 3 features) │ (single, clear,  │ (can't be easily │ (target users     │
│                   │                  │  compelling)     │  copied/bought)  │  + early adopters)│
│                   ├──────────────────┤                  ├──────────────────┤                   │
│                   │ Key Metrics      │                  │ Channels         │                   │
│                   │ (key activities  │                  │ (path to         │                   │
│                   │  measured)       │                  │  customers)      │                   │
├───────────────────┴──────────────────┴──────────────────┴──────────────────┴───────────────────┤
│ Cost Structure                                  │ Revenue Streams                              │
└─────────────────────────────────────────────────┴──────────────────────────────────────────────┘
```

### Value Proposition Canvas (Osterwalder) — six blocks, two sides

Forces alignment between *what the customer needs* (Customer Profile) and *what
you offer* (Value Map). Run as a second pass after the Lean Canvas.

```
       Customer Profile (right circle)              Value Map (left square)
     ┌──────────────────────────────┐         ┌──────────────────────────────┐
     │  Customer Jobs               │         │  Products & Services         │
     │  (functional, social,        │  ◄───►  │  (the offering)              │
     │   emotional jobs)            │         │                              │
     ├──────────────────────────────┤         ├──────────────────────────────┤
     │  Pains                       │  ◄───►  │  Pain Relievers              │
     │  (frustrations, obstacles,   │         │  (how the offering reduces   │
     │   risks)                     │         │   each pain)                 │
     ├──────────────────────────────┤         ├──────────────────────────────┤
     │  Gains                       │  ◄───►  │  Gain Creators               │
     │  (outcomes, benefits         │         │  (how the offering produces  │
     │   sought)                    │         │   each gain)                 │
     └──────────────────────────────┘         └──────────────────────────────┘
                                  Fit Check
```

**Fit check:** for each Pain, name the Pain Reliever. For each Gain, name the Gain
Creator. Pains without relievers and Gains without creators are red flags — they
belong in Stress Tests.

See `references/canvas-blocks.md` for the deep definition of each block, canonical
examples, and the stress tests that surface shaky assumptions.

---

## Phase 0: Experience-Adaptive Intake (RUN FIRST, BEFORE ANY CANVAS WORK)

**Goal:** calibrate the rigor and tone of the interview to the founder's actual
experience level. A first-time founder needs definitions and examples; a repeat
founder needs push-back, not teaching.

### Step 0.0 — Path resolution + manifest awareness (v2.2.0+)

**Resolve the canvas root** once at invocation, in this precedence order
(canonical chain):

1. **Explicit `output_dir` arg** (passed by `startup-launch-kit`) → use as-is.
2. **`STARTUP_KIT_DOCS_ROOT` env var** set → `${STARTUP_KIT_DOCS_ROOT}/canvas/`.
3. **Smart default — `docs/startup-kit/` exists** → `docs/startup-kit/canvas/`.
   Surface the smart-default notice: *"Writing to `docs/startup-kit/canvas/`
   (smart default — `docs/startup-kit/` exists). Set
   `STARTUP_KIT_DOCS_ROOT=./docs` to write standalone instead."*
4. **Solo fallback** → `docs/canvas/`.

**Manifest awareness.** Look for `kit-manifest.json` at
`/kit-manifest.json` first (e.g.,
`docs/startup-kit/kit-manifest.json`); fall back to the working-directory
root for backward compat. If found at the legacy path, surface a one-line
migration suggestion. Use it as a hint, never as a bypass:

- **Intake-cache (special case for this skill):** if the manifest's
  `intake_answers` cache is populated (the orchestrator already asked the
  3-question intake), present the cached answers and **ask the founder to
  confirm or update them** — do **NOT** silently skip Step 0.1. Single code
  path through Phase 0; manifest is a hint that lets you start with defaults.
  Example prompt: *"Manifest says: repeat founder, no domain experience, has
  segment experience → focused mode. Confirm, or update any of these?"*
- If the manifest lists `validation-canvas` as `completed` with a recent
  mtime, surface that fact: *"Manifest says you ran validation-canvas on
  [date]. Update mode (revise specific blocks per loop-back protocol),
  fresh run, or skip to the next step?"*
- **Existing-canvas branch.** If a `validation-canvas.md` already exists,
  inspect its top for the **machine-inferred seed marker** — the HTML comment
  `` that `startup-audit` writes at the head of a
  seed (defined in `startup-audit/references/inference-mapping.md`). Present →
  route to **Confirm-inferred-seed mode**; absent (founder-authored) → route to
  **Update mode**. See "Which mode?" below.
- Manifest read failures (corrupt JSON, missing fields) are non-fatal — log
  the issue inline and proceed as if no manifest exists.

After this skill ships its artifacts (Phase 3 — render & ship), if a
manifest exists, append/update this skill's entry. Use atomic write (write
`.tmp`, then rename). Increment the `iterations` counter on update-mode
runs. If the manifest doesn't exist, do **NOT** create it — that's the
`startup-launch-kit` orchestrator's job. See
[`startup-launch-kit/references/manifest-schema.md`](../startup-launch-kit/references/manifest-schema.md)
for the schema.

### Step 0.1 — Scan context for experience signals

Before asking any calibration questions, scan the conversation context, working
directory, and any provided materials for signals on three dimensions:

1. **Founding history.** Has the founder run a startup that reached paying
   customers? Look for: prior `validation-canvas.md` files, memory entries,
   explicit statements ("at my last startup…"), LinkedIn-style language ("3rd
   time founder", "ex-Stripe").
2. **Domain experience.** Has the founder worked professionally in this idea's
   domain? Look for: stated work history, technical depth in the idea description,
   industry-specific vocabulary used naturally.
3. **Customer-segment experience.** Does the founder have direct experience with
   the customer they're targeting? Look for: "I am the customer" framings,
   anecdotes from the segment, prior roles inside the segment.

### Step 0.2 — Ask only the delta

For each of the three dimensions:

- **Clear signal** → use it silently. Do not ask the question.
- **Ambiguous or missing signal** → ask the question.

The three calibration questions, asked verbatim when needed:

1. *"Have you founded or co-founded a startup that reached paying customers
   before?"*
2. *"Is this idea in a domain you've worked in professionally?"*
3. *"Do you have direct experience with this customer segment?"*

**Hard rule — ask immediately at invocation, BEFORE canvas work begins.** Never
ask mid-canvas. Never ask post-canvas. Calibration is a Phase 0 gate; commit to
the inferred mode and adjust through behavior.

### Step 0.3 — Map answers to mode

The three answers form a 2×2×2 matrix. Map to one of three modes:

| Founding history | Domain | Customer | Mode |
|---|---|---|---|
| No | No | Either | **Guided** (full walkthrough, definitions, ~60–90 min) |
| No | Yes | Either | **Focused** (lighter scaffolding, emphasize underweighted boxes) |
| Yes | Yes | Either | **Compressed-with-Challenge** (rapid-fill ~15–20 min, push back hard) |
| Yes | No | Either | **Focused** (founder knows process, needs domain scaffolding) |
| No | No | Yes | **Focused** (founder knows the customer, needs structural scaffolding) |
| Yes | Yes | Yes | **Compressed-with-Challenge** (push back hardest — risk of pattern-matching from prior) |

**Mode descriptions:**

- **Guided** — full walkthrough. Define each block before asking. Offer 2–3
  examples per block from `references/canvas-blocks.md`. Ask 2–3 questions per
  block. Pace: ~60–90 minutes for a first pass.
- **Focused** — lighter scaffolding. Skip definitions for blocks the founder
  clearly understands. Emphasize commonly underweighted boxes: **channels** and
  **cost structure** for ex-engineers; **key metrics** and **customer segments**
  for ex-designers; **unfair advantage** and **problem** for ex-PMs. Pace:
  ~30–45 minutes.
- **Compressed-with-Challenge** — rapid-fill. The skill's job shifts from
  teaching to *challenging*. Accept short answers but push back on glib ones.
  Pace: ~15–20 minutes.

### Step 0.4 — Confirm mode in one line

Before proceeding to canvas work, confirm the inferred mode in **one line** so the
founder can correct you. Examples:

- *"Treating this as a repeat-founder session — say so if I should slow down."*
- *"You haven't worked in this segment before, so I'll spend more time on the
  Customer Profile — say so if you want me to skip ahead."*
- *"First-pass guided mode. I'll define each block as we go. Stop me anytime."*

Then proceed to Phase 1.

### Hard rules for Phase 0

- **Never delegate intake to `grill-with-docs`.** That skill is for stress-testing
  plans against project docs — wrong job, wrong tone, wrong target for founder
  calibration.
- **Mode sets default rigor; observed answer quality overrides it.** A
  self-declared "repeat founder" giving glib answers gets push-back regardless of
  declared mode. The 3-question intake calibrates the *opening posture*, not a
  permanent contract.
- **One sharp exception** — a repeat founder doing a *near-identical* startup to
  a prior one (same segment, same UVP, just a different brand) can skim the
  canvas. Flag this as the exception, not the norm: *"You've shipped this canvas
  before for a similar idea — I'll move fast and only stop on real deltas."*

---

## Phase 1: Discovery (Founder Interview)

**Goal:** Extract enough raw material to fill each block substantively. A canvas
filled with "freelancers and small businesses" in Customer Segments is worthless
— the job is to force specificity.

### Role setup

Run the interview in first-person voice with these roles active. If the user
invokes `team-composer` separately, skip duplicates.

| Role | Lens |
|------|------|
| `@startup_strategist` | Workshop lead. Asks block-by-block. Pushes for specificity and internal consistency. |
| `@vc_partner` | Read-test. "Could a Series A partner understand this in 90 seconds?" Flags handwaving on Revenue / Traction adjacency. |
| `@finance_manager` | Stress-tests Revenue Streams and Cost Structure. Flags missing unit economics or undefined payment triggers. |
| `@senior_product_manager` | UVP ↔ Customer Segment alignment. Flags "value props" that are really feature lists. |

### Le

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [sorawit-w](https://github.com/sorawit-w)
- **Source:** [sorawit-w/agent-skills](https://github.com/sorawit-w/agent-skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-sorawit-w-agent-skills-validation-canvas
- Seller: https://agentstack.voostack.com/s/sorawit-w
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.