A skill that turns any project idea — no matter how vague — into 8 living planning
documents that act as the project's persistent memory across a long context window.
The documents are the source of truth for "what we agreed on"; the user's live
instructions are always the final authority and can override the docs at any time.
contradicts a file, the user wins — and the relevant file(s) should then be
updated to reflect the new instruction.
rules the user did not ask for or approve. If something seems missing, ask —
don't assume. Exception: when the user explicitly says "fill it in",
"brainstorm the rest", "you decide", etc. — see Phase 3.
the user for style direction (e.g. minimal, playful, corporate, dark mode,
neumorphic, etc.) and a color palette (or offer 2-3 palette options to pick
from) before writing anything into it.
files at once unless the user explicitly asks for that.
completed, never rewrite history, just check items off and add new ones as
they emerge.
affects earlier decisions (e.g. "actually let's use Postgres instead of
Firebase", "add a booking feature"), update ALL affected files yourself,
without being asked file-by-file. Then summarize what changed.
already exist in the project, read all 8 before doing anything else — they
are your memory.
| File | Purpose |
|---|---|
| PRD.md | What the app does, features, goals, user requirements |
| TechSpec.md | Architecture, tech stack, APIs, database choices |
| AppFlow.md | User flows and navigation |
| Design.md | UI/UX guidelines, layout, style, color palette |
| Schema.md | Database tables, relationships, data models |
| ImplementationPlan.md | Step-by-step development roadmap |
| Tracker.md | Completed work, pending tasks, progress |
| Rules.md | Coding standards, constraints, project rules |
this is the trigger to start Phase 1.
files but populate them directly from what they said — skip redundant
questions.
This is the foundation. Everything else depends on it.
number of clarifying questions to flesh out the PRD — target audience, core
features, platforms (web/mobile/both), must-haves vs nice-to-haves, monetization
if any, etc. Use ask_user_input_v0 for quick multiple-choice clarifications
where natural.
themselves — if they say "I'll fill it in", create a skeleton PRD.md with
section headers and placeholders, and wait for them.
options — don't fill gaps with assumptions.
confirmation before moving to the next file.
In this order: TechSpec.md → AppFlow.md → Schema.md → ImplementationPlan.md →
Rules.md → Tracker.md → Design.md (last, see Phase 2.5).
For each file:
questions if there's a real decision to make (e.g. "Should this use
PostgreSQL or a simpler option like SQLite/Firebase?").
If the user says "just fill out the rest yourself, no assumptions, brainstorm
properly" — this means: make reasonable, justifiable choices consistent with
the PRD and any constraints already stated (not random/lazy defaults), but
still present everything to the user afterward for review before building
starts. "No assumptions" here means "don't contradict or extend the PRD's
intent" — not "ask about every detail."
Never write Design.md without asking the user:
brutalist / glassmorphism / dark-first) — offer ask_user_input_v0 choices
if helpful.
palette options matching their chosen style and let them pick.
Only after this input is gathered do you write Design.md.
ask the user to review everything (especially Rules.md — ask if they want to
add any constraints, e.g. "no external libraries", "TypeScript only",
"must work offline", etc.).
step by step.
add a short note/date if useful).
without explicit user instruction.
follow it immediately (user command is final), AND update the relevant
file(s) afterward so the docs stay in sync. Briefly tell the user which
files you updated and why.
PRD-consistent choice, document it, present for review — don't silently bake
it in.
the file.
User request:
Turn this new-product idea into the eight structured planning files required before implementation.