LaunchChair is a spec-driven Product and Feature workflow for founders and AI builders. Product projects take a new idea from validation through launch. Feature projects research, define, and build inside an existing product. Both produce a living spec, build cards, and agent-ready work.

Does LaunchChair work with Claude, Codex, Cursor, Grok, Gemini, and Kimi?

Yes. LaunchChair is designed to give coding agents such as Claude Code, Codex, Cursor, Grok, Gemini, Kimi, and similar build agents structured product context through spec-generated prompts, Agent API, and MCP workflows.

Spec-driven Product + Feature workflows

Stop prompting. Start shipping.

Q: Is LaunchChair just a prompt library?

No. LaunchChair is a phase-based prompt engine, living spec, and synthesis workflow. It compiles the next best prompt from the current project state, validates structured output, and saves decisions back into the project spec.

Q: Is LaunchChair an AI app builder?

LaunchChair is not a hosted one-prompt app builder. It is the product workflow and living spec layer around coding agents, helping founders validate the product, scope the MVP, create build cards, and give agents structured prompts.

Q: How is LaunchChair different from vibe coding?

Vibe coding starts from manually written prompts. LaunchChair first builds evidence and scope from ICP pain, complaint and delight themes, substitute behaviors, competitor gaps, wedge choice, screens, flows, acceptance criteria, and repo context. Product projects also carry positioning, pricing, and launch context.

Q: Are Agent API and MCP the core product?

No. Agent API and MCP are execution layers on top of LaunchChair's prompt engine and living spec. They let Codex, Claude, Cursor, Hermes, Grok, Kimi, Gemini, and local agents operate queueing, apply, validation, retry, remediation, and checkpoint flows.

Q: Can agents run the whole project automatically?

Agents can operate the loop through the API or MCP bridge, but LaunchChair pauses for real human checkpoints like SQL actions, external account authorization, and manual QA notes. Those pauses are part of the product boundary, not failures.

Q: What is the living spec?

The living spec is the central project state behind LaunchChair. Research, choices, positioning, pricing, MVP scope, screens, data model, build cards, landing copy, SEO, launch assets, and agent loop state read from or write back to it.

Q: What are build cards?

Build cards are feature-scoped implementation units generated from the MVP blueprint and living spec. They carry dependencies, acceptance criteria, prompt context, evidence, QA state, SQL actions, and remediation state for coding agents.

Q: What happens after the MVP is built?

In the Product track, the same context carries into landing copy, SEO, GEO/AEO, schema, launch plans, outbound, leads, and signal tracking. The focused Feature track stops at a tested, build-ready feature unless the user asks an agent to run the implementation loop.

Build a new product from scratch or ship a new feature into an existing codebase. LaunchChair turns either path into validated direction, a living spec, and build-ready work for your agent.

ICP / Substitutes / Wedge

Living spec preview

Map the market

Start with ICP pain, substitutes, and wedge evidence.

LaunchChair turns the raw idea into ICP clarity, competitor context, substitute behaviors, validation tests, and market wedge direction.

Deep competitor analysis

Substitute behaviors and gaps

Market wedge choice

Structured phase system

One living MVP spec from idea validation to launch.

LaunchChair does not ask an agent to build from a vague paragraph. It moves through gated phases, generated choices, synthesis pages, agent runs, and human checkpoints while keeping the project spec current.

Strategy loop

Execution loop

Strategy loop

Product ideation

Capture the problem, user, solution hypothesis, and first project context.

Market + validation

Map ICP, competitors, substitutes, sentiment, distribution, risks, validation tests, and wedge options.

Positioning + pricing

Turn research into category, offer, audience, pricing, and conversion assumptions.

MVP blueprint

Generate P0 features, stories, screens, flows, data model, access rules, and feature direction.

Execution loop

Stack setup

Verify GitHub, Vercel, Supabase, Codex or Claude Code, Stripe, local path, and readiness blockers.

Build board

Run repo interrogation, scaffold, SQL setup, auth, feature cards, deploy prep, security, and QA smoke.

Landing + SEO/GEO/AEO

Generate brand, landing sections, CTA, technical SEO, schema, answer targets, and llms surfaces.

Launch + sales

Create launch plans, outbound sequences, campaigns, leads, sources, signals, and daily actions.

Ask your agent what LaunchChair does

ChatGPT

Claude

Perplexity

Grok

Feature Project Type

Already have a product? Ship the next feature.

The Feature track cuts the new-product phases. It validates demand inside your existing product, defines the PRD, and gives your agent build-ready work without forcing a new stack or architecture.

Validate the opportunity

Research ICP complaint and delight themes, substitute behaviors, competitor gaps, and wedge strength before committing to scope.

Define the feature

Turn the selected wedge into a focused PRD with feature direction, acceptance criteria, screens, flows, and system impact.

Give the agent a build board

Generate dependency-aware cards for the existing codebase, including verification, remediation, and consolidated SQL checkpoints.

Why spec-led builds waste less tokens

Generic prompts decay at every handoff.

The real waste compounds across the lifecycle: rebuilding product context, restating choices, making agents reread code paths, losing acceptance criteria, and retrying broad runs after the project state drifts. LaunchChair keeps the living spec and scoped work cards attached to the next run.

Illustrative model for a complex SaaS MVP. Actual savings vary by project scope, agent, repo quality, and founder involvement.

Cumulative lifecycle context time

Founder and agent setup time across the product lifecycle

Blank 42.5 hrs

LC 9.5 hrs

Lifecycle context time

0.0hrs saved

Blank 42.5 hrs

→

LC 9.5 hrs

Context-management time only: rebriefing, restating choices, reloading project state, and agent handoff setup.

Lifecycle tokens

0.0M fewer

Blank 7.8M

→

LC 2.8M

Blank: 5.8M input/context + 2.0M output. LC: 1.9M input/context + 0.9M output.

Retry/reread loops

0fewer loops

Blank 31

→

LC 11

Counts agent retries, broad codebase rereads, missed acceptance, QA follow-ups, and remediation loops.

What the prompt engine compiles

The agent gets the product system before it writes code.

LaunchChair packages the AI product spec, strategy, scope, repo context, acceptance criteria, verification, remediation, and launch context into the next run.

Validated ICP

Pain points, desired outcomes, current alternatives, and why-now pressure.

Substitute map

What users do today, where competitors are weak, and where the wedge lives.

Living spec

Positioning, pricing, MVP scope, screens, flows, data model, and selected choices.

Build board

Dependencies, acceptance criteria, spec selectors, repo context, SQL actions, and QA state.

Remediation

Invalid output becomes a retry or remediation run instead of silent drift.

Launch context

Landing copy, SEO/GEO/AEO, schema, launch plan, outbound, leads, and signals.

Agent API and MCP bridge

Connect your agent once. Run Product and Feature workflows from chat.

The easiest MCP setup is the LaunchChair CLI. Run the guided setup for Codex or Claude and it handles browser login, local agent instructions, MCP configuration, bridge startup, and the connection check. MCP-only setup remains available.

Install the LaunchChair CLI

Guided CLI setup

Install @launchchair/agent, then run launchchair setup codex or launchchair setup claude. The CLI handles login, AGENTS.md, MCP config, bridge startup, and connection checks.

Agent API

Scoped tokens let agents resolve Product and Feature projects, read specs, claim runs, complete runs, and export phase summaries.

MCP Bridge

Codex, Claude, and other local agents operate LaunchChair through a protected stdio bridge. Guided CLI setup writes and verifies the connection for you.

Safe agent loop

Run Product or Feature work, validate structured output, retry or remediate, and pause for SQL, account authorization, or manual QA.

Private starter boilerplate

Every build starts from an agent-readable SaaS foundation.

LaunchChair creates customer-owned repositories from a private starter instead of dropping agents into a generic blank app. The repo already knows the stack, route boundaries, security model, SEO/AEO surfaces, design rules, and optional integration recipes before the first build card runs.

The starter is separate from the LaunchChair app itself. LaunchChair owns the private upstream starter, then copies the current snapshot into the user's own private GitHub repo where all code is visible and editable.

launchchair-starter / user-owned-repo

INCLUDED

Next.js

TypeScript

Tailwind

shadcn/ui

Supabase

Vercel

Stripe

PostHog

Resend

Chart.js

Zod

Phosphor

Setup time avoided

6-10 hrs

Auth, RLS, app shell, admin/blog, SEO routes, env validation, and integration scaffolds begin mapped instead of invented.

Prompt tokens avoided

400k-900k

Agents read repo-local rules, recipes, design guidance, and route boundaries instead of getting the same architecture pasted repeatedly.

Standalone value

$299-$399

Comparable to paid SaaS boilerplates, then wrapped in LaunchChair's prompt engine, living spec, build cards, and remediation loop.

User-owned repo

The GitHub App copies the current private starter snapshot into the user's own private repository. The user can inspect and edit the code.

Agent-readable rules

`AGENTS.md`, `design.md`, `launchchair.json`, and `docs/*` carry architecture, design, security, SEO, and recipe context.

Secure SaaS baseline

Supabase SSR auth, profiles, RLS policies, protected app routes, admin role checks, security headers, and server-only secret boundaries.

Launch-ready surfaces

Public landing, blog, dynamic sitemap, robots, Open Graph image, JSON-LD helpers, `llms.txt`, and SEO/GEO/AEO recipes.

Optional integrations

Stripe, PostHog, and Resend scaffolds are installed but inactive until a build card needs payments, analytics, or email.

Less slop by default

Known routes, UI primitives, env helpers, site config, and local docs stop agents from hand-rolling thin, inconsistent foundations.

LaunchChair Pricing

Ship products and features without hidden LaunchChair token fees.

PRICING-01

Founder

$19

/mo

For founders launching products and shipping features

Unlimited product projects

Unlimited feature projects

1 team seat

Infinite project resets

Full-workflow Agent API & MCP

LaunchChair Boilerplate

Popular

PRICING-02

Builder

$39

/mo

For builders shipping multiple products and features

Unlimited product projects

Unlimited feature projects

3 seats

Infinite project resets

Full-workflow Agent API & MCP

LaunchChair Boilerplate

PRICING-03

Agency

$99

/mo

For agencies shipping products and features for clients

Unlimited product projects

Unlimited feature projects

10 seats

Unlimited full-workflow Agent API & MCP

White-labeled and shareable summary pages

LaunchChair Boilerplate

LaunchChair comparison

LaunchChair vs vibe coding and AI app builders.

Hosted AI builders are strong when you want a fast generated app, deployment surface, and visual editing loop. LaunchChair is for the work before and around generation: product validation, a living spec, build-card remediation, agent contracts, SEO/GEO/AEO, and launch assets so Codex, Claude, Cursor, Grok, Kimi, Gemini, and similar build agents work from current product truth.

Features	LaunchChair	AI Vibe coding	Bolt.new	Lovable	Netlify	Replit	Base44
Product validation and living spec
Product validation before build scope
ICP, substitute, competitor, and wedge research
Auto-generated PRD and spec
Positioning, pricing, and MVP scope in one system
Spec reused across research, build, launch, SEO, GEO, and AEO
App generation and platform capabilities
AI-assisted app generation from natural language
Backend, database, auth, or storage support
Hosted deployment or runtime surface
In-browser editor or builder workspace
SEO or design-system support
Agent execution and build quality
Build cards with acceptance criteria and evidence
Strict agent contracts, spec context, feature scope, guardrails, and slop checks
Agent API and MCP for Codex, Claude, Hermes, Grok, Kimi, Gemini, and local agents
Retry, reread, remediation, and validation loop
Human SQL, QA, account, and authorization checkpoints
Works with your preferred coding agent
You write every prompt manually
Starter, launch, and search surfaces
Customer-owned AI-readable Next.js/Supabase starter
Repo-local AGENTS.md, design.md, launchchair.json, and docs
Landing page, launch assets, and sales execution from the spec
SEO/GEO/AEO prompts, schema, sitemap, robots, and llms.txt generated from spec
One-prompt hosted prototype convenience

Comparison separates hosted-builder app generation and platform conveniences from LaunchChair product validation, living spec, build-card remediation, agent contracts, and spec-derived launch workflow.

FAQ

LaunchChair FAQ for AI MVP planning and spec-driven builds

Short answers for founders comparing LaunchChair with prompt libraries, AI app builders, coding agents, PRD tools, and startup validation workflows.

Q-01

What is LaunchChair?

Q-02

Is LaunchChair just a prompt library?

Q-03

Is LaunchChair an AI app builder?

Q-04

How is LaunchChair different from vibe coding?

Q-05

Are Agent API and MCP the core product?

Q-06

Can agents run the whole project automatically?

Q-07

What is the living spec?

Q-08

What are build cards?

Q-09

Does LaunchChair charge for token usage?

Q-010

What happens after the MVP is built?

Product-team layer for AI agents

Stop asking agents to guess the product.

LaunchChair turns messy founder intent into validation, a living spec, MVP blueprint, build cards, guardrails, remediation, and launch assets. Your coding agent executes from product truth instead of a vague paragraph.