product-playbook 1.0.0

package/i18n/en/references/05c-validation-spec.md

@@ -0,0 +1,117 @@
+# Stage 4: Deliver — Hypothesis Validation + Product Spec Summary
+
+## 4.5 Hypothesis Validation Plan
+
+**Applicable: Medium/high completeness / audience is data scientists/self**
+
+```
+| Core Hypothesis | Validation Method | Validation Timing | Success Criteria | If hypothesis is wrong, we will... |
+|----------------|-------------------|-------------------|-----------------|----------------------------------|
+| | Alpha user interviews / data | | | |
+```
+
+Principles: Qualitative validation (user interviews, diary studies) + quantitative validation (data) carry equal weight; stay alert to your own confirmation bias.
+
+## 4.6 Product Spec Summary
+
+The Product Spec Summary is the final deliverable across all modes (Quick mode produces a one-page directional summary — different structure but same spirit).
+The Product Spec Summary has three sections, corresponding to different reading depths:
+
+### Section 1: Decision Summary (Readable in 30 seconds)
+
+```
+**Product One-liner**: [PR-FAQ headline]
+**For Whom**: [Target Persona in one sentence]
+**Core Value**: [JTBD functional job + emotional job, in one sentence]
+**North Star Metric**: [Metric name + definition]
+**Current PMF Level**: [Level 1-4 + one-sentence explanation]
+```
+
+### Section 2: Execution Boundaries (Readable in 2 minutes)
+
+```
+**Core JTBD Statement**: [Target Customer] + wants to [Job] + in the context of [Job Context]
+**Aha Moment**: When the user completes [action], they experience the core value. Target: reach it within [X].
+**MVP Must-Haves**: [3-5 most critical features/capabilities]
+**Not Doing (Deliberately excluded from this version)**: [Explicit exclusions + reasons]
+**Key Hypotheses**: [2-3 core hypotheses that need validation]
+**Pre-mortem Top Risks**: [2-3 most likely causes of failure]
+**Hero Metric**: [1-2 most important success metrics + target values]
+```
+
+### Section 3: Deep Reference (Consult when needed)
+
+```
+**JTBD Breakdown**:
+  - Functional Job:
+  - Emotional Job:
+  - Social Job:
+**April Dunford Positioning**:
+  - Real competitive alternatives:
+  - Our unique attributes:
+  - Core value for target users:
+  - Target market characteristics:
+  - Market category:
+**Core HMW Question**: [From the Define stage]
+**Solution Description**: [From PR-FAQ summary]
+**Business Model**: [Revenue model + pricing strategy, if completed]
+**GTM Strategy**: [Initial acquisition channel + launch strategy, if completed]
+```
+
+After completing the three sections, Claude **must proactively add the following three sections** without waiting for the user to ask:
+
+---
+
+### ⚠️ Risk Register
+
+Consolidate all risks identified throughout the planning process (sources: Pre-mortem + Opportunity Assessment + Hypothesis Validation):
+
+```
+| Risk Type | Risk Description | Severity (High/Med/Low) | Mitigation in Place? |
+|-----------|-----------------|------------------------|---------------------|
+| Market risk | | | |
+| User assumption risk | | | |
+| Technical risk | | | |
+| Competitive risk | | | |
+| Execution risk | | | |
+```
+
+---
+
+### 🔍 Gaps & Blind Spots
+
+Claude proactively identifies the following types of gaps based on the entire conversation flow:
+
+```
+| Type | Description | Recommended Next Step |
+|------|------------|----------------------|
+| Unexecuted steps | [Which frameworks were skipped and what blind spots this may cause] | |
+| Insufficient data | [Which decisions are based on assumptions rather than real user data] | |
+| Logical leaps | [Where the reasoning lacks intermediate evidence] | |
+| Unvalidated hypotheses | [List all core hypotheses without a validation method yet] | |
+| Unclear definitions | [Which concepts need more precise definition before execution] | |
+```
+
+---
+
+### 💡 Additional Recommendations
+
+Claude provides 3-5 specific, actionable recommendations based on the product's characteristics, stage, and known risks:
+
+```
+1. [Top priority]: [Specific action] — Rationale: [Why this matters most]
+2. [Second priority]: [Specific action] — Rationale:
+3. [Third priority]: [Specific action] — Rationale:
+...
+```
+
+Recommendations may cover: user validation methods, MVP boundary adjustments, competitive strategy, metric design, team allocation, next milestone priorities.
+
+---
+
+## 📎 File Integration Tips for This Stage
+
+| Uploaded Content | Integrate Into | Integration Action |
+|-----------------|----------------|-------------------|
+| User behavior data (CSV / Excel) | 4.2 North Star + 4.3 PMF | Use real retention and engagement data to assess PMF level; calibrate North Star baseline |
+| Sean Ellis survey results | 4.3 PMF + 4.2 Three-Layer Signals | Calculate Score directly, fill into Layer 3 |

package/i18n/en/references/06-html-report.md

@@ -0,0 +1,128 @@
+# HTML Product Planning Report Output
+
+Triggered when the user says "produce a report" or confirms the last stage content is correct.
+
+## Design Specifications
+
+Use a **modern design style** — a single HTML file (CSS and JS fully inlined), ensuring it's readable offline.
+
+**Overall Style:**
+- Gradient background Hero section (with mode, audience, date labels)
+- Card-based layout (rounded corners + shadows), each section like an independent information card
+- Clear typography hierarchy and comfortable reading spacing
+- Responsive design, smooth reading on mobile
+
+**Color Scheme:**
+- Primary: Deep blue `#1a1a2e` → `#16213e` → `#0f3460`
+- Accent: `#e94560` or `#533483`
+- Content area background: `#f8f9fa`, cards: white with `box-shadow`
+
+**Font:** Load Inter from Google Fonts CDN first, fall back to system fonts:
+```css
+/* In <head> */
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap" rel="stylesheet">
+
+/* In CSS */
+font-family: "Inter", system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+```
+> This is the only permitted external CDN dependency. If Google Fonts is unavailable, the page will still render correctly.
+
+## Page Structure (Dynamically rendered based on completed stages)
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│  Hero Section (Product name, one-liner, mode, audience, date)│
+├──────────────────────────────────────────────────────────────┤
+│  Table of Contents Navigation (Sticky, only shows completed) │
+├──────────────────────────────────────────────────────────────┤
+│  🧭 Strategy Section (if completed)                          │
+│     ├─ Strategy Blocks hierarchy diagram                     │
+│     ├─ Rumelt's Kernel of Good Strategy (Diagnosis/Policy/   │
+│     │  Actions)                                              │
+│     └─ Shreyas' Three Levels of Product Work                 │
+│  ✅ Opportunity Check Section (if completed)                  │
+│  🔍 Discovery Section (if completed)                         │
+│     ├─ Persona Table (card-style table)                      │
+│     ├─ Persona Cards (one per persona)                       │
+│     ├─ JTBD Analysis Table (four types)                      │
+│     ├─ Opportunity Solution Tree (visual tree)               │
+│     └─ User Journey Map (overview + accordion detail)        │
+│  🎯 Define Section (if completed)                            │
+│     ├─ Pain Point Summary Table                              │
+│     ├─ April Dunford Positioning Framework Card              │
+│     ├─ HMW Question Cards (with JTBD type tags)             │
+│     └─ Opportunity Assessment Table (opportunity cost view)  │
+│  💡 Develop Section (if completed)                           │
+│     ├─ PR-FAQ Card (simulated press release format)          │
+│     ├─ Solution Ideation (three-column parallel cards)       │
+│     ├─ Pre-mortem Risk Table (color-coded High/Med risk)     │
+│     ├─ GEM Matrix + Impact/Effort Quadrant Chart             │
+│     ├─ RICE Prioritization Table (if completed)              │
+│     ├─ User Story Table (if completed)                       │
+│     └─ MVP Scope (three-column cards + Not Doing List)       │
+│  🚀 Deliver Section (if completed)                           │
+│     ├─ Aha Moment Definition Card (prominently displayed)    │
+│     ├─ North Star Metric Card                                │
+│     ├─ Three-Layer Signal Metrics Table                      │
+│     ├─ PMF Level Assessment (four-level visual + current     │
+│     │  position marker)                                      │
+│     ├─ GTM Strategy (channel selection + first 100 users     │
+│     │  plan, if completed)                                   │
+│     ├─ Business Model & Pricing (revenue model + pricing     │
+│     │  strategy, if completed)                               │
+│     ├─ Hypothesis Validation Plan Table (if completed)       │
+│     └─ Product Spec Summary (three-section structure:        │
+│        Decision Summary / Execution Boundaries / Deep Ref)   │
+│  ⭐ Best Entry Point Analysis (full logic chain visual)       │
+├──────────────────────────────────────────────────────────────┤
+│  Footer: Output date + mode + framework attribution          │
+└──────────────────────────────────────────────────────────────┘
+```
+
+## Section Design Details
+
+**Table Styling:** Zebra stripes, dark header, rounded corners, hover highlight
+
+**Persona Cards:** One card per Persona, pain points with red left border, JTBD emphasized with blue/purple color blocks
+
+**Opportunity Solution Tree:** Use CSS or lightweight SVG to draw the tree structure, clearly showing the Goal → Opportunity → Solution hierarchy
+
+**PMF Level Chart:** Use a progress bar or step diagram showing four levels, marking the user's current position
+
+**PR-FAQ Card:** Simulated press release format with headline, subtitle, lead paragraph — visually resembling a real document
+
+**Pre-mortem Risk Table:** High-risk items in red alert, medium-risk in yellow
+
+**Best Entry Point Logic Chain:** Visualize the full reasoning chain, each node as a small card, connected by arrows
+
+## Interactive Effects
+
+- `scroll-behavior: smooth` — Smooth scrolling on TOC click
+- Intersection Observer — Highlight current section in TOC while scrolling
+- Card hover micro-lift (`transform: translateY(-2px)` + `transition`)
+- Accordion expand/collapse (User Journey Map stages, `<details>/<summary>`)
+- `@media print` — Hide interactive elements when printing, ensure tables aren't truncated
+
+## Important Notes
+
+- All CSS and JS inlined in HTML — no external dependencies except Google Fonts CDN for Inter
+- If a stage was not completed, don't render an empty section — just skip it
+- The Hero section displays the "Mode" and "Audience" so readers immediately understand the document's context
+- The page can be very long — TOC navigation is critical for quick jumping
+
+## Framework Attribution & Further Reading (in footer)
+
+| Thinker | Key Contribution | Source |
+|---------|-----------------|--------|
+| Teresa Torres | Continuous Discovery, Opportunity Solution Tree | Lenny's Podcast + *Continuous Discovery Habits* |
+| Shreyas Doshi | LNO Framework, Pre-mortem, Three Levels of Product Work, Opportunity Cost Thinking | Lenny's Podcast Ep.3 |
+| Gibson Biddle | DHM Model, GEM Prioritization | Lenny's Podcast |
+| April Dunford | Positioning Framework | Lenny's Podcast + *Obviously Awesome* |
+| Todd Jackson | Four-Level PMF Framework, Four P's | Lenny's Podcast (First Round Capital) |
+| Richard Rumelt | Good Strategy / Bad Strategy, Kernel of Good Strategy | Lenny's Podcast + *Good Strategy Bad Strategy* |
+| Marty Cagan | Empowered Teams, Product Discovery | Lenny's Podcast + *Inspired*, *Empowered* |
+| Chandra Janakiraman | Strategy Blocks | Lenny's Newsletter (Headspace / Meta) |
+| Clayton Christensen | Jobs to Be Done | *Competing Against Luck* |
+| Amazon | Working Backwards / PR-FAQ | *Working Backwards* |
+| Sean Ellis | Sean Ellis Score, ICE Scoring | *Hacking Growth* |
+| Lenny Rachitsky | Shape / Ship / Synchronize, North Star Thinking | Lenny's Newsletter + Podcast |

package/i18n/en/references/07a-handoff-core.md

@@ -0,0 +1,152 @@
+# Development Handoff — Core Handoff Package
+
+> Triggered when the user says "start development," "produce a dev handoff package," "set up my project," or "connect to Claude Code."
+> Read this file, consolidate the outputs from the entire product planning process, and generate a development handoff package that can be used directly in the Claude Code CLI.
+
+## Environment Constraints & Handoff Strategy
+
+**Key fact: Claude Chat / Cowork and Claude Code are separate runtime environments — you cannot launch Claude Code from within Chat.**
+
+The handoff strategy is therefore: **Produce a structured development handoff package (a set of files)** that the user downloads, places in their project folder, and can kick off the entire development workflow with a single prompt in Claude Code.
+
+The handoff method depends on the user's environment:
+
+| User Environment | Handoff Method |
+|-----------------|----------------|
+| **Claude Chat (Web/App)** | Produce a zip file for download; user extracts to project directory then opens Claude Code |
+| **Claude Cowork (Desktop)** | Same as above, but can write files directly to a user-specified local path |
+| **Already in Claude Code** | Create all files directly in the project directory (in this scenario, this skill is likely referenced from CLAUDE.md) |
+
+---
+
+## Development Handoff Package Contents
+
+Produce the following file set, all placed in the project root:
+
+```
+[project-name]/
+├── .gitignore             # Version control exclusions (.env, secrets, progress files, etc. — template in references/07c-architecture-setup.md)
+├── CLAUDE.md              # Claude Code's project memory: product context + development guidelines
+├── TASKS.md               # Feature breakdown + Phase milestones + per-Task acceptance criteria
+├── TICKETS.md             # Ticket content: title, description, acceptance criteria per ticket — PM can create tickets directly
+├── docs/
+│   ├── PRD.md             # Full PRD (consolidated from 04-develop.md output format)
+│   ├── ARCHITECTURE.md    # Technical architecture: directory structure + DB schema + API endpoints + security architecture
+│   └── PRODUCT-SPEC.md    # Product Spec Summary (consolidated from 05-deliver.md → 4.6)
+└── scripts/
+    └── setup.sh           # One-click initialization script (create directories + install dependencies)
+```
+
+---
+
+## 📄 CLAUDE.md Template
+
+CLAUDE.md is Claude Code's project memory file — Claude Code automatically reads it on every startup. It must include:
+
+```markdown
+# [Product Name] — Project Guide
+
+## Product Context
+
+**One-liner**: [PR-FAQ headline]
+**Target Users**: [Persona in one sentence]
+**Core JTBD**: [Target Customer] wants to [Job] in the context of [Job Context]
+**Aha Moment**: When the user completes [action], they experience the core value
+**North Star Metric**: [Metric name + definition]
+
+## Tech Stack
+
+- **Frontend**: [Framework + version]
+- **Backend**: [Framework + version]
+- **Database**: [Type + version]
+- **Deployment**: [Platform]
+- **Package Manager**: [Tool]
+
+## Development Guidelines
+
+- Develop in [language]
+- Follow [style guide / lint rules]
+- Commit message format: `[type]: [description]` (type: feat / fix / refactor / docs / test)
+- Branch strategy: [main / develop / feature-xxx]
+- Every feature must reference its User Story number (see TASKS.md)
+
+## MVP Boundaries
+
+**Must-Have (P0)**:
+- [Feature 1]
+- [Feature 2]
+- [Feature 3]
+
+**Explicitly Not Doing**:
+- [Exclusion 1] — Reason: [rationale]
+- [Exclusion 2] — Reason: [rationale]
+
+## Key Decision Log
+
+| Decision | Choice | Rationale | Date |
+|----------|--------|-----------|------|
+| [e.g., Database selection] | [PostgreSQL] | [Needs relational queries + JSON support] | [Date] |
+
+## Risk Alerts (from Pre-mortem)
+
+- ⚠️ [Risk 1]: [Preventive measure]
+- ⚠️ [Risk 2]: [Preventive measure]
+
+## Security Notes
+
+> Full security checklist at `references/08-security-checklist.md`. Below are this product's key security decisions:
+
+- Authentication: [JWT / Session / OAuth]
+- CORS policy: [Allowed origins]
+- Rate Limiting: [Strategy summary]
+- Sensitive data: [Handling approach]
+
+## Development Workflow
+
+Follow the Phase order in `TASKS.md`. After completing each Phase:
+1. Verify all Task acceptance criteria pass
+2. Ask the user whether to proceed to the next Phase
+3. If architectural questions arise, refer to `docs/ARCHITECTURE.md`
+```
+
+---
+
+## Tech Stack Confirmation Flow
+
+Before producing the handoff package, the tech stack must be confirmed. If the user hasn't specified, ask in this order:
+
+### Must-Ask (Affects all outputs)
+
+```
+1. What type of application is this?
+   □ Web App (browser)
+   □ Mobile App (iOS / Android / cross-platform)
+   □ Desktop App
+   □ API / Backend Service
+   □ CLI Tool
+   □ Other
+
+2. Do you have a preferred tech stack?
+   (If not, I'll recommend one based on the product characteristics)
+```
+
+### Recommendation Logic (When user hasn't specified)
+
+| Application Type | Recommended Stack | Rationale |
+|-----------------|-------------------|-----------|
+| Web App (fast MVP validation) | Next.js + Tailwind + Supabase | Full-stack in one, easy deployment, built-in Auth |
+| Web App (complex backend logic) | React + Node.js/Express + PostgreSQL | High flexibility, mature ecosystem |
+| Web App (Python team) | React + FastAPI/Django + PostgreSQL | Python ecosystem, Django has built-in Admin |
+| Mobile App (cross-platform) | React Native / Flutter | Single codebase covers both platforms |
+| API Service | FastAPI / Express / Go | Lightweight, high performance |
+
+> Claude should explain the rationale when recommending and remind the user they can override the recommendation.
+
+### Optional (Follow-up based on product needs)
+
+```
+3. Do you need user authentication? (Affects Auth approach selection)
+4. Any real-time requirements? (WebSocket / SSE)
+5. Need file upload/processing? (Affects storage choice)
+6. Where do you plan to deploy? (Vercel / Railway / AWS / self-hosted)
+```

package/i18n/en/references/07b-tasks-tickets.md

@@ -0,0 +1,215 @@
+# Development Handoff — TASKS.md + TICKETS.md
+
+## 📄 TASKS.md Template
+
+Core principles for feature breakdown:
+- Start from the MVP must-haves (P0 features)
+- Each Task maps to a User Story
+- Phases have clear dependencies: Phase N+1 depends on Phase N outputs
+- Each Task includes acceptance criteria that Claude Code can self-verify
+
+```markdown
+# [Product Name] — Development Task List
+
+## Phase 0: Project Initialization
+> Goal: Establish a runnable blank project skeleton
+
+- [ ] **T0.1** Initialize project (`scripts/setup.sh` or manual)
+  - Acceptance:
+    - [ ] `npm run dev` / `python manage.py runserver` or equivalent command starts successfully
+    - [ ] `.gitignore` created, includes `.env`, `.env.local`, `node_modules/`, `.product-playbook-progress.md`, and other sensitive files
+    - [ ] `.env.example` created (key names only, no actual values)
+- [ ] **T0.2** Set up linter + formatter
+  - Acceptance: lint passes with no errors
+- [ ] **T0.3** Set up database + run initial migration
+  - Acceptance: Database is connectable, base tables are created
+- [ ] **T0.4** Set up base routing structure
+  - Acceptance: All main page routes are accessible (returning blank pages is fine)
+
+## Phase 1: Core Flow (Aha Moment Path)
+> Goal: Let users complete the shortest path from entry to the Aha Moment
+> Corresponds to User Stories: [US-001, US-002, ...]
+
+- [ ] **T1.1** [Feature name]
+  - User Story: As a [Persona], I want to [action], so that [value]
+  - Acceptance Criteria:
+    - [ ] [Specific testable condition 1]
+    - [ ] [Specific testable condition 2]
+  - Technical Notes: [Required APIs / third-party services / special logic]
+
+- [ ] **T1.2** [Feature name]
+  - User Story: ...
+  - Acceptance Criteria: ...
+
+> **Phase 1 Completion Checkpoint**: User can complete [Aha Moment action]. If not, do not proceed to Phase 2.
+
+## Phase 2: Complete MVP
+> Goal: Fill in all remaining P0 features not covered in Phase 1
+> Corresponds to User Stories: [US-003, US-004, ...]
+
+- [ ] **T2.1** [Feature name]
+  - ...
+
+> **Phase 2 Completion Checkpoint**: All P0 User Story acceptance criteria pass.
+
+## Phase 3: Quality & Experience
+> Goal: Error handling, edge cases, loading states, basic security
+
+- [ ] **T3.1** Global error handling
+- [ ] **T3.2** Form validation + edge cases
+- [ ] **T3.3** Loading states + empty states
+- [ ] **T3.4** Security check (verify each item per `references/08-security-checklist.md`)
+  - Acceptance:
+    - [ ] OWASP Top 10 related items addressed (input validation, authentication, XSS protection, CSRF protection)
+    - [ ] Security headers configured (CSP, X-Frame-Options, HSTS, etc.)
+    - [ ] CORS policy configured (no wildcard *)
+    - [ ] Sensitive API endpoints have rate limiting
+    - [ ] API error responses don't leak internal information
+- [ ] **T3.5** Responsive design (if Web)
+
+## Phase 4: Deployment
+> Goal: Make the app accessible to external users
+
+- [ ] **T4.1** Environment variable management
+- [ ] **T4.2** Deployment configuration
+- [ ] **T4.3** Basic monitoring + logging
+```
+
+---
+
+## 📄 TICKETS.md Template
+
+TICKETS.md takes the feature breakdown from TASKS.md and produces structured content that can be directly used to create tickets in project management tools. Each ticket contains all the information a PM needs.
+
+> **Design goal**: PMs can copy each ticket's content directly into Jira / Asana / Linear or other tools to create tickets. Future versions will support automatic ticket creation via API.
+
+```markdown
+# [Product Name] — Ticket List
+
+> Generated: [timestamp]
+> Corresponds to TASKS.md version: [version/timestamp]
+> Total: [N] tickets
+
+---
+
+## Ticket Overview
+
+| Ticket # | Title | Phase | Priority | Estimated Hours | Dependencies |
+|----------|-------|-------|----------|----------------|-------------|
+| TKT-001 | [Title] | Phase 0 | P0 | [X]h | — |
+| TKT-002 | [Title] | Phase 1 | P0 | [X]h | TKT-001 |
+| ... | | | | | |
+
+---
+
+## TKT-001: [Title]
+
+**Phase**: Phase 0 — Project Initialization
+**Corresponding Task**: T0.1
+**Priority**: P0
+**Estimated Hours**: [X] hours
+**Dependencies**: None
+**Assignee**: [Role/team, e.g., Backend Engineer]
+
+### Description
+
+[1-3 paragraphs describing what this ticket accomplishes, including business context and technical goals]
+
+### User Story
+
+As a [Persona], I want to [action], so that [value]
+
+### Acceptance Criteria
+
+- [ ] [Specific testable condition 1]
+- [ ] [Specific testable condition 2]
+- [ ] [Specific testable condition 3]
+
+### Technical Notes
+
+- [Implementation considerations]
+- [Required APIs / third-party services]
+- [Related file paths or modules]
+
+### Suggested Labels
+
+`[Phase 0]` `[backend]` `[setup]`
+
+---
+
+## TKT-002: [Title]
+
+[Same format, expanded for each ticket]
+```
+
+### Ticketing Rules
+
+1. **Ticket-to-Task mapping**: Each Task in TASKS.md maps to one ticket (TKT-001 ↔ T0.1); overly large Tasks may be split into multiple tickets
+2. **Priority inheritance**: Phase 0-1 default to P0, Phase 2 defaults to P1, Phase 3-4 default to P2 — adjustable based on RICE scores
+3. **Dependencies**: Explicitly mark ticket-to-ticket dependencies to prevent engineers from skipping steps
+4. **Estimated hours**: Based on the Task granularity principle (1-4 hours), provide reasonable estimates
+5. **Suggested labels**: Include Phase, technical domain (frontend / backend / database / infra), feature module
+
+### Project Management Tool Integration (Reserved)
+
+> The following is a reserved interface design for future automatic ticketing. The current version only produces TICKETS.md for manual PM ticket creation.
+
+TICKETS.md's structured format reserves the following fields for future API import:
+
+| Field | Jira Mapping | Asana Mapping | Linear Mapping |
+|-------|-------------|--------------|----------------|
+| Ticket # | Issue Key | Task ID | Issue ID |
+| Title | Summary | Task Name | Title |
+| Description | Description | Description | Description |
+| Priority | Priority | Custom Field | Priority |
+| Estimated Hours | Story Points / Time Estimate | Custom Field | Estimate |
+| Dependencies | Linked Issues | Dependencies | Relations |
+| Labels | Labels + Components | Tags | Labels |
+| Phase | Epic | Section | Project |
+| Assignee | Assignee | Assignee | Assignee |
+| Acceptance Criteria | Acceptance Criteria (Description) | Subtasks | Sub-issues |
+
+---
+
+## Feature Breakdown Logic
+
+Rules for converting MVP features into Tasks:
+
+### Phase Division Principles
+
+```
+Phase 0: Project skeleton (required for all modes)
+  → Initialization, linter, DB, base routing
+
+Phase 1: Shortest path to Aha Moment (most important)
+  → Minimum features needed from user entry to Aha Moment
+  → Only includes P0 features on this path
+
+Phase 2: Complete MVP
+  → Fill in remaining P0 features not covered in Phase 1
+  → Secondary flows, supporting pages
+
+Phase 3: Quality & Experience
+  → Error handling, edge cases, loading/empty states
+  → Basic security, responsive design
+
+Phase 4: Deployment
+  → Environment variables, deployment config, monitoring
+```
+
+### Task Granularity Principle
+
+- Each Task should be completable in **1-4 hours**
+- Too large → Split into sub-Tasks (T1.1a, T1.1b)
+- Too small → Merge into a related Task
+- Each Task must have at least one testable acceptance criterion
+
+### User Story → Task Mapping
+
+```
+A single User Story may map to 1-3 Tasks:
+  US-001: As a new user, I want to register an account, so I can start using the product
+    → T1.1: Registration page UI
+    → T1.2: Registration API + data validation
+    → T1.3: Email verification flow (if needed for MVP)
+```