Skip to content
Back to search

plaid

SkillWorks with Claude CodeGitHub

Product Led AI Development — guides founders from idea to launched product. Six capabilities: Idea (discover a product idea), Validate (pressure-test the idea against fatal flaws, problem reality, competition, and 2-week MVP feasibility), Plan (vision intake + document generation), Design (translate image references into a design.md spec), Launch (go-to-market strategy), and Build (roadmap execution). Use when someone says "PLAID", "plaid idea", "help me find an idea", "product idea", "idea from my business", "idea from my expertise", "plaid validate", "validate my idea", "pressure-test", "is this idea good", "find fatal flaws", "validate the problem", "plan a product", "define my vision", "generate a PRD", "product strategy", "plaid design", "design from image", "translate image to design", "create design.md", "extract design tokens", "plaid launch", "go-to-market", "launch plan", "GTM strategy", "launch playbook", "plaid build", "build the app", "start building", or "execute the roadmap".

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/buildgreatproducts--plaid/badge.svg)](/listings/buildgreatproducts--plaid)

HTML

<a href="/listings/buildgreatproducts--plaid"><img src="/api/listings/buildgreatproducts--plaid/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

If you prefer to install manually:

1. Open your Claude Code settings (either project-level `.claude/settings.json` or user-level `~/.claude/settings.json`) 2. Add the path to the skill under the `skills` array:

{
  "skills": [
    "/absolute/path/to/plaid/SKILL.md"
  ]
}

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 79 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ---
  2. name: plaid
  3. description: |
  4. Product Led AI Development — guides founders from idea to launched product.
  5. Six capabilities: Idea (discover a product idea), Validate (pressure-test
  6. the idea against fatal flaws, problem reality, competition, and 2-week MVP
  7. feasibility), Plan (vision intake + document generation), Design (translate
  8. image references into a design.md spec), Launch (go-to-market strategy),
  9. and Build (roadmap execution). Use when someone says "PLAID", "plaid idea",
  10. "help me find an idea", "product idea", "idea from my business",
  11. "idea from my expertise", "plaid validate", "validate my idea",
  12. "pressure-test", "is this idea good", "find fatal flaws",
  13. "validate the problem", "plan a product", "define my vision",
  14. "generate a PRD", "product strategy", "plaid design", "design from image",
  15. "translate image to design", "create design.md", "extract design tokens",
  16. "plaid launch", "go-to-market", "launch plan", "GTM strategy",
  17. "launch playbook", "plaid build", "build the app", "start building",
  18. or "execute the roadmap".
  19. license: MIT
  20. metadata:
  21. author: plaid-dev
  22. version: "2.0"
  23. compatibility: Requires file system access to write docs/ directory.
  24. ---
  25. ## Overview
  26. PLAID helps founders go from idea to launched product through structured conversations and AI-powered document generation. The full pipeline is: **Idea → Validate → Plan → Launch → Build.** Validate is optional but strongly recommended — it pressure-tests the idea before the founder commits to the full vision intake. Design is a side capability that can run at any point — typically alongside Plan or before Build — to translate image references into a `docs/design.md` token spec.
  27. ## Shared Context
  28. You are a product development advisor. You are warm, direct, and opinionated. You treat the founder as capable and smart — you're here to help them articulate what's already in their head, not to lecture them.
  29. **Validation rule:** Before generating any documents from `vision.json`, always validate first by running `node scripts/validate-vision.js --migrate`. The `--migrate` flag automatically upgrades older schema versions. If validation fails after migration, report errors and fix them before proceeding.
  30. **Resumability:** PLAID is designed to be interrupted and resumed at any point. Always check the current project state before starting work — does `vision.json` exist? Are docs present? What's the roadmap progress? Pick up from where things left off.
  31. ## Routing
  32. Determine which capability the user needs based on their request, then read the appropriate reference file and follow its instructions:
  33. | User Intent | Reference File |
  34. |---|---|
  35. | "plaid idea", "help me find an idea", "product idea", "idea from my business", "idea from my expertise", "what should I build" | `references/idea.md` |
  36. | "plaid validate", "validate my idea", "pressure-test", "is this idea good", "find fatal flaws", "validate the problem", "stress test my idea" | `references/validate.md` |
  37. | "PLAID", "plan a product", "define my vision", "generate a PRD", "plan my app", "spec out my idea", "product strategy", "help me build something" | `references/plan.md` |
  38. | "plaid design", "design from image", "translate image to design", "create design.md", "image to design system", "extract design tokens", "design system from screenshot" | `references/design.md` |
  39. | "plaid launch", "go-to-market", "launch plan", "GTM strategy", "help me launch", "marketing plan", "launch playbook" | `references/launch.md` |
  40. | "plaid build", "build the app", "start building", "execute the roadmap", "build phase", "continue building" | `references/build.md` |
  41. ### Auto-detection
  42. If the request is ambiguous, check the project state to determine the right capability:
  43. - No `docs/product-idea.md` AND no `vision.json` → offer Idea (with Plan as a direct alternative if they already know what they want to build)
  44. - `docs/product-idea.md` exists but no `docs/validation-report.md` AND no `vision.json` → suggest Validate (with Plan as a fast-forward if the founder is confident)
  45. - `docs/product-idea.md` and `docs/validation-report.md` exist but no `vision.json` → route to Plan (using `docs/product-idea.md` as pre-filled context)
  46. - No `vision.json` → route to Plan
  47. - `vision.json` exists but `docs/` is incomplete → route to Plan (document generation mode)
  48. - All docs exist but no code built yet → suggest Launch or Build
  49. - `docs/product-roadmap.md` has unchecked tasks → route to Build
  50. - User shares an image, screenshot, or Figma URL with no other clear intent → offer Design
  51. Design is image-triggered and orthogonal to the main pipeline — it does not require any other PLAID document. Route to it whenever the founder's intent centers on translating visual references into a design system, regardless of pipeline state.
  52. If still ambiguous after checking state, ask one clarifying question before loading a reference file.
  53. ### Phase Transitions
  54. When a capability completes, suggest the natural next step. If the user progresses naturally from one capability to the next during a session (e.g., finishes idea discovery and says "now let's plan"), load the next reference file and continue without requiring re-invocation.
  55. - After Idea completes → suggest Validate (`/plaid validate`) to pressure-test before planning; Plan (`/plaid`) is a valid fast-forward if the founder is confident
  56. - After Validate completes with a Strong verdict → suggest Plan (`/plaid`); `docs/product-idea.md` was sharpened during validation and pre-fills much of the vision intake
  57. - After Validate completes with a Pivot verdict → re-run Validate against the pivoted framing, or return to Idea (`/plaid idea`) to rework candidates
  58. - After Validate completes with a Weak verdict → recommend more discovery before Plan; do not advance automatically
  59. - After Plan completes → suggest Design (`/plaid design`) if the founder has imagery to anchor on, then launching (`/plaid launch`) or building (`/plaid build`)
  60. - After Design completes → if `docs/prd.md` does not yet exist, suggest Plan (`/plaid plan`); if it does, suggest Build (`/plaid build`)
  61. - After Launch completes → suggest building (`/plaid build`)
  62. - After Build completes → suggest launching (`/plaid launch`) if not done already
README.md · README · 267 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ```
  2. ██████╗ ██╗ █████╗ ██╗ ██████╗
  3. ██╔══██╗ ██║ ██╔══██╗ ██║ ██╔══██╗
  4. ██████╔╝ ██║ ███████║ ██║ ██║ ██║
  5. ██╔═══╝ ██║ ██╔══██║ ██║ ██║ ██║
  6. ██║ ███████╗██║ ██║ ██║ ██████╔╝
  7. ╚═╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ ╚═════╝
  8. ```
  9. # PLAID — Product Led AI Development
  10. An agent skill that guides founders from idea to launched product through structured conversations and AI-powered document generation. PLAID combines the thinking of a product strategist, brand strategist, UX researcher, design director, technical architect, and go-to-market specialist into a single skill with six capabilities.
  11. ## Capabilities
  12. PLAID is a single skill with six capabilities, each handling a distinct phase of the product development pipeline:
  13. | Capability | Trigger | What It Does | Output |
  14. |---|---|---|---|
  15. | **Idea** | "plaid idea", "help me find an idea", "what should I build" | Guided discovery of a product idea from business processes or personal expertise | `docs/product-idea.md` |
  16. | **Validate** | "plaid validate", "validate my idea", "pressure-test", "is this idea good" | Brutally pressure-tests the chosen idea — fatal flaws, problem reality, competition, first 10 customers, 2-week MVP test, strong/weak/pivot verdict. Asks targeted follow-up questions to confirm direction, then sharpens `docs/product-idea.md`. | `docs/validation-report.md`, sharpened `docs/product-idea.md` |
  17. | **Plan** | "PLAID", "plan a product", "define my vision", "generate a PRD" | Vision intake conversation + document generation | `vision.json`, `product-vision.md`, `prd.md`, `product-roadmap.md` |
  18. | **Design** | "plaid design", "design from image", "create design.md", "image to design system" | Translates image references (screenshots, mockups, Figma URLs) into a [Google design.md](https://github.com/google-labs-code/design.md) token spec + prose rationale | `docs/design.md` |
  19. | **Launch** | "plaid launch", "go-to-market", "launch plan", "GTM strategy" | Go-to-market plan generation | `gtm.md` |
  20. | **Build** | "plaid build", "build the app", "start building" | Executes roadmap phase by phase, reviews code, commits to git | Working code, git commits per phase |
  21. ## How It Works
  22. ### 1. Idea
  23. Start here if you don't yet have a concrete product concept. PLAID Idea walks you through a stepped conversation that mines a great idea from what you already know or already do.
  24. 1. **Source selection** — Business, personal expertise, or both
  25. 2. **Context capture** — 8 targeted questions (or 10 combined, trimmed) surfacing workflows, unmet demand, unfair advantages, and obsessions
  26. 3. **Pattern synthesis** — 3–5 ranked candidate directions drawn directly from your answers
  27. 4. **Scorecard** — Each candidate scored on unfair advantage, pain level, audience reachability, MVP feasibility, and differentiation
  28. 5. **Pick one** — Opinionated recommendation you can accept, swap, or blend
  29. 6. **Sharpen** — Target user, specific problem, smallest testable version, why you, and top risky assumptions
  30. 7. **Output** — `docs/product-idea.md`
  31. `docs/product-idea.md` feeds directly into Validate (recommended next step) and Plan — most of the Plan intake's first three sections are already answered.
  32. ### 2. Validate
  33. Pressure-test the chosen idea before investing in Plan, Build, or Launch. Validate adapts the [Startup Pressure Test](https://github.com/BuildGreatProducts/product-masters_validate) framework into PLAID's flow.
  34. 1. **Read or gather** — If `docs/product-idea.md` exists, Validate reads it and confirms the direction. If not, it asks for the idea, target customer, and what you want them to do or pay for.
  35. 2. **Find the core assumption** — One sentence: the single thing that must be true for the business to work.
  36. 3. **Surface fatal flaws** — Up to 3, ranked by severity, each with a fast behavioral test.
  37. 4. **Test problem reality** — Vitamin or painkiller verdict, in the user's own language.
  38. 5. **Map real competition** — Including current behavior (always a competitor) and the real enemy you have to displace.
  39. 6. **Plan the first 10 customers** — Manual outreach, no ads, no automation. Where they are, how to reach them, what success looks like.
  40. 7. **Define a 2-week MVP test** — The smallest thing that tests the core assumption with real users.
  41. 8. **Score and verdict** — A 6-axis scorecard (pain intensity, buyer clarity, urgency, differentiation, speed to validate, founder advantage) and a direct strong / weak / pivot verdict.
  42. 9. **Direction check** — Before touching `docs/product-idea.md`, Validate surfaces the directional calls the findings imply (tighter target user, reframed problem statement, different MVP shape, pivot vs. stay) and asks you to choose. Only the choices you confirm get applied.
  43. 10. **Sharpen the idea** — Validate applies the agreed edits to `docs/product-idea.md` (target user, problem statement, MVP shape, risky assumptions) and tells you what changed. The `Candidates considered` section is preserved.
  44. 11. **Output** — `docs/validation-report.md` (the full diagnosis, preserved for the record) and updated `docs/product-idea.md`.
  45. The validation scorecard sits **alongside** the Idea capability's candidate scorecard. Idea ranks 3–5 candidate directions; Validate stress-tests the chosen one. Both are kept.
  46. ### 3. Plan
  47. Start here. PLAID Plan guides you through a structured vision intake conversation, then generates three product documents.
  48. **Vision Intake** — An interactive conversation that captures your product idea through 8 sections:
  49. 1. **About You** — Name, expertise, and background story
  50. 2. **Your Purpose** — Who you help, the problem you solve, the transformation you deliver, and why you're the right person to build it
  51. 3. **Your Product** — Name, one-liner, how it works, key capabilities, platform (web/mobile/desktop/cross-platform), differentiation, and magic moment
  52. 4. **Your Audience** — Primary user persona, secondary users, current alternatives, and frustrations with existing solutions
  53. 5. **Business Intent** — Revenue model, 90-day goals, 6-month vision, constraints, and go-to-market approach
  54. 6. **The Feeling** — Brand personality, visual mood, tone of voice, and anti-patterns (what the product should never feel like)
  55. 7. **Tech Stack** — Frontend, backend, database, auth, and payments choices with comparison data and recommendations
  56. 8. **Tooling** — Which coding agent will execute the build
  57. For each question, PLAID generates 3 tailored suggestions based on your previous answers. You can pick one, modify it, or write your own. All answers are saved to `vision.json` in the project root.
  58. **Document Generation** — Reads `vision.json` and produces three documents in `docs/`:
  59. | Document | Purpose | Audience |
  60. |---|---|---|
  61. | `product-vision.md` | Strategic foundation — vision, mission, brand, user research, product strategy, design direction | Founders, designers, stakeholders |
  62. | `prd.md` | Technical specification — architecture, data models, API specs, user stories, requirements, design system, auth/payments setup | Coding agents, developers |
  63. | `product-roadmap.md` | Phased build plan with checkbox-tracked tasks for sequential execution | Coding agents, project managers |
  64. ### 4. Design
  65. Translates an image — or a set of image references — into a structured `docs/design.md` file following [Google's open design.md format](https://github.com/google-labs-code/design.md). Standalone — does not require any other PLAID document, but pairs naturally with `product-vision.md` and `prd.md`.
  66. 1. **Image intake** — Share screenshots, mockups, Figma URLs (read via the Figma MCP), or live website references. Multiple images are supported; identify the primary anchor.
  67. 2. **Image analysis** — PLAID describes what's actually in the imagery: colors with approximate hex values, typography character, spacing density, shape language, elevation philosophy, components visible, and overall mood.
  68. 3. **Context questions** — A short interactive pass: emotional tone, audience and context of use, color role assignments, type scale, density, shape language, elevation, component priorities, and anti-patterns. Each question gets 3 tailored suggestions.
  69. 4. **Token derivation** — Synthesizes a YAML block with `colors`, `typography`, `rounded`, `spacing`, and `components` per the design.md spec. Variants like hover and pressed are separate component entries.
  70. 5. **Prose drafting** — Writes the eight canonical sections in order: Overview, Colors, Typography, Layout, Elevation & Depth, Shapes, Components, Do's and Don'ts. Prose explains the *why* behind the tokens.
  71. 6. **Output** — `docs/design.md` — front matter for coding agents, prose for design rationale.
  72. | Document | Purpose | Audience |
  73. |---|---|---|
  74. | `docs/design.md` | Design system spec — YAML tokens (colors, typography, spacing, rounded, components) with prose rationale for each section | Coding agents, designers |
  75. ### 5. Launch
  76. Generates your go-to-market playbook. Requires `vision.json` and `docs/product-vision.md` from the Plan capability.
  77. | Document | Purpose | Audience |
  78. |---|---|---|
  79. | `gtm.md` | Go-to-market plan — launch strategy, pre-launch playbook, channel strategy, growth tactics, metrics | Founders, marketing |
  80. ### 6. Build
  81. Executes the roadmap phase by phase. Requires `docs/product-roadmap.md` and `docs/prd.md` from the Plan capability.
  82. 1. Reads the roadmap and finds the first phase with incomplete tasks
  83. 2. Builds each task in order, referencing the PRD for implementation details
  84. 3. Marks tasks complete as it goes (`- [x]`)
  85. 4. Reviews code after each phase for bugs and inconsistencies
  86. 5. Commits to git after each phase
  87. 6. Continues until all phases are complete
  88. Each phase produces a working, demoable product.
  89. ## Adding PLAID as a Skill
  90. PLAID is an AI agent skill. The quickest way to install it:
  91. ```sh
  92. npx skills add BuildGreatProducts/plaid
  93. ```
  94. This uses the [skills CLI](https://github.com/vercel-labs/skills) to install PLAID into your project automatically.
  95. ### Manual Installation
  96. If you prefer to install manually:
  97. 1. Open your Claude Code settings (either project-level `.claude/settings.json` or user-level `~/.claude/settings.json`)
  98. 2. Add the path to the skill under the `skills` array:
  99. ```json
  100. {
  101. "skills": [
  102. "/absolute/path/to/plaid/SKILL.md"
  103. ]
  104. }
  105. ```
  106. ### Using PLAID
  107. Start a new conversation with your AI coding agent and trigger PLAID:
  108. **Idea:** "plaid idea", "Help me find an idea", "What should I build", "Product idea from my business"
  109. **Validate:** "plaid validate", "Validate my idea", "Pressure-test", "Is this idea good", "Find fatal flaws"
  110. **Plan:** "PLAID", "Help me build something", "Plan a product", "Define my vision", "Generate a PRD", "Spec out my idea"
  111. **Design:** "plaid design", "Design from image", "Create design.md", "Image to design system", "Extract design tokens"
  112. **Launch:** "plaid launch", "Go-to-market plan", "Launch strategy", "GTM"
  113. **Build:** "plaid build", "Start building", "Execute the roadmap"
  114. PLAID automatically routes to the right capability based on your request. No dependencies need to be installed — the skill is entirely documentation-driven.
  115. ## What to Expect After Setup
  116. **Optional first session — Idea Discovery.** If you don't yet have a concrete product concept, start with `plaid idea`. PLAID walks you through a stepped conversation that mines an idea from your business or expertise, ranks candidates on a scorecard, and writes `docs/product-idea.md`. This becomes input to Validate and Plan.
  117. **Optional second session — Validation.** Once you have an idea, run `plaid validate` to pressure-test it. PLAID surfaces fatal flaws, tests whether the problem is real, maps competition (including current behavior), plans a 2-week MVP test, and returns a strong/weak/pivot verdict. Before updating `docs/product-idea.md`, it asks you targeted follow-up questions to confirm the direction the findings point at — narrower target user, reframed problem, different MVP shape, or a pivot — and only applies the choices you confirm. It writes `docs/validation-report.md` and sharpens `docs/product-idea.md` based on what you decided.
  118. **First (or third) session — Vision Intake.** PLAID opens with "What do you want to build?" and adapts based on how concrete your idea is. If you have a clear concept (or a `docs/product-idea.md`), it jumps into structured questions. If you're still exploring, it helps you narrow down before moving forward. At the end, you'll have a validated `vision.json` in your project root.
  119. **Second session — Document Generation.** When PLAID detects a `vision.json` but missing docs, it generates the three product documents: `product-vision.md`, `prd.md`, and `product-roadmap.md`.
  120. **Go-to-market.** Generate your launch playbook whenever you're ready. This can happen before or after building.
  121. **Building.** Execute the roadmap. PLAID Build reads the roadmap, builds each phase, reviews the code, and commits. You get a working product at the end of each phase.
  122. **Resuming at any point.** Each skill detects your current state automatically:
  123. - Partial intake? Continues from the next unanswered question
  124. - Missing docs? Generates only what's missing
  125. - Mid-build? Shows progress and picks up from the first unchecked task
  126. ## Editing Your Vision
  127. You can update your answers after the intake is complete:
  128. - **Change a single answer** — Tell PLAID what you want to change. It updates `vision.json` and flags which documents need regeneration.
  129. - **Regenerate docs** — Ask PLAID to regenerate specific documents. It re-reads `vision.json` and rebuilds from the source of truth.
  130. ## Project Structure
  131. ```
  132. plaid/
  133. ├── SKILL.md # Router — routes to capability files
  134. ├── references/ # Capability files + detailed guides
  135. │ ├── idea.md # Idea discovery — produces docs/product-idea.md
  136. │ ├── validate.md # Idea pressure-test — produces docs/validation-report.md
  137. │ ├── plan.md # Vision intake + 3-doc generation
  138. │ ├── design.md # Image-to-design.md translation
  139. │ ├── launch.md # Go-to-market plan generation
  140. │ ├── build.md # Roadmap execution + git commits
  141. │ ├── INTAKE-GUIDE.md # Full question bank with suggestion prompts
  142. │ ├── VISION-SCHEMA.md # TypeScript schema, field rules, examples
  143. │ ├── VISION-GENERATION.md # How product-vision.md is generated
  144. │ ├── PRD-GENERATION.md # How prd.md is generated
  145. │ ├── ROADMAP-GENERATION.md # How product-roadmap.md is generated
  146. │ ├── GTM-GENERATION.md # How gtm.md is generated
  147. │ └── TECH-STACK-OPTIONS.md # Comparison data for stack recommendations
  148. ├── scripts/
  149. │ └── validate-vision.js # Schema validator and migrator
  150. ├── assets/
  151. │ └── vision-template.json # Empty template for new vision files
  152. ├── README.md # This file
  153. ├── package.json # npm metadata and validate script
  154. └── LICENSE.txt # MIT license
  155. ```
  156. The `references/` directory contains capability files and detailed guides. You don't need to read these to use PLAID, but they're useful if you want to understand or customize how documents are generated.
  157. ## Validator
  158. The included validator checks that `vision.json` conforms to the expected schema:
  159. ```sh
  160. # Validate (read-only)
  161. node scripts/validate-vision.js
  162. # Validate a specific file
  163. node scripts/validate-vision.js path/to/vision.json
  164. # Validate and migrate older schema versions
  165. node scripts/validate-vision.js --migrate
  166. ```
  167. Or via npm:
  168. ```sh
  169. npm run validate
  170. ```
  171. Output is JSON:
  172. ```json
  173. {
  174. "valid": true,
  175. "errors": [],
  176. "warnings": ["audience.secondaryUsers is empty"],
  177. "migrated": false,
  178. "migrationsApplied": []
  179. }
  180. ```
  181. The validator uses only built-in Node.js modules and has zero external dependencies. Node.js 14 or later is required.
  182. ## Tech Stack Defaults
  183. PLAID recommends specific stacks based on your platform and needs, but respects whatever you choose. The defaults lean toward:
  184. - **Web**: Next.js + Convex + Clerk + Polar
  185. - **Mobile**: Expo (React Native) + Convex + Convex Auth + RevenueCat
  186. - **Desktop**: Electron + Convex + Clerk
  187. Full comparison data for all supported options (including Remix, SvelteKit, Flutter, Supabase, Stripe, and more) is available in `references/TECH-STACK-OPTIONS.md`.
  188. ## License
  189. MIT — see [LICENSE.txt](LICENSE.txt).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.