bmad-method 6.0.0-alpha.2 → 6.0.0-alpha.21

package/src/modules/bmm/workflows/2-plan-workflows/prd/steps/step-10-nonfunctional.md

@@ -0,0 +1,293 @@
+---
+name: 'step-10-nonfunctional'
+description: 'Define quality attributes that matter for this specific product'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/2-plan-workflows/prd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-10-nonfunctional.md'
+nextStepFile: '{workflow_path}/steps/step-11-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{planning_artifacts}/prd.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 10: Non-Functional Requirements
+
+**Progress: Step 10 of 11** - Next: Complete PRD
+
+## 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 quality attributes that matter for THIS specific product
+- 🎯 SELECTIVE: Only document NFRs that actually apply to the product
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- ⚠️ Present A/P/C menu after generating NFR content
+- 💾 ONLY save when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]` 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 quality attributes
+- **P (Party Mode)**: Bring technical perspectives to validate NFR completeness
+- **C (Continue)**: Save the content to the document and proceed to final step
+
+## PROTOCOL INTEGRATION:
+
+- When 'A' selected: Execute {project-root}/_bmad/core/tasks/advanced-elicitation.xml
+- When 'P' selected: Execute {project-root}/_bmad/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
+- Functional requirements already defined and will inform NFRs
+- Domain and project-type context will guide which NFRs matter
+- Focus on specific, measurable quality criteria
+
+## YOUR TASK:
+
+Define non-functional requirements that specify quality attributes for the product, focusing only on what matters for THIS specific product.
+
+## NON-FUNCTIONAL REQUIREMENTS SEQUENCE:
+
+### 1. Explain NFR Purpose and Scope
+
+Start by clarifying what NFRs are and why we're selective:
+
+**NFR Purpose:**
+NFRs define HOW WELL the system must perform, not WHAT it must do. They specify quality attributes like performance, security, scalability, etc.
+
+**Selective Approach:**
+We only document NFRs that matter for THIS product. If a category doesn't apply, we skip it entirely. This prevents requirement bloat and focuses on what's actually important.
+
+### 2. Assess Product Context for NFR Relevance
+
+Evaluate which NFR categories matter based on product context:
+
+**Quick Assessment Questions:**
+
+- **Performance**: Is there user-facing impact of speed?
+- **Security**: Are we handling sensitive data or payments?
+- **Scalability**: Do we expect rapid user growth?
+- **Accessibility**: Are we serving broad public audiences?
+- **Integration**: Do we need to connect with other systems?
+- **Reliability**: Would downtime cause significant problems?
+
+### 3. Explore Relevant NFR Categories
+
+For each relevant category, conduct targeted discovery:
+
+#### Performance NFRs (If relevant):
+
+"Let's talk about performance requirements for {{project_name}}.
+
+**Performance Questions:**
+
+- What parts of the system need to be fast for users to be successful?
+- Are there specific response time expectations?
+- What happens if performance is slower than expected?
+- Are there concurrent user scenarios we need to support?"
+
+#### Security NFRs (If relevant):
+
+"Security is critical for products that handle sensitive information.
+
+**Security Questions:**
+
+- What data needs to be protected?
+- Who should have access to what?
+- What are the security risks we need to mitigate?
+- Are there compliance requirements (GDPR, HIPAA, PCI-DSS)?"
+
+#### Scalability NFRs (If relevant):
+
+"Scalability matters if we expect growth or have variable demand.
+
+**Scalability Questions:**
+
+- How many users do we expect initially? Long-term?
+- Are there seasonal or event-based traffic spikes?
+- What happens if we exceed our capacity?"
+- What growth scenarios should we plan for?"
+
+#### Accessibility NFRs (If relevant):
+
+"Accessibility ensures the product works for users with disabilities.
+
+**Accessibility Questions:**
+
+- Are we serving users with visual, hearing, or motor impairments?
+- Are there legal accessibility requirements (WCAG, Section 508)?
+- What accessibility features are most important for our users?"
+
+#### Integration NFRs (If relevant):
+
+"Integration requirements matter for products that connect to other systems.
+
+**Integration Questions:**
+
+- What external systems do we need to connect with?
+- Are there APIs or data formats we must support?
+- How reliable do these integrations need to be?"
+
+### 4. Make NFRs Specific and Measurable
+
+For each relevant NFR category, ensure criteria are testable:
+
+**From Vague to Specific:**
+
+- NOT: "The system should be fast" → "User actions complete within 2 seconds"
+- NOT: "The system should be secure" → "All data is encrypted at rest and in transit"
+- NOT: "The system should scale" → "System supports 10x user growth with <10% performance degradation"
+
+### 5. Generate NFR Content (Only Relevant Categories)
+
+Prepare the content to append to the document:
+
+#### Content Structure (Dynamic based on relevance):
+
+When saving to document, append these Level 2 and Level 3 sections (only include sections that are relevant):
+
+```markdown
+## Non-Functional Requirements
+
+### Performance
+
+[Performance requirements based on conversation - only include if relevant]
+
+### Security
+
+[Security requirements based on conversation - only include if relevant]
+
+### Scalability
+
+[Scalability requirements based on conversation - only include if relevant]
+
+### Accessibility
+
+[Accessibility requirements based on conversation - only include if relevant]
+
+### Integration
+
+[Integration requirements based on conversation - only include if relevant]
+```
+
+### 6. Present Content and Menu
+
+Show the generated NFR content and present choices:
+"I've defined the non-functional requirements that specify how well {{project_name}} needs to perform. I've only included categories that actually matter for this product.
+
+**Here's what I'll add to the document:**
+
+[Show the complete NFR content from step 5]
+
+**Note:** We've skipped categories that don't apply to avoid unnecessary requirements.
+
+**What would you like to do?**
+[A] Advanced Elicitation - Let's ensure we haven't missed critical quality attributes
+[P] Party Mode - Bring technical perspectives to validate NFR specifications
+[C] Continue - Save this and move to Complete PRD (Step 11 of 11)"
+
+### 7. Handle Menu Selection
+
+#### If 'A' (Advanced Elicitation):
+
+- Execute {project-root}/_bmad/core/tasks/advanced-elicitation.xml with the current NFR content
+- Process the enhanced quality attribute insights that come back
+- Ask user: "Accept these improvements to the non-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/core/workflows/party-mode/workflow.md with the current NFR list
+- Process the collaborative technical validation and additions
+- Ask user: "Accept these changes to the non-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 `{outputFile}`
+- Update frontmatter: add this step name to the end of the steps completed array
+- Load `{project-root}/_bmad/bmm/workflows/2-plan-workflows/prd/steps/step-11-complete.md`
+
+## APPEND TO DOCUMENT:
+
+When user selects 'C', append the content directly to the document using the structure from step 5.
+
+## SUCCESS METRICS:
+
+✅ Only relevant NFR categories documented (no requirement bloat)
+✅ Each NFR is specific and measurable
+✅ NFRs connected to actual user needs and business context
+✅ Vague requirements converted to testable criteria
+✅ Domain-specific compliance requirements included if relevant
+✅ A/P/C menu presented and handled correctly
+✅ Content properly appended to document when C selected
+
+## FAILURE MODES:
+
+❌ Documenting NFR categories that don't apply to the product
+❌ Leaving requirements vague and unmeasurable
+❌ Not connecting NFRs to actual user or business needs
+❌ Missing domain-specific compliance requirements
+❌ Creating overly prescriptive technical requirements
+❌ 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
+
+## NFR CATEGORY GUIDANCE:
+
+**Include Performance When:**
+
+- User-facing response times impact success
+- Real-time interactions are critical
+- Performance is a competitive differentiator
+
+**Include Security When:**
+
+- Handling sensitive user data
+- Processing payments or financial information
+- Subject to compliance regulations
+- Protecting intellectual property
+
+**Include Scalability When:**
+
+- Expecting rapid user growth
+- Handling variable traffic patterns
+- Supporting enterprise-scale usage
+- Planning for market expansion
+
+**Include Accessibility When:**
+
+- Serving broad public audiences
+- Subject to accessibility regulations
+- Targeting users with disabilities
+- B2B customers with accessibility requirements
+
+## NEXT STEP:
+
+After user selects 'C' and content is saved to document, load `{project-root}/_bmad/bmm/workflows/2-plan-workflows/prd/steps/step-11-complete.md` to finalize the PRD and complete the workflow.
+
+Remember: Do NOT proceed to step-11 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-11-complete.md

@@ -0,0 +1,185 @@
+---
+name: 'step-11-complete'
+description: 'Complete the PRD workflow, update status files, and suggest next steps'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/2-plan-workflows/prd'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-11-complete.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{planning_artifacts}/prd.md'
+---
+
+# Step 11: Workflow Completion
+
+**Final Step - Complete the PRD**
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- ✅ THIS IS A FINAL STEP - Workflow completion required
+
+- 📖 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
+- 🛑 NO content generation - this is a wrap-up step
+- 📋 FINALIZE document and update workflow status
+- 💬 FOCUS on completion, next steps, and suggestions
+- 🎯 UPDATE workflow status files with completion information
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 💾 Update the main workflow status file with completion information
+- 📖 Suggest potential next workflow steps for the user
+- 🚫 DO NOT load additional steps after this one
+
+## TERMINATION STEP PROTOCOLS:
+
+- This is a FINAL step - workflow completion required
+- Output any remaining content if needed (none for this step)
+- Update the main workflow status file with finalized document
+- Suggest potential next steps for the user
+- Mark workflow as complete in status tracking
+
+## CONTEXT BOUNDARIES:
+
+- Complete PRD document is available from all previous steps
+- Workflow frontmatter shows all completed steps
+- All collaborative content has been generated and saved
+- Focus on completion, validation, and next steps
+
+## YOUR TASK:
+
+Complete the PRD workflow, update status files, and suggest next steps for the project.
+
+## WORKFLOW COMPLETION SEQUENCE:
+
+### 1. Announce Workflow Completion
+
+Inform user that the PRD is complete:
+"🎉 **PRD Complete, {{user_name}}!**
+
+I've successfully collaborated with you to create a comprehensive Product Requirements Document for {{project_name}}.
+
+**What we've accomplished:**
+
+- ✅ Executive Summary with vision and product differentiator
+- ✅ Success Criteria with measurable outcomes and scope definition
+- ✅ User Journeys covering all interaction patterns
+- ✅ Domain-specific requirements (if applicable)
+- ✅ Innovation analysis (if applicable)
+- ✅ Project-type specific technical requirements
+- ✅ Comprehensive Functional Requirements (capability contract)
+- ✅ Non-Functional Requirements for quality attributes
+
+**The complete PRD is now available at:** `{outputFile}`
+
+This document is now ready to guide UX design, technical architecture, and development planning."
+
+### 2. Workflow Status Update
+
+Update the main workflow status file if there is one:
+
+- Load `{status_file}` from workflow configuration (if exists)
+- Update workflow_status["prd"] = "{default_output_file}"
+- Save file, preserving all comments and structure
+- Mark current timestamp as completion time
+
+### 3. Suggest Next Steps
+
+Provide guidance on logical next workflows:
+
+**Typical Next Workflows:**
+
+**Immediate Next Steps:**
+
+1. `workflow create-ux-design` - UX Design (if UI exists)
+   - User journey insights from step-04 will inform interaction design
+   - Functional requirements from step-09 define design scope
+
+2. `workflow create-architecture` - Technical architecture
+   - Project-type requirements from step-07 guide technical decisions
+   - Non-functional requirements from step-10 inform architecture choices
+
+3. `workflow create-epics-and-stories` - Epic breakdown
+   - Functional requirements from step-09 become epics and stories
+   - Scope definition from step-03 guides sprint planning
+
+**Strategic Considerations:**
+
+- UX design and architecture can happen in parallel
+- Epics/stories are richer when created after UX/architecture
+
+**What would be most valuable to tackle next?**
+
+### 4. Document Quality Check
+
+Perform final validation of the PRD:
+
+**Completeness Check:**
+
+- Does the executive summary clearly communicate the vision?
+- Are success criteria specific and measurable?
+- Do user journeys cover all major user types?
+- Are functional requirements comprehensive and testable?
+- Are non-functional requirements relevant and specific?
+
+**Consistency Check:**
+
+- Do all sections align with the product differentiator?
+- Is scope consistent across all sections?
+- Are requirements traceable to user needs and success criteria?
+
+### 5. Final Completion Confirmation
+
+- Confirm completion with user and summarize what you have done.
+- Update frontmatter: add this final step name to the end of the steps completed array.
+
+## SUCCESS METRICS:
+
+✅ PRD document contains all required sections
+✅ All collaborative content properly saved to document
+✅ Workflow status file updated with completion information
+✅ Clear next step guidance provided to user
+✅ Document quality validation completed
+✅ User acknowledges completion and understands next options
+
+## FAILURE MODES:
+
+❌ Not updating workflow status file with completion information
+❌ Missing clear next step guidance for user
+❌ Not confirming document completeness with user
+❌ Workflow not properly marked as complete in status tracking
+❌ User unclear about what happens next
+
+❌ **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
+
+## WORKFLOW COMPLETION CHECKLIST:
+
+### Document Structure Complete:
+
+- [ ] Executive Summary with vision and differentiator
+- [ ] Success Criteria with measurable outcomes
+- [ ] Product Scope (MVP, Growth, Vision)
+- [ ] User Journeys (comprehensive coverage)
+- [ ] Domain Requirements (if applicable)
+- [ ] Innovation Analysis (if applicable)
+- [ ] Project-Type Requirements
+- [ ] Functional Requirements (capability contract)
+- [ ] Non-Functional Requirements
+
+### Process Complete:
+
+- [ ] All steps completed with user confirmation
+- [ ] All content saved to document
+- [ ] Frontmatter properly updated
+- [ ] Workflow status file updated
+- [ ] Next steps clearly communicated
+
+## FINAL REMINDER:
+
+This workflow is now complete. The PRD serves as the foundation for all subsequent product development activities. All design, architecture, and development work should trace back to the requirements and vision documented in this PRD.
+
+**Congratulations on completing the Product Requirements Document for {{project_name}}!** 🎉

package/src/modules/bmm/workflows/2-plan-workflows/prd/workflow.md

@@ -0,0 +1,61 @@
+---
+name: create-prd
+description: Creates a comprehensive PRD through collaborative step-by-step discovery between two product managers working as peers.
+main_config: '{project-root}/_bmad/bmm/config.yaml'
+web_bundle: true
+---
+
+# PRD Workflow
+
+**Goal:** Create comprehensive PRDs through collaborative step-by-step discovery between two product managers working as peers.
+
+**Your Role:** You are a product-focused PM facilitator collaborating with an expert peer. This is a partnership, not a client-vendor relationship. You bring structured thinking and facilitation skills, while the user brings domain expertise and product vision. Work together as equals. You will continue to operate with your given name, identity, and communication_style, merged with the details of this role description.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self contained instruction file that is a part of an overall workflow that must be followed exactly
+- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
+- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
+- **Append-Only Building**: Build documents by appending content as directed to the output file
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, load, read entire file, then execute the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- 🛑 **NEVER** load multiple step files simultaneously
+- 📖 **ALWAYS** read entire step file before execution
+- 🚫 **NEVER** skip steps or optimize the sequence
+- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
+- 🎯 **ALWAYS** follow the exact instructions in the step file
+- ⏸️ **ALWAYS** halt at menus and wait for user input
+- 📋 **NEVER** create mental todo lists from future steps
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from {main_config} and resolve:
+
+- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+
+### 2. First Step EXECUTION
+
+Load, read the full file and then execute `steps/step-01-init.md` to begin the workflow.