bmad-method 6.0.0-alpha.12 → 6.0.0-alpha.13

package/src/modules/bmm/workflows/2-plan-workflows/prd/steps/step-08-scoping.md

@@ -0,0 +1,280 @@
+# Step 8: Scoping Exercise - MVP & Future Features
+
+**Progress: Step 8 of 11** - Next: Functional Requirements
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without user input
+
+- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
+- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
+- ✅ ALWAYS treat this as collaborative discovery between PM peers
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- 💬 FOCUS on strategic scope decisions that keep projects viable
+- 🎯 EMPHASIZE lean MVP thinking while preserving long-term vision
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 📚 Review the complete PRD document built so far
+- ⚠️ Present A/P/C menu after generating scoping decisions
+- 💾 ONLY save when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]` before loading next step
+- 🚫 FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+This step will generate content and present choices:
+
+- **A (Advanced Elicitation)**: Use discovery protocols to explore innovative scoping approaches
+- **P (Party Mode)**: Bring multiple perspectives to ensure comprehensive scope decisions
+- **C (Continue)**: Save the scoping decisions and proceed to functional requirements
+
+## PROTOCOL INTEGRATION:
+
+- When 'A' selected: Execute {project-root}/{bmad_folder}/core/tasks/advanced-elicitation.xml
+- When 'P' selected: Execute {project-root}/{bmad_folder}/core/workflows/party-mode/workflow.md
+- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
+- User accepts/rejects protocol changes before proceeding
+
+## CONTEXT BOUNDARIES:
+
+- Complete PRD document built so far is available for review
+- User journeys, success criteria, and domain requirements are documented
+- Focus on strategic scope decisions, not feature details
+- Balance between user value and implementation feasibility
+
+## YOUR TASK:
+
+Conduct comprehensive scoping exercise to define MVP boundaries and prioritize features across development phases.
+
+## SCOPING SEQUENCE:
+
+### 1. Review Current PRD State
+
+Analyze everything documented so far:
+"I've reviewed your complete PRD so far. Here's what we've established:
+
+**Product Vision & Success:**
+{{summary_of_vision_and_success_criteria}}
+
+**User Journeys:** {{number_of_journeys}} mapped with rich narratives
+
+**Domain & Innovation Focus:**
+{{summary_of_domain_requirements_and_innovation}}
+
+**Current Scope Implications:**
+Based on everything we've documented, this looks like it could be:
+
+- [ ] Simple MVP (small team, lean scope)
+- [ ] Medium scope (moderate team, balanced features)
+- [ ] Complex project (large team, comprehensive scope)
+
+Does this initial assessment feel right, or do you see this differently?"
+
+### 2. Define MVP Strategy
+
+Facilitate strategic MVP decisions:
+
+"Let's think strategically about your launch strategy:
+
+**MVP Philosophy Options:**
+
+1. **Problem-Solving MVP**: Solve the core problem with minimal features
+2. **Experience MVP**: Deliver the key user experience with basic functionality
+3. **Platform MVP**: Build the foundation for future expansion
+4. **Revenue MVP**: Generate early revenue with essential features
+
+**Critical Questions:**
+
+- What's the minimum that would make users say 'this is useful'?
+- What would make investors/partners say 'this has potential'?
+- What's the fastest path to validated learning?
+
+**Which MVP approach feels right for {{project_name}}?**"
+
+### 3. Scoping Decision Framework
+
+Use structured decision-making for scope:
+
+**Must-Have Analysis:**
+"Let's identify absolute MVP necessities. For each journey and success criterion, ask:
+
+- **Without this, does the product fail?** (Y/N)
+- **Can this be manual initially?** (Y/N)
+- **Is this a deal-breaker for early adopters?** (Y/N)
+
+**Current Document Review:**
+Looking at your user journeys, what are the absolute core experiences that must work?
+
+{{analyze_journeys_for_mvp_essentials}}"
+
+**Nice-to-Have Analysis:**
+"Let's also identify what could be added later:
+
+**Post-MVP Enhancements:**
+
+- Features that enhance but aren't essential
+- User types that can be added later
+- Advanced functionality that builds on MVP
+
+**What features could we add in versions 2, 3, etc.?**"
+
+### 4. Progressive Feature Roadmap
+
+Create phased development approach:
+
+"Let's map your features across development phases:
+
+**Phase 1: MVP**
+
+- Core user value delivery
+- Essential user journeys
+- Basic functionality that works reliably
+
+**Phase 2: Growth**
+
+- Additional user types
+- Enhanced features
+- Scale improvements
+
+**Phase 3: Expansion**
+
+- Advanced capabilities
+- Platform features
+- New markets or use cases
+
+**Where does your current vision fit in this development sequence?**"
+
+### 5. Risk-Based Scoping
+
+Identify and mitigate scoping risks:
+
+**Technical Risks:**
+"Looking at your innovation and domain requirements:
+
+- What's the most technically challenging aspect?
+- Could we simplify the initial implementation?
+- What's the riskiest assumption about technology feasibility?"
+
+**Market Risks:**
+
+- What's the biggest market risk?
+- How does the MVP address this?
+- What learning do we need to de-risk this?"
+
+**Resource Risks:**
+
+- What if we have fewer resources than planned?
+- What's the absolute minimum team size needed?
+- Can we launch with a smaller feature set?"
+
+### 6. Generate Scoping Content
+
+Prepare comprehensive scoping section:
+
+#### Content Structure:
+
+```markdown
+## Project Scoping & Phased Development
+
+### MVP Strategy & Philosophy
+
+**MVP Approach:** {{chosen_mvp_approach}}
+**Resource Requirements:** {{mvp_team_size_and_skills}}
+
+### MVP Feature Set (Phase 1)
+
+**Core User Journeys Supported:**
+{{essential_journeys_for_mvp}}
+
+**Must-Have Capabilities:**
+{{list_of_essential_mvp_features}}
+
+### Post-MVP Features
+
+**Phase 2 (Post-MVP):**
+{{planned_growth_features}}
+
+**Phase 3 (Expansion):**
+{{planned_expansion_features}}
+
+### Risk Mitigation Strategy
+
+**Technical Risks:** {{mitigation_approach}}
+**Market Risks:** {{validation_approach}}
+**Resource Risks:** {{contingency_approach}}
+```
+
+### 7. Present Content and Menu
+
+Show the scoping decisions and present choices:
+
+"I've analyzed your complete PRD and created a strategic scoping plan for {{project_name}}.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 6]
+
+**What would you like to do?**
+[A] Advanced Elicitation - Explore alternative scoping strategies
+[P] Party Mode - Bring different perspectives on MVP and roadmap decisions
+[C] Continue - Save scoping decisions and move to Functional Requirements (Step 9 of 11)"
+
+### 8. Handle Menu Selection
+
+#### If 'A' (Advanced Elicitation):
+
+- Execute {project-root}/{bmad_folder}/core/tasks/advanced-elicitation.xml with current scoping analysis
+- Process enhanced scoping insights that come back
+- Ask user: "Accept these improvements to the scoping decisions? (y/n)"
+- If yes: Update content, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'P' (Party Mode):
+
+- Execute {project-root}/{bmad_folder}/core/workflows/party-mode/workflow.md with scoping context
+- Process collaborative insights on MVP and roadmap decisions
+- Ask user: "Accept these changes to the scoping decisions? (y/n)"
+- If yes: Update content, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'C' (Continue):
+
+- Append the final content to `{output_folder}/prd.md`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]`
+- Load `./step-09-functional.md`
+
+## APPEND TO DOCUMENT:
+
+When user selects 'C', append the content directly to the document using the structure from step 6.
+
+## SUCCESS METRICS:
+
+✅ Complete PRD document analyzed for scope implications
+✅ Strategic MVP approach defined and justified
+✅ Clear MVP feature boundaries established
+✅ Phased development roadmap created
+✅ Key risks identified and mitigation strategies defined
+✅ User explicitly agrees to scope decisions
+✅ A/P/C menu presented and handled correctly
+✅ Content properly appended to document when C selected
+
+## FAILURE MODES:
+
+❌ Not analyzing the complete PRD before making scoping decisions
+❌ Making scope decisions without strategic rationale
+❌ Not getting explicit user agreement on MVP boundaries
+❌ Missing critical risk analysis
+❌ Not creating clear phased development approach
+❌ Not presenting A/P/C menu after content generation
+
+❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
+❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
+❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
+
+## NEXT STEP:
+
+After user selects 'C' and content is saved to document, load `./step-09-functional.md`.
+
+Remember: Do NOT proceed to step-09 until user explicitly selects 'C' from the A/P/C menu and content is saved!

package/src/modules/bmm/workflows/2-plan-workflows/prd/steps/step-09-functional.md

@@ -0,0 +1,251 @@
+# Step 9: Functional Requirements Synthesis
+
+**Progress: Step 9 of 11** - Next: Non-Functional Requirements
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without user input
+
+- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
+- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
+- ✅ ALWAYS treat this as collaborative discovery between PM peers
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- 💬 FOCUS on creating comprehensive capability inventory for the product
+- 🎯 CRITICAL: This is THE CAPABILITY CONTRACT for all downstream work
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- ⚠️ Present A/P/C menu after generating functional requirements
+- 💾 ONLY save when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]` before loading next step
+- 🚫 FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+This step will generate content and present choices:
+
+- **A (Advanced Elicitation)**: Use discovery protocols to ensure comprehensive requirement coverage
+- **P (Party Mode)**: Bring multiple perspectives to validate complete requirement set
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## PROTOCOL INTEGRATION:
+
+- When 'A' selected: Execute {project-root}/{bmad_folder}/core/tasks/advanced-elicitation.xml
+- When 'P' selected: Execute {project-root}/{bmad_folder}/core/workflows/party-mode/workflow.md
+- PROTOCOLS always return to this step's A/P/C menu
+- User accepts/rejects protocol changes before proceeding
+
+## CONTEXT BOUNDARIES:
+
+- Current document and frontmatter from previous steps are available
+- ALL previous content (executive summary, success criteria, journeys, domain, innovation, project-type) must be referenced
+- No additional data files needed for this step
+- Focus on capabilities, not implementation details
+
+## CRITICAL IMPORTANCE:
+
+**This section defines THE CAPABILITY CONTRACT for the entire product:**
+
+- UX designers will ONLY design what's listed here
+- Architects will ONLY support what's listed here
+- Epic breakdown will ONLY implement what's listed here
+- If a capability is missing from FRs, it will NOT exist in the final product
+
+## FUNCTIONAL REQUIREMENTS SYNTHESIS SEQUENCE:
+
+### 1. Understand FR Purpose and Usage
+
+Start by explaining the critical role of functional requirements:
+
+**Purpose:**
+FRs define WHAT capabilities the product must have. They are the complete inventory of user-facing and system capabilities that deliver the product vision.
+
+**Critical Properties:**
+✅ Each FR is a testable capability
+✅ Each FR is implementation-agnostic (could be built many ways)
+✅ Each FR specifies WHO and WHAT, not HOW
+✅ No UI details, no performance numbers, no technology choices
+✅ Comprehensive coverage of capability areas
+
+**How They Will Be Used:**
+
+1. UX Designer reads FRs → designs interactions for each capability
+2. Architect reads FRs → designs systems to support each capability
+3. PM reads FRs → creates epics and stories to implement each capability
+
+### 2. Review Existing Content for Capability Extraction
+
+Systematically review all previous sections to extract capabilities:
+
+**Extract From:**
+
+- Executive Summary → Core product differentiator capabilities
+- Success Criteria → Success-enabling capabilities
+- User Journeys → Journey-revealed capabilities
+- Domain Requirements → Compliance and regulatory capabilities
+- Innovation Patterns → Innovative feature capabilities
+- Project-Type Requirements → Technical capability needs
+
+### 3. Organize Requirements by Capability Area
+
+Group FRs by logical capability areas (NOT by technology or layer):
+
+**Good Grouping Examples:**
+
+- ✅ "User Management" (not "Authentication System")
+- ✅ "Content Discovery" (not "Search Algorithm")
+- ✅ "Team Collaboration" (not "WebSocket Infrastructure")
+
+**Target 5-8 Capability Areas** for typical projects.
+
+### 4. Generate Comprehensive FR List
+
+Create complete functional requirements using this format:
+
+**Format:**
+
+- FR#: [Actor] can [capability] [context/constraint if needed]
+- Number sequentially (FR1, FR2, FR3...)
+- Aim for 20-50 FRs for typical projects
+
+**Altitude Check:**
+Each FR should answer "WHAT capability exists?" NOT "HOW it's implemented?"
+
+**Examples:**
+
+- ✅ "Users can customize appearance settings"
+- ❌ "Users can toggle light/dark theme with 3 font size options stored in LocalStorage"
+
+### 5. Self-Validation Process
+
+Before presenting to user, validate the FR list:
+
+**Completeness Check:**
+
+1. "Did I cover EVERY capability mentioned in the MVP scope section?"
+2. "Did I include domain-specific requirements as FRs?"
+3. "Did I cover the project-type specific needs?"
+4. "Could a UX designer read ONLY the FRs and know what to design?"
+5. "Could an Architect read ONLY the FRs and know what to support?"
+6. "Are there any user actions or system behaviors we discussed that have no FR?"
+
+**Altitude Check:**
+
+1. "Am I stating capabilities (WHAT) or implementation (HOW)?"
+2. "Am I listing acceptance criteria or UI specifics?" (Remove if yes)
+3. "Could this FR be implemented 5 different ways?" (Good - means it's not prescriptive)
+
+**Quality Check:**
+
+1. "Is each FR clear enough that someone could test whether it exists?"
+2. "Is each FR independent (not dependent on reading other FRs to understand)?"
+3. "Did I avoid vague terms like 'good', 'fast', 'easy'?" (Use NFRs for quality attributes)
+
+### 6. Generate Functional Requirements Content
+
+Prepare the content to append to the document:
+
+#### Content Structure:
+
+When saving to document, append these Level 2 and Level 3 sections:
+
+```markdown
+## Functional Requirements
+
+### [Capability Area Name]
+
+- FR1: [Specific Actor] can [specific capability]
+- FR2: [Specific Actor] can [specific capability]
+- FR3: [Specific Actor] can [specific capability]
+
+### [Another Capability Area]
+
+- FR4: [Specific Actor] can [specific capability]
+- FR5: [Specific Actor] can [specific capability]
+
+[Continue for all capability areas discovered in conversation]
+```
+
+### 7. Present Content and Menu
+
+Show the generated functional requirements and present choices:
+"I've synthesized all our discussions into comprehensive functional requirements. This becomes the capability contract that UX designers, architects, and developers will all work from.
+
+**Here's what I'll add to the document:**
+
+[Show the complete FR list from step 6]
+
+**This is critical because:**
+
+- Every feature we build must trace back to one of these requirements
+- UX designers will ONLY design interactions for these capabilities
+- Architects will ONLY build systems to support these capabilities
+
+**What would you like to do?**
+[A] Advanced Elicitation - Let's ensure we haven't missed any capabilities
+[P] Party Mode - Bring different perspectives to validate complete coverage
+[C] Continue - Save this and move to Non-Functional Requirements (Step 10 of 11)"
+
+### 8. Handle Menu Selection
+
+#### If 'A' (Advanced Elicitation):
+
+- Execute {project-root}/{bmad_folder}/core/tasks/advanced-elicitation.xml with the current FR list
+- Process the enhanced capability coverage that comes back
+- Ask user: "Accept these additions to the functional requirements? (y/n)"
+- If yes: Update content with improvements, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'P' (Party Mode):
+
+- Execute {project-root}/{bmad_folder}/core/workflows/party-mode/workflow.md with the current FR list
+- Process the collaborative capability validation and additions
+- Ask user: "Accept these changes to the functional requirements? (y/n)"
+- If yes: Update content with improvements, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'C' (Continue):
+
+- Append the final content to `{output_folder}/prd.md`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]`
+- Load `{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/prd/steps/step-10-nonfunctional.md`
+
+## APPEND TO DOCUMENT:
+
+When user selects 'C', append the content directly to the document using the structure from step 6.
+
+## SUCCESS METRICS:
+
+✅ All previous discovery content synthesized into FRs
+✅ FRs organized by capability areas (not technology)
+✅ Each FR states WHAT capability exists, not HOW to implement
+✅ Comprehensive coverage with 20-50 FRs typical
+✅ Altitude validation ensures implementation-agnostic requirements
+✅ Completeness check validates coverage of all discussed capabilities
+✅ A/P/C menu presented and handled correctly
+✅ Content properly appended to document when C selected
+
+## FAILURE MODES:
+
+❌ Missing capabilities from previous discovery sections
+❌ Organizing FRs by technology instead of capability areas
+❌ Including implementation details or UI specifics in FRs
+❌ Not achieving comprehensive coverage of discussed capabilities
+❌ Using vague terms instead of testable capabilities
+❌ Not presenting A/P/C menu after content generation
+❌ Appending content without user selecting 'C'
+
+❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
+❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
+❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
+
+## CAPABILITY CONTRACT REMINDER:
+
+Emphasize to user: "This FR list is now binding. Any feature not listed here will not exist in the final product unless we explicitly add it. This is why it's critical to ensure completeness now."
+
+## NEXT STEP:
+
+After user selects 'C' and content is saved to document, load `{project-root}/{bmad_folder}/bmm/workflows/2-plan-workflows/prd/steps/step-10-nonfunctional.md` to define non-functional requirements.
+
+Remember: Do NOT proceed to step-10 until user explicitly selects 'C' from the A/P/C menu and content is saved!