██████╗  ██╗      █████╗  ██╗ ██████╗
██╔══██╗ ██║     ██╔══██╗ ██║ ██╔══██╗
██████╔╝ ██║     ███████║ ██║ ██║  ██║
██╔═══╝  ██║     ██╔══██║ ██║ ██║  ██║
██║      ███████╗██║  ██║ ██║ ██████╔╝
╚═╝      ╚══════╝╚═╝  ╚═╝ ╚═╝ ╚═════╝

PLAID — Product Led AI Development

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 seven capabilities.

Capabilities

PLAID is a single skill with seven capabilities, each handling a distinct phase of the product development pipeline:

Capability	Trigger	What It Does	Output
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
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
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
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 token spec + prose rationale	docs/design.md
Launch	"plaid launch", "go-to-market", "launch plan", "GTM strategy"	Go-to-market plan generation	gtm.md
Build	"plaid build", "build the app", "start building"	Executes roadmap phase by phase, reviews code, commits to git	Working code, git commits per phase
Reverse Engineer	"plaid reverse", "reverse engineer this project", "generate a PRD from this repo", "document this existing app"	Starts from an existing codebase and reconstructs PLAID-compatible product docs from code evidence	docs/codebase-audit.md, vision.json, docs/product-vision.md, docs/prd.md, docs/product-roadmap.md

How It Works

1. Idea

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.

1. Source selection — Business, personal expertise, or both
2. Context capture — 8 targeted questions (or 10 combined, trimmed) surfacing workflows, unmet demand, unfair advantages, and obsessions
3. Pattern synthesis — 3–5 ranked candidate directions drawn directly from your answers
4. Scorecard — Each candidate scored on unfair advantage, pain level, audience reachability, MVP feasibility, and differentiation
5. Pick one — Opinionated recommendation you can accept, swap, or blend
6. Sharpen — Target user, specific problem, smallest testable version, why you, and top risky assumptions
7. Output — docs/product-idea.md

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.

2. Validate

Pressure-test the chosen idea before investing in Plan, Build, or Launch. Validate adapts the Startup Pressure Test framework into PLAID's flow.

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.
2. Find the core assumption — One sentence: the single thing that must be true for the business to work.
3. Surface fatal flaws — Up to 3, ranked by severity, each with a fast behavioral test.
4. Test problem reality — Vitamin or painkiller verdict, in the user's own language.
5. Map real competition — Including current behavior (always a competitor) and the real enemy you have to displace.
6. Plan the first 10 customers — Manual outreach, no ads, no automation. Where they are, how to reach them, what success looks like.
7. Define a 2-week MVP test — The smallest thing that tests the core assumption with real users.
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.
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.
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.
11. Output — docs/validation-report.md (the full diagnosis, preserved for the record) and updated docs/product-idea.md.

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.

3. Plan

Start here. PLAID Plan guides you through a structured vision intake conversation, then generates three product documents.

Vision Intake — An interactive conversation that captures your product idea through 8 sections:

1. About You — Name, expertise, and background story
2. Your Purpose — Who you help, the problem you solve, the transformation you deliver, and why you're the right person to build it
3. Your Product — Name, one-liner, how it works, key capabilities, platform (web/mobile/desktop/cross-platform), differentiation, and magic moment
4. Your Audience — Primary user persona, secondary users, current alternatives, and frustrations with existing solutions
5. Business Intent — Revenue model, 90-day goals, 6-month vision, constraints, and go-to-market approach
6. The Feeling — Brand personality, visual mood, tone of voice, and anti-patterns (what the product should never feel like)
7. Tech Stack — Frontend, backend, database, auth, and payments choices with comparison data and recommendations
8. Tooling — Which coding agent will execute the build

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.

Document Generation — Reads vision.json and produces three documents in docs/:

Document	Purpose	Audience
product-vision.md	Strategic foundation — vision, mission, brand, user research, product strategy, design direction	Founders, designers, stakeholders
prd.md	Technical specification — architecture, data models, API specs, user stories, requirements, design system, auth/payments setup	Coding agents, developers
product-roadmap.md	Phased build plan with checkbox-tracked tasks for sequential execution	Coding agents, project managers

4. Design

Translates an image — or a set of image references — into a structured docs/design.md file following Google's open design.md format. Standalone — does not require any other PLAID document, but pairs naturally with product-vision.md and prd.md.

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.
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.
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.
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.
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.
6. Output — docs/design.md — front matter for coding agents, prose for design rationale.

Document	Purpose	Audience
docs/design.md	Design system spec — YAML tokens (colors, typography, spacing, rounded, components) with prose rationale for each section	Coding agents, designers

5. Launch

Generates your go-to-market playbook. Requires vision.json and docs/product-vision.md from the Plan capability.

Document	Purpose	Audience
gtm.md	Go-to-market plan — launch strategy, pre-launch playbook, channel strategy, growth tactics, metrics	Founders, marketing

6. Build

Executes the roadmap phase by phase. Requires docs/product-roadmap.md and docs/prd.md from the Plan capability.

1. Reads the roadmap and finds the first phase with incomplete tasks
2. Builds each task in order, referencing the PRD for implementation details
3. Marks tasks complete as it goes (- [x])
4. Reviews code after each phase for bugs and inconsistencies
5. Commits to git after each phase
6. Continues until all phases are complete

Each phase produces a working, demoable product.

7. Reverse Engineer

Starts from an existing codebase instead of a new idea. Reverse Engineer inspects the repository, treats the implementation as the source of truth, and generates PLAID-compatible documentation for the product that already exists.

1. Scope — Determines the target repo, output docs, language, and whether the docs should cover current state only or current state plus future recommendations
2. Codebase inventory — Reads README files, package metadata, routes, screens, APIs, data models, auth, payments, tests, styles, deployment config, and existing docs
3. Evidence map — Separates findings into Observed, Inferred, Unknown, and Recommended
4. Audit output — Writes docs/codebase-audit.md, the evidence ledger humans should review before trusting the generated PRD
5. Vision reconstruction — Creates a valid vision.json using the existing product as the source of truth
6. Document generation — Produces docs/product-vision.md, an as-built docs/prd.md, and a future-work docs/product-roadmap.md
7. Optional docs — Generates docs/design.md when the codebase has enough UI/design evidence, and docs/gtm.md when launch strategy is requested

Reverse Engineer is evidence-first. It should not invent features that are not present, and it should not create roadmap tasks to rebuild features that already exist.

Adding PLAID as a Skill

PLAID is an AI agent skill. The quickest way to install it:

npx skills add BuildGreatProducts/plaid

This uses the skills CLI to install PLAID into your project automatically.

Manual Installation

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"
  ]
}

Using PLAID

Start a new conversation with your AI coding agent and trigger PLAID:

Idea: "plaid idea", "Help me find an idea", "What should I build", "Product idea from my business"

Validate: "plaid validate", "Validate my idea", "Pressure-test", "Is this idea good", "Find fatal flaws"

Plan: "PLAID", "Help me build something", "Plan a product", "Define my vision", "Generate a PRD", "Spec out my idea"

Design: "plaid design", "Design from image", "Create design.md", "Image to design system", "Extract design tokens"

Launch: "plaid launch", "Go-to-market plan", "Launch strategy", "GTM"

Build: "plaid build", "Start building", "Execute the roadmap"

Reverse Engineer: "plaid reverse", "Reverse engineer this project", "Generate a PRD from this repo", "Document this existing app", "Create docs from an existing codebase"

PLAID automatically routes to the right capability based on your request. No dependencies need to be installed — the skill is entirely documentation-driven.

What to Expect After Setup

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.

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.

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.

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.

Go-to-market. Generate your launch playbook whenever you're ready. This can happen before or after building.

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.

Reverse engineering an existing project. Run plaid reverse from inside an existing codebase, or give PLAID the path to a target repo. It inspects the implementation and writes an evidence audit, vision.json, an as-built PRD, product vision, and a future-work roadmap. Review docs/codebase-audit.md first — anything marked Unknown should be confirmed before implementation work.

Resuming at any point. Each skill detects your current state automatically:

• Partial intake? Continues from the next unanswered question
• Missing docs? Generates only what's missing
• Mid-build? Shows progress and picks up from the first unchecked task

Editing Your Vision

You can update your answers after the intake is complete:

• Change a single answer — Tell PLAID what you want to change. It updates vision.json and flags which documents need regeneration.
• Regenerate docs — Ask PLAID to regenerate specific documents. It re-reads vision.json and rebuilds from the source of truth.

Project Structure

plaid/
├── SKILL.md                    # Router — routes to capability files
├── references/                 # Capability files + detailed guides
│   ├── idea.md                 # Idea discovery — produces docs/product-idea.md
│   ├── validate.md             # Idea pressure-test — produces docs/validation-report.md
│   ├── plan.md                 # Vision intake + 3-doc generation
│   ├── design.md               # Image-to-design.md translation
│   ├── launch.md               # Go-to-market plan generation
│   ├── build.md                # Roadmap execution + git commits
│   ├── reverse-engineering.md  # Existing codebase → PLAID docs
│   ├── INTAKE-GUIDE.md         # Full question bank with suggestion prompts
│   ├── VISION-SCHEMA.md        # TypeScript schema, field rules, examples
│   ├── VISION-GENERATION.md    # How product-vision.md is generated
│   ├── PRD-GENERATION.md       # How prd.md is generated
│   ├── ROADMAP-GENERATION.md   # How product-roadmap.md is generated
│   ├── GTM-GENERATION.md       # How gtm.md is generated
│   └── TECH-STACK-OPTIONS.md   # Comparison data for stack recommendations
├── scripts/
│   └── validate-vision.js      # Schema validator and migrator
├── assets/
│   └── vision-template.json    # Empty template for new vision files
├── README.md                   # This file
├── package.json                # npm metadata and validate script
└── LICENSE.txt                 # MIT license

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.

Validator

The included validator checks that vision.json conforms to the expected schema:

# Validate (read-only)
node scripts/validate-vision.js

# Validate a specific file
node scripts/validate-vision.js path/to/vision.json

# Validate and migrate older schema versions
node scripts/validate-vision.js --migrate

Or via npm:

npm run validate

Output is JSON:

{
  "valid": true,
  "errors": [],
  "warnings": ["audience.secondaryUsers is empty"],
  "migrated": false,
  "migrationsApplied": []
}

The validator uses only built-in Node.js modules and has zero external dependencies. Node.js 14 or later is required.

Tech Stack Defaults

PLAID recommends specific stacks based on your platform and needs, but respects whatever you choose. The defaults lean toward:

• Web: Next.js + Convex + Clerk + Polar
• Mobile: Expo (React Native) + Convex + Convex Auth + RevenueCat
• Desktop: Electron + Convex + Clerk

Full comparison data for all supported options (including Remix, SvelteKit, Flutter, Supabase, Stripe, and more) is available in references/TECH-STACK-OPTIONS.md.

License

MIT — see LICENSE.txt.