@cliangdev/flux-plugin 0.2.0 → 0.3.0

package/skills/prd-writer/SKILL.md

@@ -0,0 +1,761 @@
+---
+name: flux:prd-writer
+description: Comprehensive guide for creating PRDs that are concise for humans and detailed enough for AI implementation. Use when creating, refining, or reviewing product requirement documents. This skill drives the entire PRD creation workflow.
+user-invocable: false
+---
+
+# PRD Writer Skill
+
+This skill guides the creation of **Product Requirement Documents** that serve two audiences:
+1. **Humans** - who need to understand and approve the vision
+2. **AI Agents** - who need unambiguous specifications to implement
+
+## Core Principle: Specification as Contract
+
+A PRD is a contract between the product vision and the implementation. Every feature must have:
+- **Clear scope** - What's in, what's out
+- **Testable criteria** - How do we know it works?
+- **Edge cases** - What could go wrong?
+
+---
+
+## PRD Scoping: Right-Sizing Your PRDs
+
+### The Golden Rule
+
+**One PRD = One implementable unit that delivers standalone value.**
+
+A well-scoped PRD should:
+- Be completable in 1-3 weeks of focused work
+- Result in 15-25 tasks when broken down
+- Deliver something usable/testable on its own
+- Have clear boundaries that don't leak into other features
+
+### Scope Assessment Matrix
+
+| Indicator | Right-Sized PRD | Too Large (Split It) |
+|-----------|-----------------|----------------------|
+| Major features | 3-5 related features | 6+ distinct features |
+| User flows | 1-2 main journeys | 3+ separate journeys |
+| Technical domains | Focused area | Frontend + Backend + Infra + DevOps |
+| User personas | 1-2 related personas | Multiple distinct user types |
+| Estimated tasks | 15-25 tasks | 30+ tasks |
+| Dependencies | Few external deps | Multiple other systems |
+
+### When to Split: Red Flags
+
+🚩 **"Build a mobile app"** → Too vague. What features? For whom?
+
+🚩 **"Full e-commerce platform"** → Contains auth, catalog, cart, checkout, payments, orders, admin...
+
+🚩 **"Complete user management"** → Could mean signup, profiles, roles, permissions, teams, invites, admin...
+
+🚩 **Multiple distinct user types** → Admin dashboard + Customer portal = 2 PRDs minimum
+
+### Multi-PRD Project Structure
+
+For large projects, organize PRDs into phases:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    PROJECT: Task Manager App                 │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  FOUNDATION LAYER (implement first)                         │
+│  ┌─────────────────┐    ┌─────────────────┐                │
+│  │ Project Setup   │───▶│ Authentication  │                │
+│  │ [foundation]    │    │ [foundation]    │                │
+│  └─────────────────┘    └────────┬────────┘                │
+│                                  │                          │
+│  MVP LAYER                       ▼                          │
+│  ┌─────────────────┐    ┌─────────────────┐                │
+│  │ Task CRUD       │    │ Task Lists      │                │
+│  │ [mvp]           │◀───│ [mvp]           │                │
+│  └─────────────────┘    └─────────────────┘                │
+│                                                             │
+│  POST-MVP LAYER                                             │
+│  ┌─────────────────┐    ┌─────────────────┐                │
+│  │ Sharing &       │    │ Notifications   │                │
+│  │ Collaboration   │    │ [post-mvp]      │                │
+│  │ [post-mvp]      │    └─────────────────┘                │
+│  └─────────────────┘                                        │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### PRD Tags
+
+Use tags to organize related PRDs:
+
+| Tag | Meaning | When to Use |
+|-----|---------|-------------|
+| `foundation` | Core infrastructure | Setup, auth, database schema, core APIs |
+| `mvp` | Minimum viable product | Essential features for first release |
+| `mvp-phase-2` | Second wave of MVP | Important but not launch-blocking |
+| `post-mvp` | Future enhancements | Nice-to-have, can wait |
+| `experimental` | Exploratory | R&D, prototypes, uncertain scope |
+| `bugfix` | Defect correction | Addressing issues in existing features |
+| `refactor` | Technical improvement | No new features, internal quality |
+
+### PRD Dependencies
+
+When PRDs depend on each other, document it clearly:
+
+**In the Constraints section:**
+```markdown
+## Constraints
+
+### PRD Dependencies
+- **Requires**: [Authentication PRD](./auth/prd.md) (FLUX-P1) - Need user model and JWT middleware
+- **Blocks**: [Notifications PRD](./notifications/prd.md) (FLUX-P4) - Will need task events
+
+### Shared Components
+- Uses User model from Authentication PRD
+- Extends base API patterns from Project Setup PRD
+```
+
+### Example: Splitting a Large Scope
+
+**User says**: "I want to build a fitness tracking app"
+
+**❌ Bad (too large)**:
+```
+PRD: Fitness Tracking App
+Features:
+- User accounts
+- Workout logging
+- Exercise library
+- Progress charts
+- Social features
+- Meal tracking
+- Sleep tracking
+- Wearable integration
+- Premium subscriptions
+```
+
+**✅ Good (split into focused PRDs)**:
+
+```
+PRD 1: Project Foundation [foundation]
+- Project setup, CI/CD, deployment
+- Core data models
+- API structure
+Dependencies: None
+
+PRD 2: User Authentication [foundation]
+- Sign up, login, profile
+- Password reset
+Dependencies: PRD 1
+
+PRD 3: Workout Logging [mvp]
+- Log workouts manually
+- View workout history
+- Basic exercise library
+Dependencies: PRD 2
+
+PRD 4: Progress Tracking [mvp]
+- Dashboard with charts
+- Weekly/monthly summaries
+Dependencies: PRD 3
+
+PRD 5: Social Features [post-mvp]
+- Follow friends
+- Share workouts
+- Leaderboards
+Dependencies: PRD 2, PRD 3
+```
+
+### Scope Negotiation
+
+When scope is too large, guide the user:
+
+```
+This is a substantial project. Let me help you break it down:
+
+**Option A: Start with foundation**
+Begin with authentication and core infrastructure. Other features build on this.
+
+**Option B: Pick one user journey**
+What's the ONE thing users must be able to do? Let's nail that first.
+
+**Option C: Define MVP strictly**
+What could you launch with in 2 weeks that would be useful?
+
+Which approach works for you?
+```
+
+---
+
+## PRD Structure (Required Sections)
+
+### For Local Adapter (files in `.flux/prds/`)
+
+```markdown
+# {Project Name}
+
+> **Tag**: {foundation | mvp | mvp-phase-2 | post-mvp | experimental}
+> **Depends on**: {None | List of PRD refs like FLUX-P1, FLUX-P2}
+> **Blocks**: {None | List of PRD refs that depend on this}
+
+## Table of Contents
+- [Problem](#problem)
+- [Users](#users)
+- [Solution](#solution)
+- [Features (MVP)](#features-mvp)
+  - [P0: Must Have](#p0-must-have)
+  - [P1: Should Have](#p1-should-have)
+  - [Out of Scope](#out-of-scope)
+- [Technical Context](#technical-context)
+- [Constraints](#constraints)
+- [Open Questions](#open-questions)
+
+## Problem
+{2-3 sentences: What pain point are we solving? Why does it matter now?}
+
+## Users
+{Who experiences this problem? Be specific about user segments.}
+
+## Solution
+{1 paragraph: What are we building? How does it solve the problem?}
+
+## Features
+
+### P0: Must Have
+
+For each feature, use the What/Not pattern:
+
+- **{Feature Name}**: {One-line description}
+  - **What**: {Specific scope - what IS included}
+  - **Not**: {Explicit exclusions - prevents scope creep}
+  - **Acceptance Criteria**:
+    - [ ] {Input → expected output, testable by AI}
+    - [ ] {Another criterion with specific values}
+  - **Edge Cases**:
+    - {Scenario}: {Expected behavior}
+
+### P1: Should Have
+
+- **{Feature}**: {Description}
+  - {Brief acceptance criteria - less detail than P0}
+
+### Out of Scope
+- {What we're explicitly NOT building}
+- {Future considerations deferred}
+
+## Technical Context
+
+### Existing Patterns
+{Describe relevant existing code patterns the implementation should follow.}
+{Reference key files/modules that will be extended or modified.}
+
+### Tech Stack
+- **{Layer}**: {Technology} - {Why this choice}
+
+### API Design (if applicable)
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | /api/... | ... |
+
+## Constraints
+- **Timeline**: {Any deadlines}
+- **PRD Dependencies**: {What must be completed before this PRD can start}
+- **External Dependencies**: {APIs, services, third-party systems}
+- **Performance**: {SLAs, limits}
+
+## Open Questions
+- [ ] {Unresolved decision needing stakeholder input}
+```
+
+**Note**: The metadata block at the top (Tag, Depends on, Blocks) is optional for standalone PRDs but required for multi-PRD projects.
+
+### For External Adapters (Linear, Notion)
+
+**Skip the Table of Contents** - external systems have their own navigation.
+
+---
+
+## Writing for Two Audiences
+
+A PRD must satisfy both humans and AI agents:
+
+| Audience | Needs | What They Read |
+|----------|-------|----------------|
+| **Humans** | Quick understanding, approve/reject decisions | Problem, Solution, feature summaries |
+| **AI Agents** | Unambiguous specs for autonomous implementation | Acceptance criteria, edge cases, code references |
+
+### Size Guidelines
+
+| Section | Target | Guidance |
+|---------|--------|----------|
+| Problem | 2-3 sentences | What pain? Why now? Who suffers? |
+| Solution | 1 paragraph | What we're building, how it solves the problem |
+| P0 Features | 3-5 features | The true MVP, nothing more |
+| Each Feature | 5-10 criteria | Enough for AI to implement without guessing |
+| Total PRD | 1-2 pages | Fits on one screen when scrolling |
+
+---
+
+## Feature Writing: The What/Not Pattern
+
+Every P0 feature must have explicit boundaries. Use the **What/Not** pattern to prevent scope creep and give AI clear implementation guidance.
+
+### Feature Template
+
+```markdown
+- **{Feature Name}**: {One-line description}
+  - **What**: {Specific scope - what IS included}
+  - **Not**: {Explicit exclusions - what is NOT included}
+  - **Acceptance Criteria**:
+    - [ ] {Testable criterion with specific input → expected output}
+    - [ ] {Another criterion - AI can verify pass/fail}
+  - **Edge Cases**:
+    - {Scenario}: {Expected behavior}
+```
+
+### Feature Quality Ladder
+
+**Level 1: Vague** (human might understand, AI cannot implement)
+```markdown
+- User authentication
+```
+*Problem: What kind? Email? OAuth? What flows?*
+
+**Level 2: Named** (clearer, still ambiguous)
+```markdown
+- **User Authentication**: Users can sign up and log in
+```
+*Problem: What about logout? Password reset? Validation rules?*
+
+**Level 3: Scoped** (boundaries defined)
+```markdown
+- **User Authentication**: Email/password auth for user accounts
+  - **What**: Sign up, login, logout, password reset
+  - **Not**: OAuth, 2FA, social login, magic links
+```
+*Better: AI knows the boundaries. Still lacks implementation detail.*
+
+**Level 4: Implementable** (AI can build autonomously)
+```markdown
+- **User Authentication**: Email/password auth for user accounts
+  - **What**: Sign up, login, logout, password reset via email
+  - **Not**: OAuth, 2FA, social login, magic links, session management (use JWT)
+  - **Acceptance Criteria**:
+    - [ ] POST /auth/signup with {email, password, name} → 201 + user object (no password)
+    - [ ] POST /auth/login with valid credentials → 200 + {token, user}
+    - [ ] POST /auth/login with wrong password → 401 + {error: "Invalid credentials"}
+    - [ ] POST /auth/logout with valid token → 200 (token invalidated)
+    - [ ] Password minimum 8 chars; shorter rejected with 400 + validation error
+    - [ ] Email must be valid format; malformed rejected with 400
+  - **Edge Cases**:
+    - Duplicate email on signup: 409 Conflict + {error: "Email already registered"}
+    - Login with non-existent email: 401 (same as wrong password, for security)
+    - Expired token on protected routes: 401 + {error: "Token expired"}
+    - Rate limiting: 429 after 5 failed login attempts per email in 1 minute
+```
+*This is AI-ready: specific endpoints, status codes, error messages, edge cases.*
+
+### Acceptance Criteria Rules
+
+1. **Use input → output format**: `POST /path with {data} → status + {response}`
+2. **Include failure cases**: Don't just test happy paths
+3. **Specify exact values**: "400" not "error", "8 chars" not "short password"
+4. **Be deterministic**: AI should know exactly what to assert in tests
+
+### Edge Cases Worth Documenting
+
+Not every edge case matters. Focus on:
+
+| Include | Skip |
+|---------|------|
+| Security boundaries (auth failures, rate limits) | Obvious validations (null checks) |
+| Business rule exceptions | Framework-handled errors |
+| Data conflicts (duplicates, race conditions) | Infrastructure issues (DB down) |
+| User journey dead ends | Extremely rare scenarios |
+
+---
+
+## Research Phase: What to Investigate
+
+Before writing the PRD, research the following:
+
+### 1. Codebase Context
+- **Project structure**: What patterns are already established?
+- **Existing modules**: What can be reused or extended?
+- **Tech stack**: What frameworks/libraries are in use?
+- **Testing patterns**: How are tests structured?
+
+### 2. Similar Features
+- Look for similar functionality in the codebase
+- Note patterns, naming conventions, file organization
+- Identify shared utilities or base classes
+
+### 3. Technical Feasibility
+- Are there any technical blockers?
+- What dependencies are needed?
+- Are there security considerations?
+
+### 4. Prior Art (External)
+- How do similar products solve this?
+- Any best practices or anti-patterns to know?
+
+---
+
+## Project-Type Specific Guidance
+
+### Web Application
+**Key questions**:
+- What's the authentication model?
+- What data needs persistence?
+- What are the main user flows?
+
+**Common epics**:
+- Project Setup & Configuration
+- Database Schema & Models
+- Authentication/Authorization
+- Core Feature(s)
+- UI/Frontend
+
+### CLI Tool
+**Key questions**:
+- What commands are needed?
+- What's the input/output format?
+- How does configuration work?
+
+**Common epics**:
+- Command Parser & Help
+- Core Command Implementation
+- Configuration Management
+- Output Formatting
+
+### API/Backend Service
+**Key questions**:
+- What's the API contract?
+- What are the data models?
+- What external services integrate?
+
+**Common epics**:
+- API Design & Documentation
+- Data Models & Storage
+- Core Endpoints
+- Authentication & Security
+- Error Handling & Logging
+
+### Library/Package
+**Key questions**:
+- What's the public API surface?
+- What are the main use cases?
+- How should errors be handled?
+
+**Common epics**:
+- API Design
+- Core Implementation
+- Error Handling
+- Documentation & Examples
+
+---
+
+## Supporting Documents (Optional)
+
+Generate based on project complexity and user needs.
+
+| Document | When Useful | Content |
+|----------|-------------|---------|
+| `architecture.md` | Multi-component systems | System diagram, API endpoints, data flow |
+| `data-model.md` | Custom data storage | ERD, table schemas, relationships |
+| `wireframes.md` | UI-heavy features | ASCII wireframes, element descriptions |
+| `user-flows.md` | Complex journeys | Step-by-step user paths |
+
+### When to Offer Supporting Docs
+
+After PRD approval, ask based on project type:
+- **Web App**: Offer architecture, wireframes
+- **API/Backend**: Offer architecture, data-model
+- **CLI Tool**: Usually just PRD is sufficient
+- **Mobile App**: Offer architecture, wireframes
+
+---
+
+## Workflow: Three-Phase PRD Creation
+
+### Phase 1: Discovery (Gather Intent)
+
+**Goal**: Understand what the user wants to build.
+
+1. **Initial prompt**: "What are you trying to build?"
+2. **Follow-up based on response**:
+   - If vague: "Can you describe the problem you're solving?"
+   - If clear: "Who is this for? Who experiences this problem?"
+3. **Scope clarification**: "What's the minimum that would be useful?"
+
+**Gather**:
+- Problem statement
+- Target users
+- Core functionality (what, not how)
+- Any known constraints
+
+### Phase 2: Research (Understand Context)
+
+**Goal**: Gather technical context to inform the PRD.
+
+#### Step 2.0: Greenfield Detection & Setup
+
+**Before exploring the codebase, check if this is a greenfield project.**
+
+##### Detection
+
+Check for project indicators:
+```
+- .git directory exists?
+- package.json / go.mod / pyproject.toml / Cargo.toml / etc.?
+- src/ or lib/ directories with code files?
+- Any meaningful source files?
+```
+
+**If ALL indicators are missing → Greenfield project → Trigger setup flow**
+
+##### Essential Setup Flow
+
+When greenfield is detected, present:
+
+```
+This looks like a new project without existing setup.
+
+Before we create the PRD, let's establish the foundation:
+
+**Git Setup**
+- Initialize repository with .gitignore
+- Create branching structure: main + develop (git flow ready)
+- Initial commit with project structure
+
+**Project Structure** (based on {detected project type from Phase 1})
+{Show recommended minimal structure for the project type}
+
+**Package Setup**
+- Initialize {package.json / pyproject.toml / go.mod / etc.}
+- Add essential dev dependencies
+
+Proceed with this setup?
+```
+
+Use AskUserQuestion:
+- "Yes, set up essentials" (Recommended)
+- "Customize setup first"
+- "Skip - I'll set up manually"
+
+##### Essential Setup by Project Type
+
+| Project Type | Git | Structure | Package Init |
+|--------------|-----|-----------|--------------|
+| **Web App (Node)** | .gitignore (node) | `src/`, `tests/`, `public/` | package.json with scripts |
+| **Web App (Python)** | .gitignore (python) | `src/`, `tests/` | pyproject.toml |
+| **CLI Tool (Node)** | .gitignore (node) | `src/`, `bin/`, `tests/` | package.json with bin |
+| **CLI Tool (Go)** | .gitignore (go) | `cmd/`, `internal/`, `pkg/` | go.mod |
+| **API/Backend** | .gitignore (lang) | `src/`, `tests/`, `config/` | Language-specific |
+| **Library** | .gitignore (lang) | `src/`, `tests/`, `examples/` | Language-specific |
+
+##### Executing Essential Setup
+
+When user confirms, execute these commands:
+
+```bash
+# Git initialization
+git init
+git checkout -b main
+git checkout -b develop
+
+# Create .gitignore (language-appropriate)
+# Create initial directory structure
+# Initialize package manager
+
+# Initial commit
+git add .
+git commit -m "Initial project setup
+
+- Initialize git with main/develop branches
+- Add .gitignore for {language}
+- Create project structure
+- Initialize {package manager}
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>"
+
+# Return to develop for feature work
+git checkout develop
+```
+
+##### Foundation PRD Offer
+
+After essential setup completes (or if user skipped), offer comprehensive setup as a tracked PRD:
+
+```
+Foundation is ready. Would you like to track additional setup as a PRD?
+
+A Foundation PRD would include:
+- CI/CD pipeline (GitHub Actions / GitLab CI)
+- Linting & formatting (ESLint+Prettier / Ruff / etc.)
+- Testing framework setup
+- Environment configuration (.env patterns)
+- Pre-commit hooks
+- Documentation structure
+
+This gets tracked in Flux so you can implement it systematically.
+```
+
+Use AskUserQuestion:
+- "Create Foundation PRD" - Creates PRD with [tag: foundation], then continues to feature PRD
+- "Skip - continue to feature PRD" (Recommended for simple projects)
+
+##### Foundation PRD Template
+
+If user wants a Foundation PRD, create it with this structure:
+
+```markdown
+# Project Foundation
+
+> **Tag**: foundation
+> **Depends on**: None
+> **Blocks**: All feature PRDs
+
+## Problem
+
+New projects without proper tooling lead to inconsistent code quality,
+manual testing overhead, and deployment friction.
+
+## Users
+
+Developers working on this codebase.
+
+## Solution
+
+Establish development infrastructure: CI/CD, code quality tools, testing
+framework, and environment management.
+
+## Features
+
+### P0: Must Have
+
+- **CI Pipeline**: Automated testing on push/PR
+  - **What**: GitHub Actions (or GitLab CI) workflow for test/lint/build
+  - **Not**: Deployment pipelines (separate PRD), complex matrix builds
+  - **Acceptance Criteria**:
+    - [ ] Push to any branch triggers CI
+    - [ ] PR cannot merge if CI fails
+    - [ ] CI runs tests, linting, and type checking
+
+- **Code Quality**: Linting and formatting
+  - **What**: {ESLint+Prettier / Biome / Ruff / etc.} with pre-commit hooks
+  - **Not**: Custom rules beyond standard configs
+  - **Acceptance Criteria**:
+    - [ ] `{lint command}` runs without errors on codebase
+    - [ ] Pre-commit hook prevents committing unlinted code
+    - [ ] Editor integration documented in README
+
+- **Testing Framework**: Test infrastructure
+  - **What**: {Jest/Vitest / Pytest / Go test} configured with coverage
+  - **Not**: E2E tests, integration test infrastructure
+  - **Acceptance Criteria**:
+    - [ ] `{test command}` runs and reports coverage
+    - [ ] Example test file demonstrates testing patterns
+    - [ ] Coverage threshold configured (suggest 70%)
+
+### P1: Should Have
+
+- **Environment Config**: .env management
+  - .env.example with all required variables documented
+  - Validation on startup for required env vars
+
+- **Documentation**: README and contributing guide
+  - Setup instructions
+  - Development workflow
+  - How to run tests
+
+### Out of Scope
+- Deployment pipelines (separate DevOps PRD)
+- Production infrastructure
+- Monitoring and observability
+```
+
+After creating Foundation PRD, continue to the user's feature PRD with proper dependency:
+- Set feature PRD's `Depends on: {Foundation PRD ref}`
+
+---
+
+#### Step 2.1: Codebase Exploration
+
+Spawn a research agent to:
+1. **Explore the codebase** (if exists):
+   - Project structure and patterns
+   - Existing similar features
+   - Tech stack and testing approach
+2. **Research externally** (if needed):
+   - Similar solutions in the ecosystem
+   - Best practices for this type of feature
+   - Potential libraries or tools
+
+**Output**: Technical context section of the PRD.
+
+### Phase 3: Generate (Create AI-Ready PRD)
+
+**Goal**: Produce a PRD ready for breakdown and implementation.
+
+1. **Draft PRD** using the template structure above
+2. **Review with user**: Present outline, ask for feedback
+3. **Refine**: Incorporate feedback
+4. **Store**:
+   - Local adapter: Write to `.flux/prds/{slug}/prd.md`
+   - External adapter: Store in description field
+5. **Offer supporting docs** based on project type
+
+---
+
+## Quality Checklist
+
+Before finalizing a PRD, verify:
+
+### Scope
+- [ ] PRD is right-sized (15-25 tasks when broken down)
+- [ ] Scope is achievable in 1-3 weeks
+- [ ] Features are cohesive (belong together)
+- [ ] If multi-PRD project, dependencies are documented
+- [ ] Tag is assigned (foundation/mvp/post-mvp/etc.)
+
+### Content
+- [ ] Problem statement is specific (not generic)
+- [ ] Solution clearly addresses the problem
+- [ ] Each P0 feature has acceptance criteria
+- [ ] Acceptance criteria are testable (pass/fail determinable)
+- [ ] Edge cases are identified for complex features
+- [ ] Technical context reflects actual codebase (if applicable)
+- [ ] Out of Scope is explicit about what's NOT included
+- [ ] Open Questions are actionable (can be resolved)
+
+---
+
+## Anti-Patterns to Avoid
+
+### 1. Solution Masquerading as Problem
+❌ "We need a React dashboard"
+✅ "Users can't see their data at a glance"
+
+### 2. Implementation Details in Features
+❌ "Use Redux for state management"
+✅ "App state persists across page refreshes"
+
+### 3. Vague Acceptance Criteria
+❌ "System should be fast"
+✅ "API responses complete in < 200ms for 95th percentile"
+
+### 4. Missing Scope Boundaries
+❌ "User management" (how much?)
+✅ "User management: CRUD for users. No roles, no permissions, no team features."
+
+### 5. Ignoring Existing Patterns
+❌ Proposing new patterns when established ones exist
+✅ "Following existing auth middleware pattern in `src/middleware/auth.ts`"
+
+### 6. Boiling the Ocean
+❌ "Build a complete e-commerce platform with user accounts, product catalog, shopping cart, checkout, payments, order management, inventory, shipping integration, admin dashboard, analytics, and mobile apps"
+✅ Split into 8-10 focused PRDs with clear dependencies
+
+### 7. Orphan PRDs
+❌ Creating a PRD that can't be implemented without undefined prerequisites
+✅ Explicitly list dependencies; create foundation PRDs first