From 714e7bc3738c8cf2f1d1be8e7bbaaff5a857781f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A5rten=20Angner?= Date: Wed, 3 Dec 2025 23:07:06 +0100 Subject: [PATCH] feat(wds): finalize WDS methodology documentation and update phase details - Updated the WDS conversion roadmap with the latest phase naming conventions and statuses. - Introduced a new section detailing key methodology refinements, including scoring systems for feature prioritization and clarifications on the design system's optional and parallel nature. - Enhanced the PRD platform phase to emphasize technical foundations and proofs of concept. - Revised phase outputs and documentation structure for improved clarity and organization. - Completed all phase guides with positive language and unified naming conventions for better integration with design tools. --- WDS-V6-CONVERSION-ROADMAP.md | 160 ++- .../wds/docs/method/wds-method-guide.md | 167 ++- .../1-project-brief/complete/instructions.md | 265 ++++ .../complete/project-brief.template.md | 103 ++ .../simplified/instructions.md | 121 ++ .../simplified/simplified-brief.template.md | 45 + .../workflows/1-project-brief/workflow.yaml | 39 + .../2-trigger-mapping/instructions.md | 108 ++ .../templates/feature-impact.template.md | 46 + .../templates/trigger-map.template.md | 136 ++ .../workflows/2-trigger-mapping/workflow.yaml | 58 + .../1-business-goals/instructions.md | 101 ++ .../workshops/2-target-groups/instructions.md | 104 ++ .../3-driving-forces/instructions.md | 123 ++ .../4-prioritization/instructions.md | 194 +++ .../5-feature-impact/instructions.md | 150 +++ .../workflows/3-prd-platform/instructions.md | 1110 +++++++++++++++++ .../experimental-endpoints.template.md | 197 +++ .../platform-architecture.template.md | 145 +++ .../technical-constraints.template.md | 173 +++ .../workflows/3-prd-platform/workflow.yaml | 34 + .../workflows/paths/design-system-only.yaml | 62 + .../wds/workflows/paths/digital-strategy.yaml | 39 + .../workflows/paths/feature-enhancement.yaml | 93 ++ .../wds/workflows/paths/full-product.yaml | 96 ++ .../wds/workflows/paths/landing-page.yaml | 54 + .../wds/workflows/paths/quick-prototype.yaml | 39 + .../wds-workflow-status-template.yaml | 87 ++ .../workflows/workflow-init/instructions.md | 306 +++++ .../wds/workflows/workflow-init/workflow.yaml | 32 + .../workflows/workflow-status/instructions.md | 142 +++ .../workflows/workflow-status/workflow.yaml | 22 + 32 files changed, 4421 insertions(+), 130 deletions(-) create mode 100644 src/modules/wds/workflows/1-project-brief/complete/instructions.md create mode 100644 src/modules/wds/workflows/1-project-brief/complete/project-brief.template.md create mode 100644 src/modules/wds/workflows/1-project-brief/simplified/instructions.md create mode 100644 src/modules/wds/workflows/1-project-brief/simplified/simplified-brief.template.md create mode 100644 src/modules/wds/workflows/1-project-brief/workflow.yaml create mode 100644 src/modules/wds/workflows/2-trigger-mapping/instructions.md create mode 100644 src/modules/wds/workflows/2-trigger-mapping/templates/feature-impact.template.md create mode 100644 src/modules/wds/workflows/2-trigger-mapping/templates/trigger-map.template.md create mode 100644 src/modules/wds/workflows/2-trigger-mapping/workflow.yaml create mode 100644 src/modules/wds/workflows/2-trigger-mapping/workshops/1-business-goals/instructions.md create mode 100644 src/modules/wds/workflows/2-trigger-mapping/workshops/2-target-groups/instructions.md create mode 100644 src/modules/wds/workflows/2-trigger-mapping/workshops/3-driving-forces/instructions.md create mode 100644 src/modules/wds/workflows/2-trigger-mapping/workshops/4-prioritization/instructions.md create mode 100644 src/modules/wds/workflows/2-trigger-mapping/workshops/5-feature-impact/instructions.md create mode 100644 src/modules/wds/workflows/3-prd-platform/instructions.md create mode 100644 src/modules/wds/workflows/3-prd-platform/templates/experimental-endpoints.template.md create mode 100644 src/modules/wds/workflows/3-prd-platform/templates/platform-architecture.template.md create mode 100644 src/modules/wds/workflows/3-prd-platform/templates/technical-constraints.template.md create mode 100644 src/modules/wds/workflows/3-prd-platform/workflow.yaml create mode 100644 src/modules/wds/workflows/paths/design-system-only.yaml create mode 100644 src/modules/wds/workflows/paths/digital-strategy.yaml create mode 100644 src/modules/wds/workflows/paths/feature-enhancement.yaml create mode 100644 src/modules/wds/workflows/paths/full-product.yaml create mode 100644 src/modules/wds/workflows/paths/landing-page.yaml create mode 100644 src/modules/wds/workflows/paths/quick-prototype.yaml create mode 100644 src/modules/wds/workflows/wds-workflow-status-template.yaml create mode 100644 src/modules/wds/workflows/workflow-init/instructions.md create mode 100644 src/modules/wds/workflows/workflow-init/workflow.yaml create mode 100644 src/modules/wds/workflows/workflow-status/instructions.md create mode 100644 src/modules/wds/workflows/workflow-status/workflow.yaml diff --git a/WDS-V6-CONVERSION-ROADMAP.md b/WDS-V6-CONVERSION-ROADMAP.md index 8d796a25..4ae0472f 100644 --- a/WDS-V6-CONVERSION-ROADMAP.md +++ b/WDS-V6-CONVERSION-ROADMAP.md @@ -3,8 +3,8 @@ **Document Purpose:** Complete record of all decisions, context, and progress for converting Whiteport Design Studio to BMad Method v6 format. This document allows continuation of work if the conversation is lost. **Created:** December 2, 2025 -**Last Updated:** December 2, 2025 -**Status:** In Progress - Foundation Phase +**Last Updated:** December 3, 2025 +**Status:** In Progress - Examples Phase --- @@ -411,7 +411,58 @@ What tends to feel less collaborative: --- -## 7. Development Order +## 6.5 Key Methodology Refinements (Dec 3, 2025) + +### Phase Naming Convention +Each phase title now includes the artifact in parentheses: +- Phase 1: Product Exploration (Product Brief) +- Phase 2: Trigger Mapping (Trigger Map) +- Phase 3: PRD Platform (Technical Foundation) +- Phase 4: UX Design (UX-Sketches & Usage Scenarios) +- Phase 5: Design System (Component Library) +- Phase 6: PRD Finalization (Complete PRD) + +### Phase 2: Feature Impact Analysis +Added a scoring system (Beta) for prioritizing features: +- Positive drivers: +3/+2/+1 by priority +- Negative drivers: +4/+3/+2 (higher due to loss aversion) +- Bonuses for multi-group and multi-driver features +- Outputs ranked feature list for MVP planning + +### Phase 3: PRD Platform +Renamed from "Requirements" to emphasize: +- Technical foundation work (platform, infrastructure) +- Proofs of concept for risky features +- Experimental endpoints that can start before design +- Parallel with design work, not sequential + +### Phase 4: Step 4E - PRD Update +Added step 4E after each page design: +- Extract functional requirements discovered during design +- Add to PRD with page references +- PRD grows incrementally throughout Phase 4 +- Creates traceability: page → feature → epic + +### Phase 5: Optional & Parallel +Clarified that Design System is: +- **Optional** - chosen during project setup +- **Parallel** - builds alongside Phase 4, not after +- Includes unified naming for Figma/Code integration +- Component library selection guidance added + +### Phase 6: PRD Finalization +Renamed from "Dev Integration" to emphasize: +- Compiling all functional requirements from Phase 4 +- Organizing by epic/feature area +- Continuous handoff model (not single event) +- First handoff at MVP, then ongoing updates + +### Removed from Guides +- Duration estimates (project-dependent) +- Inline code examples (belong in templates/examples) +- Negative language ("expensive problems", "kills projects") + +--- ### 7.1 Chosen Approach: Methodology-First @@ -432,13 +483,24 @@ What tends to feel less collaborative: #### Phase 1: Define the Methodology | Order | Component | File | Status | |-------|-----------|------|--------| -| 1 | Method Overview | `docs/method/wds-method-guide.md` | ✅ CREATED | -| 2 | Phase 1 Guide | `docs/method/phase-1-exploration-guide.md` | ✅ CREATED | -| 3 | Phase 2 Guide | `docs/method/phase-2-research-guide.md` | ✅ CREATED | -| 4 | Phase 3 Guide | `docs/method/phase-3-requirements-guide.md` | ✅ CREATED | -| 5 | Phase 4 Guide | `docs/method/phase-4-ux-design-guide.md` | ✅ CREATED | -| 6 | Phase 5 Guide | `docs/method/phase-5-design-system-guide.md` | ✅ CREATED | -| 7 | Phase 6 Guide | `docs/method/phase-6-integration-guide.md` | ✅ CREATED | +| 1 | Method Overview | `docs/method/wds-method-guide.md` | ✅ COMPLETE | +| 2 | Phase 1 Guide | `docs/method/phase-1-Product-exploration-guide.md` | ✅ COMPLETE | +| 3 | Phase 2 Guide | `docs/method/phase-2-trigger-mapping-guide.md` | ✅ COMPLETE | +| 4 | Phase 3 Guide | `docs/method/phase-3-PRD-Platform-guide.md` | ✅ COMPLETE | +| 5 | Phase 4 Guide | `docs/method/phase-4-ux-design-guide.md` | ✅ COMPLETE | +| 6 | Phase 5 Guide | `docs/method/phase-5-design-system-guide.md` | ✅ COMPLETE | +| 7 | Phase 6 Guide | `docs/method/phase-6-PRD-Finalization-guide.md` | ✅ COMPLETE | + +**Methodology Phase Complete!** All phase guides refined with: +- Positive language throughout (no "expensive problems", "kills projects", etc.) +- Phase titles with artifacts in parentheses +- Removed duration estimates (project-dependent) +- Feature Impact Analysis with scoring system (Phase 2) +- Step 4E: PRD Update during design (Phase 4) +- Design System as optional parallel workflow (Phase 5) +- PRD Finalization with continuous handoff model (Phase 6) +- Unified naming conventions for Figma/Code integration +- Code examples moved to templates/examples (not in guides) #### Phase 2: Create Examples | Order | Component | Location | Status | @@ -503,26 +565,37 @@ Includes: | `README.md` | Fork overview, WDS contribution explanation | ✅ CREATED | | `WDS-V6-CONVERSION-ROADMAP.md` | This document | ✅ CREATED | -### 8.2 Module Structure +### 8.2 Methodology Documentation + +| Path | Purpose | Status | +|------|---------|--------| +| `src/modules/wds/docs/method/wds-method-guide.md` | Main methodology overview | ✅ COMPLETE | +| `src/modules/wds/docs/method/phase-1-Product-exploration-guide.md` | Phase 1 guide | ✅ COMPLETE | +| `src/modules/wds/docs/method/phase-2-trigger-mapping-guide.md` | Phase 2 guide | ✅ COMPLETE | +| `src/modules/wds/docs/method/phase-3-PRD-Platform-guide.md` | Phase 3 guide | ✅ COMPLETE | +| `src/modules/wds/docs/method/phase-4-ux-design-guide.md` | Phase 4 guide | ✅ COMPLETE | +| `src/modules/wds/docs/method/phase-5-design-system-guide.md` | Phase 5 guide | ✅ COMPLETE | +| `src/modules/wds/docs/method/phase-6-PRD-Finalization-guide.md` | Phase 6 guide | ✅ COMPLETE | + +### 8.3 Module Structure (Folders Created, Content Pending) | Path | Purpose | Status | |------|---------|--------| | `src/modules/wds/` | Module root | ✅ CREATED | | `src/modules/wds/README.md` | Module entry point | ✅ CREATED | -| `src/modules/wds/_module-installer/` | Install config folder | ✅ CREATED (empty) | -| `src/modules/wds/agents/` | Agents folder | ✅ CREATED (empty) | -| `src/modules/wds/workflows/` | Workflows folder | ✅ CREATED (empty) | -| `src/modules/wds/data/` | Data folder | ✅ CREATED (empty) | -| `src/modules/wds/data/presentations/` | Agent presentations | ✅ CREATED (empty) | -| `src/modules/wds/docs/` | Documentation folder | ✅ CREATED (empty) | -| `src/modules/wds/docs/method/` | Methodology guides | ✅ CREATED (empty) | -| `src/modules/wds/docs/images/` | Images folder | ✅ CREATED (empty) | -| `src/modules/wds/examples/` | Examples folder | ✅ CREATED (empty) | -| `src/modules/wds/examples/dog-week-patterns/` | Dog Week examples | ✅ CREATED (empty) | -| `src/modules/wds/reference/` | Reference materials | ✅ CREATED (empty) | -| `src/modules/wds/reference/templates/` | Templates | ✅ CREATED (empty) | -| `src/modules/wds/reference/checklists/` | Checklists | ✅ CREATED (empty) | -| `src/modules/wds/teams/` | Team configs | ✅ CREATED (empty) | +| `src/modules/wds/_module-installer/` | Install config folder | EMPTY | +| `src/modules/wds/agents/` | Agents folder | EMPTY | +| `src/modules/wds/workflows/` | Workflows folder | EMPTY | +| `src/modules/wds/data/` | Data folder | EMPTY | +| `src/modules/wds/data/presentations/` | Agent presentations | EMPTY | +| `src/modules/wds/docs/method/` | Methodology guides | ✅ COMPLETE | +| `src/modules/wds/docs/images/` | Images folder | EMPTY | +| `src/modules/wds/examples/` | Examples folder | EMPTY | +| `src/modules/wds/examples/dog-week-patterns/` | Dog Week examples | TO CREATE | +| `src/modules/wds/reference/` | Reference materials | EMPTY | +| `src/modules/wds/reference/templates/` | Templates | TO CREATE | +| `src/modules/wds/reference/checklists/` | Checklists | TO CREATE | +| `src/modules/wds/teams/` | Team configs | EMPTY | --- @@ -530,35 +603,34 @@ Includes: ### Immediate Next Action -**Create `wds-method-guide.md`** - The methodology overview document - -This will include: -- Overview of the 6 phases -- What each phase produces -- When to use each phase -- How phases connect -- The A-B-C-D-E folder structure -- Links to examples (not rules) +**Create Examples** - Port Dog Week patterns and create conversation examples ### Short-term Roadmap 1. [x] Create `wds-method-guide.md` 2. [x] Create phase guide for each phase (6 files) -3. [ ] Port Dog Week examples to `examples/dog-week-patterns/` -4. [ ] Create conversation examples -5. [ ] Create workflow-init workflow -6. [ ] Create first phase workflow (Phase 1) -7. [ ] Create first agent (Saga-Analyst) +3. [x] Refine all phase guides with positive language, proper naming +4. [ ] Create WDS Trigger Map (meta-example for WDS itself) +5. [ ] Create conversation examples +6. [x] Create workflow-init workflow ✅ +7. [ ] Create phase workflows (1-6) +8. [ ] Create agents (Saga, Freyja, Baldr) +9. [ ] Create templates for component showcase, PRD, etc. +10. [ ] Port Dog Week examples to `examples/dog-week-patterns/` (last - project in active development) ### Commit Checkpoint -After creating methodology docs, commit with message: +Ready to commit methodology phase: ``` -feat(wds): Add WDS methodology documentation +feat(wds): Complete WDS methodology documentation -- Add wds-method-guide.md with 6-phase overview -- Add phase-specific guides -- Establish show-don't-tell documentation approach +- All 6 phase guides complete with positive language +- Feature Impact Analysis with scoring (Phase 2) +- Step 4E: PRD Update during design (Phase 4) +- Design System as optional parallel workflow (Phase 5) +- PRD Finalization with continuous handoff (Phase 6) +- Unified naming conventions for Figma/Code +- Main method guide updated ``` --- diff --git a/src/modules/wds/docs/method/wds-method-guide.md b/src/modules/wds/docs/method/wds-method-guide.md index 618be59c..510f23fb 100644 --- a/src/modules/wds/docs/method/wds-method-guide.md +++ b/src/modules/wds/docs/method/wds-method-guide.md @@ -12,26 +12,27 @@ ## What is WDS? -Whiteport Design Studio is a **design-focused methodology** that supports designers in their design process and help create detailed specifications through collaborative workshops, visual thinking, and systematic documentation perfect for development by AI and humans alike. +Whiteport Design Studio is a **design-focused methodology** that supports designers in their design process and helps create detailed specifications through collaborative workshops, visual thinking, and systematic documentation perfect for development by AI and humans alike. WDS creates the **design artifacts** that development teams need to build exceptional products - from initial vision through detailed component specifications. ### The Core Idea ``` -Vision → Clarity → UX Design → Design System → Handoff - │ │ │ │ │ - │ │ │ │ └── Dev teams get - │ │ │ │ everything - │ │ │ │ - │ │ │ └── Components, - │ │ │ tokens, patterns - │ │ │ - │ │ └── Conceptualizing, Sketching, - │ │ create specifications +Vision → Clarity → UX Design → Design System → PRD Complete + │ │ │ │ │ + │ │ │ │ └── Development + │ │ │ │ gets everything + │ │ │ │ + │ │ │ └── Components, + │ │ │ tokens, patterns + │ │ │ (optional, parallel) + │ │ │ + │ │ └── Sketching, specifying, + │ │ prototyping, PRD grows │ │ - │ └── User research, - │ trigger mapping + │ └── Trigger mapping, + │ Feature Impact Analysis │ └── Strategic foundation, positioning, ICP @@ -43,7 +44,7 @@ Vision → Clarity → UX Design → Design System → Handoff WDS follows six phases, each producing artifacts in your project's `docs/` folder: -### Phase 1: Product Exploration +### Phase 1: Product Exploration (Product Brief) **Output:** `A-Product-Brief/` **Agent:** Saga the Analyst @@ -57,82 +58,84 @@ Establish your strategic foundation through conversational discovery. Instead of --- -### Phase 2: User Research +### Phase 2: Trigger Mapping (Trigger Map) **Output:** `B-Trigger-Map/` **Agent:** Saga the Analyst -Connect business goals to user psychology through Effect Mapping. Discover not just WHO your users are, but WHY they act and WHAT triggers their decisions. +Connect business goals to user psychology through Trigger Mapping. Discover not just WHO your users are, but WHY they act and WHAT triggers their decisions. **What you create:** -- Business goals with clear priorities +- Business goals (Vision + SMART objectives) - Target groups connected to business outcomes - Detailed personas with psychological depth -- Usage goals (what users want vs what they fear) -- Visual trigger map showing the strategic connections +- Usage goals (positive and negative driving forces) +- Visual trigger map showing strategic connections +- Feature Impact Analysis with priority scoring --- -### Phase 3: Requirements -**Output:** `D-PRD/` +### Phase 3: PRD Platform (Technical Foundation) +**Output:** `C-Requirements/` **Agent:** Freyja the PM -Define the technical foundation and functional requirements. Bridge the gap between strategic vision and implementation details. +Prove your concept works technically - in parallel with design work. Validate platform decisions, create proofs of concept, and set up experimental endpoints. **What you create:** - Platform architecture decisions -- Infrastructure specifications -- Integration requirements -- Security and performance needs -- Functional feature specifications +- Data model and integrations +- Technical proofs of concept +- Experimental endpoints +- Security and performance framework +- Technical constraints document (for UX Design) --- -### Phase 4: Conceptual Design +### Phase 4: UX Design (UX-Sketches & Usage Scenarios) **Output:** `C-Scenarios/` **Agent:** Baldr the UX Expert -Transform ideas into detailed visual specifications. Your agent helps you think out the design, assists in sketching, then specifies and pressure-tests every detail. +Transform ideas into detailed visual specifications. Your agent helps you think out the design, assists in sketching, creates specifications, and builds HTML prototypes. Each page adds functional requirements to the PRD. -**The key insight:** Designs that can be logically explained without gaps are easy to develop. The specification process reveals holes in your thinking before they become expensive development problems. +**The key insight:** Designs that can be logically explained without gaps are easy to develop. The specification process reveals gaps early - when they're easy to address. **What you create:** - Scenario folder structure (numbered hierarchy) - Page specifications with full detail - Component definitions with Object IDs - Interaction behaviors and states -- Multilingual content - HTML prototypes for validation +- Functional requirements added to PRD (via step 4E) --- -### Phase 5: Component Design +### Phase 5: Design System (Component Library) **Output:** `D-Design-System/` **Agent:** Baldr the UX Expert -Build your component library following atomic design principles. Create reusable patterns that serve user psychology. +Build your component library following atomic design principles. This phase is **optional** and runs **in parallel** with Phase 4 - as you design pages, you extract reusable components. **What you create:** - Design tokens (colors, typography, spacing) - Atomic components (buttons, inputs, labels) - Molecular components (form groups, cards) - Organism components (headers, complex sections) -- Usage guidelines and variants +- Interactive HTML component showcase +- Figma/design tool integration with unified naming --- -### Phase 6: Dev Integration -**Output:** `E-UI-Roadmap/` +### Phase 6: PRD Finalization (Complete PRD) +**Output:** Complete PRD in `C-Requirements/` + `E-UI-Roadmap/` **Agent:** Freyja the PM -Prepare everything development teams need. Create the bridge between design and implementation. +Compile all functional requirements discovered during Phase 4 into a complete, development-ready PRD. This phase runs **continuously** - hand off as soon as you have MVP scope, then update as design progresses. **What you create:** -- Priority sequence (what to build first) -- Scenario-to-development mapping -- Component inventory -- Technical notes and constraints -- Object ID inventory for testing -- Handoff checklist +- Complete PRD (Platform + Functional requirements) +- Feature organization by epic/area +- Development sequence with priorities +- Handoff package in `E-UI-Roadmap/` +- Scenario-to-epic mapping --- @@ -154,21 +157,10 @@ WDS creates an organized folder structure in your project's `docs/` folder. Duri docs/ ├── A-Product-Brief/ ├── B-Trigger-Map/ +├── C-Platform-Requirements/ ├── C-Scenarios/ -├── D-PRD/ ├── D-Design-System/ -└── E-UI-Roadmap/ -``` - -**Letters + lowercase**: -``` -docs/ -├── A-product-brief/ -├── B-trigger-map/ -├── C-scenarios/ -├── D-prd/ -├── D-design-system/ -└── E-ui-roadmap/ +└── E-PRD-Finalization/ ``` **Numbers + Title-Case**: @@ -176,21 +168,10 @@ docs/ docs/ ├── 01-Product-Brief/ ├── 02-Trigger-Map/ +├── 03-Platform-Requirements/ ├── 03-Scenarios/ -├── 04-PRD/ -├── 05-Design-System/ -└── 06-UI-Roadmap/ -``` - -**Numbers + lowercase**: -``` -docs/ -├── 01-product-brief/ -├── 02-trigger-map/ -├── 03-scenarios/ -├── 04-prd/ -├── 05-design-system/ -└── 06-ui-roadmap/ +├── 04-Design-System/ +└── 05-PRD-Finalization/ ``` **Default (Letters + Title-Case) is recommended because:** @@ -206,11 +187,12 @@ Not every project needs all six phases. Select what you need based on your situa | Project Type | Recommended Phases | |--------------|-------------------| -| **Landing page** | 1, 4, 5 | +| **Landing page** | 1, 4 | | **Full product (greenfield)** | All six | -| **Feature enhancement** | 2, 4, 5, 6 | +| **Feature enhancement** | 2, 4, 6 | | **Design system only** | 4, 5 | | **Strategic planning** | 1, 2 | +| **Quick prototype** | 4 only | Your agents will help you identify which phases fit your project. @@ -227,16 +209,16 @@ Saga guides you through discovery and research. She's curious, patient, and help **Works with you on:** - Phase 1: Product Exploration -- Phase 2: User Research (Trigger Mapping) +- Phase 2: Trigger Mapping ### Freyja the PM ⚔️ *"The strategic leader who sees what must be done"* -Freyja helps you define requirements and prepare for development. She balances passion with strategy, knowing when to be fierce and when to be patient. +Freyja helps you define technical requirements and finalize the PRD for development. She balances passion with strategy, knowing when to be fierce and when to be patient. **Works with you on:** -- Phase 3: Requirements -- Phase 6: Dev Integration +- Phase 3: PRD Platform +- Phase 6: PRD Finalization ### Baldr the UX Expert ✨ *"The one who brings light and beauty"* @@ -244,8 +226,8 @@ Freyja helps you define requirements and prepare for development. She balances p Baldr transforms your ideas into beautiful, detailed specifications. He cares deeply about craft and ensures every detail serves the user experience. **Works with you on:** -- Phase 4: Conceptual Design -- Phase 5: Component Design +- Phase 4: UX Design +- Phase 5: Design System --- @@ -330,17 +312,30 @@ npx bmad-method@alpha install WDS focuses on **design** - creating the artifacts that guide development. The actual development process is handled by BMad Method (BMM) or your preferred development workflow. +### The PRD Journey + ``` -WDS Design Phases Handoff Development -───────────────── ────── ─────────── -A-Product-Brief ────┐ -B-Trigger-Map ────┼────► E-UI-Roadmap ────────► BMM or your -D-PRD ────┤ (bridge) development -C-Scenarios ────┤ process -D-Design-System ────┘ +Phase 3: PRD starts Phase 4: PRD grows Phase 6: PRD completes +(Technical Foundation) (Each page adds features) (Organized for dev) + │ │ │ + ▼ ▼ ▼ +C-Requirements/ ────► C-Requirements/ ────► E-UI-Roadmap/ +├── Platform arch ├── Platform arch ├── Priority sequence +├── Data model ├── Data model ├── Epic mapping +├── Integrations ├── Integrations ├── Component inventory +└── Security └── Functional reqs ◄──┐ └── Handoff checklist + (from each page) │ + │ + C-Scenarios/ ─────────┘ + (Page specs add features via 4E) ``` -The `E-UI-Roadmap/` folder contains everything development teams need to begin implementation without additional discovery work. +### Parallel Streams + +Design and development can work in parallel: +- Phase 3 complete → Backend/platform development can start +- Phase 4 MVP scenarios complete → Phase 6 first handoff → Sprint 1 begins +- Design continues → Regular Phase 6 updates → More sprints --- @@ -348,9 +343,9 @@ The `E-UI-Roadmap/` folder contains everything development teams need to begin i - **Phase guides:** Detailed documentation for each phase - **Examples:** Dog Week patterns showing real artifacts +- **Templates:** Ready-to-use templates for all deliverables - **Conversation examples:** See how agent sessions flow --- *Whiteport Design Studio - Part of the BMad ecosystem* - diff --git a/src/modules/wds/workflows/1-project-brief/complete/instructions.md b/src/modules/wds/workflows/1-project-brief/complete/instructions.md new file mode 100644 index 00000000..6ceb9ddb --- /dev/null +++ b/src/modules/wds/workflows/1-project-brief/complete/instructions.md @@ -0,0 +1,265 @@ +# Complete Project Brief - Instructions + +Communicate in {communication_language} with {user_name} +You are Saga the Analyst - curious, insightful, strategic thinker + + + + +Hi {user_name}! I'm Saga, and I'll guide you through creating a **Complete Project Brief**. + +This is our strategic foundation - we'll explore: +- Vision & positioning +- Target users (ICP) +- Success criteria +- Competitive landscape +- Constraints & context + +Set aside about 30-60 minutes. This investment pays off throughout the project. + +Ready to begin? 🎯 + +Before we start - is there any existing documentation, research, or context I should know about? + +If user shares docs, read and incorporate insights + + + +**Let's start with the big picture.** + +**What's your vision for this product?** + +If this project succeeds beyond your wildest dreams, what does that look like? Don't worry about being realistic yet - dream big. + +Listen for: +- Aspirational outcomes +- Impact on users +- Market position +- Emotional drivers + + +Reflect back and help crystallize into a clear vision statement + +vision + + + +**Now let's get specific about positioning.** + +**Who is this for, and how is it different?** + +Complete this statement: + +*For [target customer] who [need/opportunity], [product name] is a [category] that [key benefit]. Unlike [alternatives], we [differentiator].* + +If user struggles, break it down: +1. Who's the target customer? +2. What's their need or opportunity? +3. What category does this fit? +4. What's the key benefit? +5. What makes it different from alternatives? + + +Help craft a clear positioning statement + +positioning_statement + + + +**Is this product B2B, B2C, or both?** + +1. **B2B** - Businesses buy/use the product +2. **B2C** - Individual consumers buy/use the product +3. **Both** - Mixed model (e.g., freemium with enterprise tier) + +Choice [1/2/3]: + +Store business_model (b2b/b2c/both) +business_model + + + + +**Let's define your Ideal Business Customer.** + +**Describe your ideal business customer:** + +- Company size (employees, revenue range) +- Industry or vertical +- Company stage (startup, growth, enterprise) +- Decision-making structure +- Budget authority +- Current tech stack or processes +- Why would they buy from you? + +Build profile of ideal business customer + +**Who's the buyer vs. the user?** + +In B2B, the person who buys is often different from the person who uses. + +- **Buyer:** Who signs the contract/approves purchase? +- **Champion:** Who advocates internally? +- **User:** Who uses it day-to-day? + +Note the buying roles + +business_customer_profile +buying_roles + + + + + +**Let's define your Ideal Customer Profile.** + + + +**Now let's define the users within those businesses.** + + +**Describe your ideal user in detail.** + +- Who are they? (role, demographics, situation) +- What's their day like? +- What frustrates them? +- What are they trying to achieve? +- How do they currently solve this problem? + +Build a rich picture of the primary user + +**Are there secondary users or stakeholders?** + +Others who interact with the product but aren't the primary user? + +Note secondary users if applicable + +ideal_user_profile +secondary_users + + + +**How will we know this project succeeded?** + +**What metrics or outcomes define success?** + +Think about: +- User behavior (adoption, engagement, retention) +- Business outcomes (revenue, conversion, efficiency) +- Experience quality (satisfaction, NPS, task completion) +- Timeline (when do you need to see results?) + +Help make criteria SMART: +- Specific +- Measurable +- Achievable +- Relevant +- Time-bound + + +success_criteria + + + +**Let's understand the alternatives.** + +**What alternatives do your users have today?** + +This could be: +- Direct competitors +- Different approaches to the same problem +- Manual/analog solutions +- Doing nothing + +For each alternative, explore: +- What do they do well? +- Where do they fall short? +- Why might users choose them over you? + + +**What's your unfair advantage?** + +What do you have that competitors can't easily copy? + +competitive_landscape +unfair_advantage + + + +**Let's ground this in reality.** + +**What constraints should shape our design?** + +- Timeline/deadlines +- Budget/resources +- Technical requirements or limitations +- Brand guidelines +- Regulatory/compliance needs +- Integration requirements + +Note each constraint and its impact on design decisions + +**Any other context that's important?** + +Company stage, team capabilities, market conditions, past attempts? + +constraints +additional_context + + + +**Excellent work, {user_name}!** Here's what we've captured: + +--- + +**Vision** +{{vision}} + +**Positioning** +{{positioning_statement}} + +**Business Model:** {{business_model}} + +{{#if business_model in [b2b, both]}} +**Business Customer** +{{business_customer_profile}} +{{/if}} + +**Target Users** +{{ideal_user_profile}} + +**Success Criteria** +{{success_criteria}} + +**Competitive Landscape** +{{competitive_landscape}} + +**Unfair Advantage** +{{unfair_advantage}} + +**Constraints** +{{constraints}} + +--- + + +Does this capture your strategic foundation? Anything to refine? + +Make requested adjustments + +Generate project-brief.md from template +Save to {output_folder}/A-Product-Brief/project-brief.md + +✅ **Complete Project Brief saved!** + +Location: `A-Product-Brief/project-brief.md` + +This strategic foundation will guide all design decisions. You're ready for: +- **Phase 2: Trigger Mapping** - Deep dive into user psychology +- **Phase 3: PRD Platform** - Technical foundation + +Your vision is clear. Let's build something great! 🚀 + + + + diff --git a/src/modules/wds/workflows/1-project-brief/complete/project-brief.template.md b/src/modules/wds/workflows/1-project-brief/complete/project-brief.template.md new file mode 100644 index 00000000..11182fe3 --- /dev/null +++ b/src/modules/wds/workflows/1-project-brief/complete/project-brief.template.md @@ -0,0 +1,103 @@ +# Project Brief: {{project_name}} + +> Complete Strategic Foundation + +**Created:** {{date}} +**Author:** {{user_name}} +**Brief Type:** Complete + +--- + +## Vision + +{{vision}} + +--- + +## Positioning Statement + +{{positioning_statement}} + +**Breakdown:** +- **Target Customer:** {{target_customer}} +- **Need/Opportunity:** {{need_opportunity}} +- **Category:** {{category}} +- **Key Benefit:** {{key_benefit}} +- **Differentiator:** {{differentiator}} + +--- + +## Business Model + +**Type:** {{business_model}} + +{{#if business_model_b2b}} +--- + +## Business Customer Profile (B2B) + +{{business_customer_profile}} + +### Buying Roles + +| Role | Description | +|------|-------------| +| **Buyer** | {{buyer_role}} | +| **Champion** | {{champion_role}} | +| **User** | {{user_role}} | +{{/if}} + +--- + +## {{#if business_model_b2b}}User Profile (within Business){{else}}Ideal Customer Profile (ICP){{/if}} + +{{ideal_user_profile}} + +### Secondary Users + +{{secondary_users}} + +--- + +## Success Criteria + +{{success_criteria}} + +--- + +## Competitive Landscape + +{{competitive_landscape}} + +### Our Unfair Advantage + +{{unfair_advantage}} + +--- + +## Constraints + +{{constraints}} + +--- + +## Additional Context + +{{additional_context}} + +--- + +## Next Steps + +This complete brief provides strategic foundation for all design work: + +- [ ] **Phase 2: Trigger Mapping** - Map user psychology to business goals +- [ ] **Phase 3: PRD Platform** - Define technical foundation +- [ ] **Phase 4: UX Design** - Begin sketching and specifications +- [ ] **Phase 5: Design System** - If enabled, build components +- [ ] **Phase 6: PRD Finalization** - Compile for development handoff + +--- + +*Generated by Whiteport Design Studio* + diff --git a/src/modules/wds/workflows/1-project-brief/simplified/instructions.md b/src/modules/wds/workflows/1-project-brief/simplified/instructions.md new file mode 100644 index 00000000..8ce1842d --- /dev/null +++ b/src/modules/wds/workflows/1-project-brief/simplified/instructions.md @@ -0,0 +1,121 @@ +# Simplified Project Brief - Instructions + +Communicate in {communication_language} with {user_name} +You are Saga the Analyst - curious, insightful, and focused on understanding + + + + +Hi {user_name}! I'm Saga, and I'll help you capture the essential context for your project. + +This is a **Simplified Project Brief** - we'll cover the key points in about 5-10 minutes: +- What you're building (scope) +- The challenge or opportunity +- Your design goals + +Let's dive in! 🎯 + + + +**What are you designing?** + +Describe the project in a few sentences. What will users see and interact with? + +Listen for: +- Type of project (app, website, feature, page) +- Target platform (web, mobile, both) +- Key functionality or purpose + + +If unclear, ask one clarifying question + +project_scope + + + +**What's the challenge or opportunity here?** + +Why does this project exist? What problem are you solving, or what opportunity are you pursuing? + +Listen for: +- Pain points being addressed +- Market opportunity +- User needs not being met +- Business drivers + + +Reflect back what you heard to confirm understanding + +challenge_opportunity + + + +**What should the design achieve?** + +When this design is complete, what will make it successful? What experience do you want users to have? + +Listen for: +- Functional goals (what it should do) +- Experience goals (how it should feel) +- Business goals (what outcomes matter) + + +Help refine vague goals into specific, actionable ones + +design_goals + + + +**Any constraints I should know about?** + +Timeline, technology, brand guidelines, existing systems to integrate with? + +Note: +- Technical constraints +- Timeline/deadline +- Budget considerations +- Brand/style requirements +- Integration requirements + + +It's okay if there are few constraints - note "flexible" where appropriate + +constraints + + + +Here's what I captured: + +**Project Scope** +{{project_scope}} + +**Challenge/Opportunity** +{{challenge_opportunity}} + +**Design Goals** +{{design_goals}} + +**Constraints** +{{constraints}} + + +Does this capture the essentials? Anything to add or adjust? + +Make any requested adjustments + +Generate simplified-brief.md from template +Save to {output_folder}/A-Product-Brief/project-brief.md + +✅ **Simplified Project Brief saved!** + +Location: `A-Product-Brief/project-brief.md` + +You now have enough context to move forward. When you're ready: +- **Next phase:** Check your workflow status for what's next +- **Need more depth?** You can always expand this into a Complete brief later + +Happy designing! 🎨 + + + + diff --git a/src/modules/wds/workflows/1-project-brief/simplified/simplified-brief.template.md b/src/modules/wds/workflows/1-project-brief/simplified/simplified-brief.template.md new file mode 100644 index 00000000..0fea3074 --- /dev/null +++ b/src/modules/wds/workflows/1-project-brief/simplified/simplified-brief.template.md @@ -0,0 +1,45 @@ +# Project Brief: {{project_name}} + +> Simplified Brief - Essential context for design work + +**Created:** {{date}} +**Author:** {{user_name}} +**Brief Type:** Simplified + +--- + +## Project Scope + +{{project_scope}} + +--- + +## Challenge / Opportunity + +{{challenge_opportunity}} + +--- + +## Design Goals + +{{design_goals}} + +--- + +## Constraints + +{{constraints}} + +--- + +## Next Steps + +This simplified brief provides essential context for design work. The following phases can now proceed: + +- [ ] **Phase 4: UX Design** - Begin sketching and specifications +- [ ] **Phase 5: Design System** - If enabled, build components alongside design + +--- + +*Generated by Whiteport Design Studio* + diff --git a/src/modules/wds/workflows/1-project-brief/workflow.yaml b/src/modules/wds/workflows/1-project-brief/workflow.yaml new file mode 100644 index 00000000..76d2ce98 --- /dev/null +++ b/src/modules/wds/workflows/1-project-brief/workflow.yaml @@ -0,0 +1,39 @@ +# WDS Phase 1: Project Brief +name: project-brief +description: "Establish project context - the foundation for all design work" +author: "Whiteport Design Studio" +phase: 1 + +# Critical variables from config +config_source: "{project-root}/{bmad_folder}/wds/config.yaml" +output_folder: "{config_source}:output_folder" +user_name: "{config_source}:user_name" +project_name: "{config_source}:project_name" +communication_language: "{config_source}:communication_language" +document_output_language: "{config_source}:document_output_language" +date: system-generated + +# Brief level from workflow status +brief_level: "{output_folder}/wds-workflow-status.yaml:config.brief_level" + +# Workflow components +installed_path: "{project-root}/{bmad_folder}/wds/workflows/1-project-brief" + +# Route to appropriate workflow based on brief_level +workflows: + simplified: + instructions: "{installed_path}/simplified/instructions.md" + template: "{installed_path}/simplified/simplified-brief.template.md" + complete: + instructions: "{installed_path}/complete/instructions.md" + template: "{installed_path}/complete/project-brief.template.md" + +# Output configuration +output_file: "{output_folder}/A-Product-Brief/project-brief.md" + +# Agent assignment +primary_agent: "saga-analyst" + +standalone: true +web_bundle: false + diff --git a/src/modules/wds/workflows/2-trigger-mapping/instructions.md b/src/modules/wds/workflows/2-trigger-mapping/instructions.md new file mode 100644 index 00000000..a6ebe91f --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/instructions.md @@ -0,0 +1,108 @@ +# Trigger Mapping - Overview Instructions + +Communicate in {communication_language} with {user_name} +You are Saga the Analyst - facilitator of strategic clarity + + + + +Hi {user_name}! I'm Saga, and I'll facilitate your **Trigger Mapping** session. + +Trigger Mapping connects your business goals to user psychology. It answers: +- **Why** will users engage with your product? +- **What** motivates them (positive drivers)? +- **What** do they want to avoid (negative drivers)? +- **Which** features matter most? + +We'll work through 5 focused workshops: + +1. **Business Goals** - Vision → SMART objectives +2. **Target Groups** - Who are your key users? +3. **Driving Forces** - What motivates and concerns them? +4. **Prioritization** - What matters most? +5. **Feature Impact** - Which features serve top priorities? + +Each workshop builds on the previous. You can run them all together (60-90 min) or spread across sessions. + +Ready to begin? 🎯 + +Would you like to: +1. **Full session** - All 5 workshops now +2. **Workshop by workshop** - Start with Business Goals, continue later +3. **Jump to specific workshop** - If you've done some already + + + Proceed through all workshops sequentially + + + + Run Workshop 1, then offer to save and continue later + + + + Which workshop? + 1. Business Goals + 2. Target Groups + 3. Driving Forces + 4. Prioritization + 5. Feature Impact + Jump to selected workshop + + + + +Load and execute: workshops/1-business-goals/instructions.md +Store outputs: vision, objectives + + + +Load and execute: workshops/2-target-groups/instructions.md +Store outputs: target_groups, personas + + + +Load and execute: workshops/3-driving-forces/instructions.md +Store outputs: driving_forces_positive, driving_forces_negative + + + +Load and execute: workshops/4-prioritization/instructions.md +Store outputs: prioritized_groups, prioritized_drivers + + + +Load and execute: workshops/5-feature-impact/instructions.md +Store outputs: feature_impact_analysis + + + +Generate 00-Trigger-Map-Poster.md from template +Generate 01-Business-Goals.md (visions & objectives) +Generate 02-Target-Groups.md (all personas with drivers) +Generate 03-Feature-Impact-Analysis.md from template +Save individual persona files as 04-[Name].md, 05-[Name].md, etc. +Save all to {output_folder}/B-Trigger-Map/ + +✅ **Trigger Mapping complete!** + +**Created:** +- `B-Trigger-Map/00-Trigger-Map-Poster.md` - Visual overview +- `B-Trigger-Map/01-Business-Goals.md` - Visions & objectives +- `B-Trigger-Map/02-Target-Groups.md` - All personas with drivers +- `B-Trigger-Map/03-Feature-Impact-Analysis.md` - Prioritized features +- `B-Trigger-Map/04-08-*.md` - Individual persona detail files + +**Key Insights:** +{{summary_of_priorities}} + +You now have strategic clarity on: +- What success looks like (business goals) +- Who to focus on (target groups) +- What drives them (positive & negative forces) +- Which features matter most (impact analysis) + +Ready for the next phase! 🚀 + + + + diff --git a/src/modules/wds/workflows/2-trigger-mapping/templates/feature-impact.template.md b/src/modules/wds/workflows/2-trigger-mapping/templates/feature-impact.template.md new file mode 100644 index 00000000..b8d9238c --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/templates/feature-impact.template.md @@ -0,0 +1,46 @@ +# Feature Impact Analysis: {{project_name}} + +> **Status: Beta** - Scoring system being refined through real-world use + +## Scoring + +**Primary Persona (⭐):** High = 5 pts | Medium = 3 pts | Low = 1 pt +**Other Personas:** High = 3 pts | Medium = 1 pt | Low = 0 pts + +**Max Possible Score:** {{max_score}} (with {{persona_count}} personas) +**Must Have Threshold:** {{must_have_threshold}}+ or Primary High (5) + +--- + +## Prioritized Features + +| Rank | Feature | Score | Decision | +|------|---------|-------|----------| +{{#each sorted_features}} +| {{this.rank}} | {{this.name}} | {{this.score}} | {{this.decision}} | +{{/each}} + +--- + +## Decisions + +**Must Have MVP (Primary High OR Top Tier Score):** +{{#each must_have}} +- {{this.name}} ({{this.score}}) +{{/each}} + +**Consider for MVP:** +{{#each consider}} +- {{this.name}} ({{this.score}}) +{{/each}} + +**Defer (Nice-to-Have or Low Strategic Value):** +{{#each defer}} +- {{this.name}} ({{this.score}}) +{{/each}} + +--- + +*Generated by Whiteport Design Studio* +*Strategic input for Phase 4: UX Design and Phase 6: PRD/Development* +*Beta methodology - feedback welcome* diff --git a/src/modules/wds/workflows/2-trigger-mapping/templates/trigger-map.template.md b/src/modules/wds/workflows/2-trigger-mapping/templates/trigger-map.template.md new file mode 100644 index 00000000..749a12d1 --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/templates/trigger-map.template.md @@ -0,0 +1,136 @@ +# Trigger Map Poster: {{project_name}} + +> Visual overview connecting business goals to user psychology + +**Created:** {{date}} +**Author:** {{user_name}} +**Methodology:** Based on Effect Mapping (Balic & Domingues), adapted by WDS + +--- + +## Strategic Documents + +This is the visual overview. For detailed documentation, see: + +- **01-Business-Goals.md** - Full vision statements and SMART objectives +- **02-Target-Groups.md** - All personas with complete driving forces +- **03-Feature-Impact-Analysis.md** - Prioritized features with impact scores +- **04-08-*.md** - Individual persona detail files + +--- + +## Vision + +{{vision_statement}} + +--- + +## Business Objectives + +{{#each objectives}} +### Objective {{@index + 1}}: {{this.statement}} +- **Metric:** {{this.metric}} +- **Target:** {{this.target}} +- **Timeline:** {{this.timeline}} +{{/each}} + +--- + +## Target Groups (Prioritized) + +{{#each prioritized_groups}} +### {{@index + 1}}. {{this.name}} +**Priority Reasoning:** {{this.reasoning}} + +> {{this.persona_summary}} + +**Key Positive Drivers:** +{{#each this.positive_drivers}} +- {{this}} +{{/each}} + +**Key Negative Drivers:** +{{#each this.negative_drivers}} +- {{this}} +{{/each}} + +{{/each}} + +--- + +## Trigger Map Visualization + +``` +┌─────────────────────────────────────────────────────────────────────┐ +│ VISION │ +│ {{vision_short}} │ +└─────────────────────────────────────────────────────────────────────┘ + │ + ▼ +┌─────────────────────────────────────────────────────────────────────┐ +│ OBJECTIVES │ +│ {{#each objectives_short}}• {{this}} {{/each}} │ +└─────────────────────────────────────────────────────────────────────┘ + │ + ┌─────────────────────────┼─────────────────────────┐ + ▼ ▼ ▼ +┌───────────────┐ ┌───────────────┐ ┌───────────────┐ +│ {{group_1}} │ │ {{group_2}} │ │ {{group_3}} │ +└───────────────┘ └───────────────┘ └───────────────┘ + │ │ │ + ▼ ▼ ▼ + [Drivers] [Drivers] [Drivers] + + {{g1_pos}} + {{g2_pos}} + {{g3_pos}} + - {{g1_neg}} - {{g2_neg}} - {{g3_neg}} +``` + +--- + +## Design Focus Statement + +{{focus_statement}} + +**Primary Design Target:** {{top_group.name}} + +**Must Address:** +{{#each must_address_drivers}} +- {{this}} +{{/each}} + +**Should Address:** +{{#each should_address_drivers}} +- {{this}} +{{/each}} + +--- + +## Cross-Group Patterns + +### Shared Drivers +{{shared_drivers}} + +### Unique Drivers +{{unique_drivers}} + +{{#if conflicts}} +### Potential Tensions +{{conflicts}} +{{/if}} + +--- + +## Next Steps + +This Trigger Map Poster provides a quick reference. For detailed work: + +- [ ] **Review detailed docs** - See 01-Business-Goals.md, 02-Target-Groups.md, 03-Feature-Impact-Analysis.md +- [ ] **Use for Feature Prioritization** - Reference feature impact scores +- [ ] **Guide UX Design** - Ensure designs address priority drivers +- [ ] **Validate with Users** - Test assumptions with real target group members +- [ ] **Update as Learnings Emerge** - This is a living document + +--- + +*Generated by Whiteport Design Studio* +*Trigger Mapping methodology credits: Effect Mapping by Mijo Balic & Ingrid Domingues (inUse), adapted with negative driving forces by WDS* + diff --git a/src/modules/wds/workflows/2-trigger-mapping/workflow.yaml b/src/modules/wds/workflows/2-trigger-mapping/workflow.yaml new file mode 100644 index 00000000..d425f203 --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/workflow.yaml @@ -0,0 +1,58 @@ +# WDS Phase 2: Trigger Mapping +name: trigger-mapping +description: "Map business goals to user psychology through structured workshops" +author: "Whiteport Design Studio" +phase: 2 + +# Based on Effect Mapping by Mijo Balic & Ingrid Domingues (inUse) +# Adapted by WDS: simplified (no features), enhanced with negative driving forces + +# Critical variables from config +config_source: "{project-root}/{bmad_folder}/wds/config.yaml" +output_folder: "{config_source}:output_folder" +user_name: "{config_source}:user_name" +project_name: "{config_source}:project_name" +communication_language: "{config_source}:communication_language" +document_output_language: "{config_source}:document_output_language" +date: system-generated + +# Workflow components +installed_path: "{project-root}/{bmad_folder}/wds/workflows/2-trigger-mapping" +instructions: "{installed_path}/instructions.md" + +# Workshop micro-workflows +workshops: + business-goals: + instructions: "{installed_path}/workshops/1-business-goals/instructions.md" + output: "Vision and SMART objectives" + target-groups: + instructions: "{installed_path}/workshops/2-target-groups/instructions.md" + output: "Personas with descriptions" + driving-forces: + instructions: "{installed_path}/workshops/3-driving-forces/instructions.md" + output: "Positive and negative drivers per group" + prioritization: + instructions: "{installed_path}/workshops/4-prioritization/instructions.md" + output: "Ranked groups and drivers" + feature-impact: + instructions: "{installed_path}/workshops/5-feature-impact/instructions.md" + output: "Features scored against priorities" + +# Templates +templates: + trigger_map: "{installed_path}/templates/trigger-map.template.md" + feature_impact: "{installed_path}/templates/feature-impact.template.md" + +# Output configuration +output_folder_name: "B-Trigger-Map" +output_files: + - "trigger-map.md" + - "personas/" + - "feature-impact-analysis.md" + +# Agent assignment +primary_agent: "saga-analyst" + +standalone: true +web_bundle: false + diff --git a/src/modules/wds/workflows/2-trigger-mapping/workshops/1-business-goals/instructions.md b/src/modules/wds/workflows/2-trigger-mapping/workshops/1-business-goals/instructions.md new file mode 100644 index 00000000..49606bca --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/workshops/1-business-goals/instructions.md @@ -0,0 +1,101 @@ +# Workshop 1: Business Goals + +You are Saga the Analyst - facilitating strategic clarity + + + + +**Workshop 1: Business Goals** 🎯 + +We'll define what success looks like at two levels: +- **Vision** - The inspiring, aspirational goal (not easily quantified) +- **Objectives** - SMART metrics that indicate progress + +Let's start with the dream, then make it measurable. + + + +**Where do you want to be?** + +Think big. If everything goes perfectly, what position do you want to hold? + +Examples: +- "Be the most trusted platform for dog owners in Sweden" +- "The go-to tool for indie designers" +- "Make project management actually enjoyable" + +Listen for aspirational, motivating language +Help refine into a clear, inspiring vision statement + +**Your Vision:** +{{vision_statement}} + +vision_statement + + + +Now let's make this measurable. What would indicate you're achieving that vision? + +**How would you measure progress toward this vision?** + +Think about: +- User metrics (adoption, engagement, retention) +- Business metrics (revenue, growth, market share) +- Quality metrics (satisfaction, referrals, reviews) + +What numbers would make you confident you're on track? + +For each metric mentioned, help make it SMART: +- **S**pecific - What exactly? +- **M**easurable - What number? +- **A**chievable - Is this realistic? +- **R**elevant - Does this connect to the vision? +- **T**ime-bound - By when? + + +Aim for 3-5 clear objectives + + + +Let me help sharpen these into SMART objectives. + +For each objective, walk through: + +Example transformation: +- Vague: "Get influential users" +- SMART: "Onboard 10 verified dog trainers with 1000+ followers by Q4 2026" + +Present each refined objective for confirmation. + +Here are your refined objectives: + +{{#each objectives}} +**Objective {{@index + 1}}:** {{this.statement}} +- Metric: {{this.metric}} +- Target: {{this.target}} +- Timeline: {{this.timeline}} +{{/each}} + +Do these capture what success looks like? Any adjustments? + +objectives + + + +**Workshop 1 Complete!** ✅ + +**Vision:** +{{vision_statement}} + +**Objectives:** +{{#each objectives}} +{{@index + 1}}. {{this.statement}} +{{/each}} + +This gives us clear targets to work toward. Next, we'll identify who can help you achieve these goals. + +Store vision_statement and objectives for next workshop + + + + diff --git a/src/modules/wds/workflows/2-trigger-mapping/workshops/2-target-groups/instructions.md b/src/modules/wds/workflows/2-trigger-mapping/workshops/2-target-groups/instructions.md new file mode 100644 index 00000000..330a2ad9 --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/workshops/2-target-groups/instructions.md @@ -0,0 +1,104 @@ +# Workshop 2: Target Groups + +You are Saga the Analyst - building empathy through understanding + + + + +**Workshop 2: Target Groups** 👥 + +Now we identify the people who matter most to achieving your goals. + +We'll create: +- A list of user groups +- Rich descriptions (personas) +- Understanding of their context + + + +Looking at your objectives: +{{#each objectives}} +- {{this.statement}} +{{/each}} + +**Who needs to use your product for you to achieve these goals?** + +For your business to succeed, the product needs to be used in the intended way by real people. Think about: + +- **Who out there in the world**, by using your product, will make these business goals happen? +- **Primary users** - Who uses it directly and regularly? +- **Influencers** - Who affects whether others adopt it? +- **Decision makers** - Who chooses to buy/use it? + +List the types of people that come to mind. + +Capture each group mentioned +Ask clarifying questions to distinguish similar groups + +target_groups_raw + + + +You mentioned these groups: +{{#each target_groups_raw}} +- {{this}} +{{/each}} + +**Which 2-4 groups are most critical to your success?** + +Consider: +- Who has the most influence on your objectives? +- Who, if delighted, would drive the others? +- Where is the biggest opportunity? + +Help narrow to 2-4 primary target groups + +target_groups + + + +Let's bring each group to life. We'll create a persona for each. + +For each target group, facilitate: + +**Let's explore: {{current_group}}** + +1. **Who are they?** (role, demographics, situation) +2. **What's their day like?** (context, responsibilities) +3. **What are they trying to achieve?** (goals) +4. **What frustrates them?** (pain points) +5. **How do they solve this problem today?** (current behavior) + +Build a narrative persona, not just bullet points +Give them a name and make them feel real + +**Persona: {{persona_name}}** + +{{persona_narrative}} + +**Goals:** {{persona_goals}} +**Frustrations:** {{persona_frustrations}} +**Current Solution:** {{persona_current_solution}} + +Does this feel like a real person you'd design for? Any adjustments? + +Repeat for each target group + +personas + + + +**Workshop 2 Complete!** ✅ + +**Your Target Groups:** +{{#each personas}} +- **{{this.name}}** - {{this.summary}} +{{/each}} + +These are the people we're designing for. Next, we'll explore what drives them - both toward and away from solutions. + +Store target_groups and personas for next workshop + + + + diff --git a/src/modules/wds/workflows/2-trigger-mapping/workshops/3-driving-forces/instructions.md b/src/modules/wds/workflows/2-trigger-mapping/workshops/3-driving-forces/instructions.md new file mode 100644 index 00000000..387efa9e --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/workshops/3-driving-forces/instructions.md @@ -0,0 +1,123 @@ +# Workshop 3: Driving Forces + +You are Saga the Analyst - uncovering motivation psychology + + + + +**Workshop 3: Driving Forces** ⚡ + +Now we dig into psychology. For each target group, we'll identify: + +- **Positive Drivers** - What they want to achieve, gain, or experience +- **Negative Drivers** - What they want to avoid, escape, or prevent + +Understanding both is crucial. Research shows people work harder to avoid pain than to pursue gain (loss aversion). Negative drivers often reveal the strongest design opportunities. + + + +For each persona, we'll explore: + +**Positive Drivers** (toward motivation): +- Aspirations and dreams +- Desired outcomes +- Experiences they seek +- Status or recognition goals + +**Negative Drivers** (away-from motivation): +- Fears and anxieties +- Problems they want gone +- Frustrations they're tired of +- Risks they want to avoid + +The magic happens when your design addresses both. + + + +For each persona, facilitate exploration: + +**Let's explore what drives {{persona.name}}** + +**Positive Drivers:** +What does {{persona.name}} want to achieve or experience? + +Think about: +- What would make their day better? +- What would they brag about to colleagues? +- What would make them feel successful? + +Capture 3-5 positive drivers + +**Negative Drivers:** +What does {{persona.name}} want to avoid or escape? + +Think about: +- What keeps them up at night? +- What frustrations are they tired of? +- What risks worry them? +- What embarrassments do they want to avoid? + +Capture 3-5 negative drivers + +**{{persona.name}}'s Driving Forces:** + +✅ **Positive Drivers:** +{{#each positive_drivers}} +- {{this}} +{{/each}} + +⚠️ **Negative Drivers:** +{{#each negative_drivers}} +- {{this}} +{{/each}} + +Does this capture what truly motivates {{persona.name}}? Anything to add? + +Repeat for each persona + +driving_forces + + + +Looking across all personas, I notice some patterns... + +Analyze for: +- Common drivers across groups +- Unique drivers per group +- Potential conflicts between groups + + +**Cross-Group Patterns:** + +**Shared Drivers:** +{{shared_drivers}} + +**Unique to Specific Groups:** +{{unique_drivers}} + +{{#if conflicts}} +**Potential Tensions:** +{{conflicts}} +{{/if}} + +driver_patterns + + + +**Workshop 3 Complete!** ✅ + +We've mapped the psychological landscape: + +{{#each personas}} +**{{this.name}}:** +- Wants: {{this.top_positive_driver}} +- Avoids: {{this.top_negative_driver}} +{{/each}} + +This is powerful insight. Next, we'll prioritize which groups and drivers to focus on. + +Store driving_forces and patterns for next workshop + + + + diff --git a/src/modules/wds/workflows/2-trigger-mapping/workshops/4-prioritization/instructions.md b/src/modules/wds/workflows/2-trigger-mapping/workshops/4-prioritization/instructions.md new file mode 100644 index 00000000..7f38cd78 --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/workshops/4-prioritization/instructions.md @@ -0,0 +1,194 @@ +# Workshop 4: Prioritization + +You are Saga the Analyst - challenging assumptions, seeking clarity + + + + +**Workshop 4: Prioritization** 🎯 + +Now we make the hard choices. We'll prioritize: +1. Business goals (visions) +2. Objectives under each goal +3. Target groups +4. Driving forces + +For each decision, I'll challenge you to explain **why** - because clear reasoning leads to better decisions. + + + + +**Let's start with your business goals.** + +You have multiple vision areas: +{{#each visions}} +- {{this}} +{{/each}} + +**Which business goal is most critical right now?** + +If you could only succeed at ONE of these, which would have the biggest impact on your business? + +When user chooses, challenge: + +**Why is "{{chosen_vision}}" more important than "{{other_vision}}"?** + +Help me understand your reasoning. What makes this the priority? + +Capture the reasoning - this reveals strategic thinking + +**And the second priority?** Again, tell me why. + +Build ranked list with reasoning for each + +**Your Business Goal Priority:** +{{#each prioritized_visions}} +{{@index + 1}}. **{{this.vision}}** + *Why:* {{this.reasoning}} +{{/each}} + +prioritized_visions + + + + +**Now let's prioritize the objectives under your top goal.** + +For "{{top_vision}}", you have these objectives: +{{#each top_vision_objectives}} +- {{this.statement}} +{{/each}} + +**Which objective is most important to achieve first?** + +Which one, if achieved, would have the biggest impact or unlock the others? + +Challenge the choice: + +**Why prioritize "{{chosen_objective}}" over "{{other_objective}}"?** + +What's your reasoning? + +Continue ranking with reasoning + +**Objective Priority for "{{top_vision}}":** +{{#each prioritized_objectives}} +{{@index + 1}}. {{this.statement}} + *Why:* {{this.reasoning}} +{{/each}} + +prioritized_objectives + + + +**Now let's rank who you're designing for.** + +Your target groups: +{{#each personas}} +- {{this.name}} +{{/each}} + +Looking at your top objective: "{{top_objective}}" + +**Which group, if delighted, would have the biggest impact on achieving that objective?** + +When user chooses, challenge: + +**Why is {{chosen_group}} more important than {{other_group}} for this objective?** + +What's the logic? + +Push for clear reasoning - this prevents "gut feel" prioritization + +**Second priority?** And why? + +**Your Target Group Priority:** +{{#each prioritized_groups}} +{{@index + 1}}. **{{this.name}}** + *Why:* {{this.reasoning}} +{{/each}} + +The top group gets most design attention. Does this ranking reflect your strategy? + +prioritized_groups + + + +**Now let's prioritize drivers for your top groups.** + +For top 2-3 groups, prioritize their drivers: + +For **{{current_group.name}}**, which drivers are most important to address? + +Their drivers: +✅ Positive: +{{#each current_group.positive_drivers}} +- {{this}} +{{/each}} + +⚠️ Negative: +{{#each current_group.negative_drivers}} +- {{this}} +{{/each}} + +**Rank the top 3-5 drivers** this group cares most about. + +Remember: negative drivers often have more weight (loss aversion). + +Help rank drivers with reasoning +Note that negative drivers may be weighted higher + +**Priority Drivers for {{current_group.name}}:** +{{#each prioritized_drivers}} +{{@index + 1}}. {{this.driver}} ({{this.type}}) - {{this.reasoning}} +{{/each}} + +prioritized_drivers + + + +Let's crystallize your focus. + +Synthesize into a clear focus statement: + +**Your Design Focus:** + +**Primary Group:** {{top_group.name}} +**Secondary:** {{second_group.name}} + +**Must Address:** +{{#each must_address_drivers}} +- {{this}} +{{/each}} + +**Should Address:** +{{#each should_address_drivers}} +- {{this}} +{{/each}} + +**Could Address (if time permits):** +{{#each could_address_drivers}} +- {{this}} +{{/each}} + +Does this focus feel right? This guides all feature decisions. + +focus_statement + + + +**Workshop 4 Complete!** ✅ + +**Your Strategic Focus:** +- Design primarily for **{{top_group.name}}** +- Address: {{top_drivers_summary}} + +This focus means saying "not yet" to some things. That's the power of prioritization. + +Next, we'll analyze which features best serve these priorities. + +Store prioritized_groups, prioritized_drivers, focus_statement + + + + diff --git a/src/modules/wds/workflows/2-trigger-mapping/workshops/5-feature-impact/instructions.md b/src/modules/wds/workflows/2-trigger-mapping/workshops/5-feature-impact/instructions.md new file mode 100644 index 00000000..1283aa9b --- /dev/null +++ b/src/modules/wds/workflows/2-trigger-mapping/workshops/5-feature-impact/instructions.md @@ -0,0 +1,150 @@ +# Workshop 5: Feature Impact Analysis (Beta) + +You are Saga the Analyst - strategic facilitator + +> **Status: Beta** - This scoring system is being refined through real-world use. Your feedback improves the methodology. + + + + +**Workshop 5: Feature Impact Analysis** 📊 *(Beta)* + +Now we create a **Design Brief** - strategic guidance for the designer on which features matter most and to whom. + +For each feature, we'll assess impact on each persona using a simple scale: +- **High** = Addresses major need or fear +- **Medium** = Helpful but not critical +- **Low** = Minimal impact + +This creates a scored, prioritized feature list that guides: +- **Phase 4: UX Design** - Which scenarios to design first +- **Phase 6: PRD/Development** - Epic and story prioritization + +This workshop is optional but highly valuable for strategic clarity. + + + +Silently read the project brief and extract: +- Core product features +- User interactions +- Content/communication elements + +Build feature_queue starting with key differentiators and core functionality. +Do NOT show full list to user - present one at a time. +Skip foundational features (auth, profiles, basic CRUD). + + +feature_queue + + + +Create feature-impact-analysis.md in B-Trigger-Map/ + +I'm creating your Feature Impact Analysis document. + +**Scoring:** +- **Primary Persona:** High = 5 pts | Medium = 3 pts | Low = 1 pt +- **Other Personas:** High = 3 pts | Medium = 1 pt | Low = 0 pts + +Let's score {{feature_count}} features from your brief. + + + +For each feature in queue: + +**Feature: {{current_feature}}** + +How does this impact each persona? + +**{{primary_persona.name}}** ⭐ (Primary): High, Medium, or Low? +Record response + +**{{secondary_persona.name}}**: High, Medium, or Low? +Record response + +**{{tertiary_persona.name}}** (if exists): High, Medium, or Low? +Record response + +Calculate score: +- Primary: High=5, Medium=3, Low=1 +- Others: High=3, Medium=1, Low=0 + + +✓ **{{current_feature}}** — Score: {{calculated_score}} + +Add to running table in document + +Every 3-4 features, offer: + +Continue with next feature, or add one you want scored? + +If user adds feature, score immediately then continue queue + +Continue until queue empty or user says "that's enough" + +feature_scores + + + +Sort features by score (high to low) + +Calculate dynamic thresholds based on persona count: +- max_possible = 5 (primary high) + 3 × (other_persona_count) +- must_have_threshold = Features with Primary High (5) OR score ≥ (max_possible - 3) +- consider_threshold = mid-range scores +- defer_threshold = low scores + + +Apply decisions: +- **Must Have:** Primary scored High (5 pts) OR score in top tier +- **Consider:** Medium-range scores, might serve strategic needs +- **Defer:** Low scores, minimal strategic value + + +**Scoring complete!** Here's your prioritized feature list: + +{{#each sorted_features}} +{{@index + 1}}. {{this.name}} — Score {{this.score}} +{{/each}} + +**Scoring context:** +- Max possible score with {{persona_count}} personas: {{max_possible}} +- Top tier (Must Have): {{must_have_threshold}}+ +- Primary critical (Must Have): Features with Primary High (5) + +Top features strongly serve your primary persona and strategic goals. + +prioritized_features + + + +Complete feature-impact-analysis.md with: +- Scoring legend +- Prioritized table with decisions +- Must Have / Consider / Defer sections + +Do NOT include analysis section - keep it clean. + + +✅ **Feature Impact Analysis complete!** + +**Saved to:** `B-Trigger-Map/00-feature-impact-analysis.md` + +This is your **Design Brief** - it tells the designer: +- **What to design first** - Top-scoring features = priority scenarios +- **Prominence in UI** - High scores = prominent placement +- **Who to optimize for** - Which persona's needs matter most + +**Trigger Mapping Complete!** 🎉 + +You now have: +- Clear business priorities +- Defined target personas with drivers +- Strategically ranked features + +Ready for **Phase 4: UX Design**! + +Store all outputs + + + diff --git a/src/modules/wds/workflows/3-prd-platform/instructions.md b/src/modules/wds/workflows/3-prd-platform/instructions.md new file mode 100644 index 00000000..d41a3fbe --- /dev/null +++ b/src/modules/wds/workflows/3-prd-platform/instructions.md @@ -0,0 +1,1110 @@ +# Phase 3: PRD Platform (Technical Foundation) + +**Agent:** Freyja the PM +**Output Folder:** `C-Requirements/` (or user's configured prefix) + +--- + +## Overview + +This phase establishes the technical foundation for the product—everything that can be validated and documented **before** the final UI is designed. The goal is to prove that innovative features are technically feasible, establish platform decisions, and set up experimental endpoints that enable parallel development work. + +**Core Principle:** Prove our concept works technically — in parallel with design work. + +--- + +## What You'll Create + +By the end of this phase, the `C-Requirements/` folder will contain comprehensive technical specifications: + +1. **00-Platform-Architecture.md** - Technology stack and infrastructure decisions +2. **01-Integration-Map.md** - External services and how they connect +3. **02-Technical-Proofs-Of-Concept.md** - Validation of risky features +4. **03-Security-Framework.md** - Authentication, authorization, compliance +5. **04-API-Specifications.md** - Service contracts and endpoint definitions (API-first) +6. **05-Data-Models.md** - Database schemas and entity relationships +7. **06-Performance-Requirements.md** - Scalability and benchmarks +8. **07-Technical-Constraints.md** - What UX design needs to know +9. **08-Acceptance-Criteria.md** - Testable success definitions +10. **09-Platform-Backlog-Recommendations.md** - Suggested epics/initiatives for BMM +11. **10-PRD.md** - Product Requirements Document (started here, grows in Phase 4) + +**Note:** These are requirements documents. The actual backlog creation (epics, stories, E-Backlog/ structure) will be handled by BMM agents based on these recommendations. + +--- + +## Prerequisites + +Before starting, ensure you have: + +- ✅ Product Brief (Phase 1) - Strategic context +- ✅ Trigger Map with Feature Impact Analysis (Phase 2) - Prioritized features +- ✅ Development team availability (for PoC work if needed) + +--- + +## Workflow Steps + +### Step 1: Welcome and Context Review + +**Freyja's Role:** + +Greet the user and explain this phase: +- "We're establishing your technical foundation—proving that innovative features work before investing in design." +- "We'll make platform decisions, validate risky features with PoCs, and set up experimental endpoints." +- "This enables backend development to start in parallel with UX design." + +Review available context: +- Read the Product Brief to understand project scope and constraints +- Read the Feature Impact Analysis to identify high-priority features +- Ask: "Do you already have any technical constraints or platform preferences?" + +--- + +### Step 2: Platform Architecture Decisions + +**Goal:** Define the technology stack and infrastructure through systematic discussion. + +**Freyja's Approach:** + +"Let's establish your technical foundation. I'll walk through each major area, and we'll document your decisions, business rules, and constraints as we go." + +**2A: Technology Stack** + +Ask each question and document the answer: + +1. **Backend:** + - "What backend framework/language are you using?" + - "Why this choice? Any specific requirements or constraints?" + - **Business Rules to Capture:** + - Language version requirements + - Framework-specific patterns or conventions + - Performance characteristics needed + +2. **Frontend:** + - "What frontend framework are you using?" + - "Any UI library or component framework?" + - "Why this choice?" + - **Business Rules to Capture:** + - Browser support requirements + - Mobile responsiveness needs + - Accessibility standards + +3. **Database:** + - "What database system(s) will you use?" + - "What are your core data entities?" (Start listing them) + - "How do they relate to each other?" + - **Business Rules to Capture:** + - Data retention policies + - Backup/recovery requirements + - Data consistency needs (ACID vs. eventual consistency) + +**2B: Architecture Style** + +Ask systematically: + +1. "Are you building a monolith, microservices, or serverless architecture?" +2. Based on answer, dive deeper: + - **If Monolith:** "How will you structure the codebase? Any module boundaries?" + - **If Microservices:** "What are your service boundaries? How will they communicate?" + - **If Serverless:** "What functions/lambdas? What triggers them?" +3. **Business Rules to Capture:** + - Deployment patterns + - Service boundaries and responsibilities + - Communication protocols + +**2C: Infrastructure & Hosting** + +Ask systematically: + +1. "What cloud provider or hosting platform?" +2. "Any specific infrastructure services needed?" (CDN, load balancers, etc.) +3. "What's your deployment approach?" (containers, VMs, serverless) +4. **Business Rules to Capture:** + - Geographic regions/data residency + - Disaster recovery requirements + - Cost constraints + +**2D: Platform Requirements & Standards** + +Ask systematically about critical platform concerns: + +1. **Accessibility:** + - "What accessibility standards do you need to meet?" (WCAG 2.1 Level AA, etc.) + - "Who are your accessibility-dependent users?" (screen reader users, keyboard-only, etc.) + - **Business Rules to Capture:** + - WCAG compliance level required + - Keyboard navigation requirements + - Screen reader compatibility + - Color contrast standards + - Alt text and ARIA label policies + +2. **Internationalization & Localization:** + - "What languages/regions do you need to support?" + - "Are there currency, date, or number format requirements?" + - **Business Rules to Capture:** + - Supported languages and locales + - RTL (right-to-left) language support + - Translation management approach + - Regional data formats + +3. **Browser & Device Compatibility:** + - "What browsers and versions must you support?" + - "What devices?" (desktop, mobile, tablet) + - "Any specific OS requirements?" + - **Business Rules to Capture:** + - Minimum browser versions + - Mobile responsiveness requirements + - Tablet-specific considerations + - Progressive web app (PWA) capabilities + +4. **Monitoring & Observability:** + - "What monitoring and logging do you need?" + - "Error tracking? Performance monitoring?" + - **Business Rules to Capture:** + - Logging level requirements + - Error tracking service + - Performance monitoring tools + - Uptime monitoring + - Alert thresholds + +**2E: Performance & Scale** + +Ask systematically: + +1. "What are your performance requirements?" + - Expected response times? + - How many concurrent users? + - Peak load expectations? +2. "What's your availability target?" (99%, 99.9%, 99.99%?) +3. "Any scalability concerns?" +4. **Business Rules to Capture:** + - SLA requirements + - Peak usage patterns + - Growth projections + +**After completing all sections:** + +"Let me summarize what we've covered for platform architecture... [summarize key points]" + +**Ask:** "Is there anything about the platform or infrastructure we should add? Any constraints or requirements we missed?" + +**Output:** Create `00-Platform-Architecture.md` using the template, incorporating all documented answers. + +--- + +### Step 3: Integration Mapping + +**Goal:** Systematically identify all external dependencies through intelligent, context-aware discussion. + +**Freyja's Approach:** + +"Let me review your Product Brief to understand which integrations you'll likely need, then we'll go through each relevant category systematically." + +**First: Analyze Product Brief** + +Read the Product Brief and identify relevant integration categories based on features mentioned: + +- **Payment Processing:** Transactions, subscriptions, e-commerce, paid features, pricing +- **Communication:** User notifications, emails, SMS, alerts, reminders +- **Maps/Location:** Geographic features, addresses, directions, proximity, location-based services +- **Search:** Large content volumes, filtering, discovery features +- **Calendar/Scheduling:** Bookings, appointments, events, availability +- **Social Media:** Sharing, social login, content from social platforms +- **Analytics:** User tracking, behavior analysis, conversion tracking +- **Storage/Media:** File uploads, images, videos, documents +- **Customer Support:** Help features, ticketing, live chat +- **Authentication:** User accounts, SSO, enterprise login +- **Domain-Specific:** Industry-specific services mentioned + +**Present Relevant Categories:** + +"Based on your Product Brief, I've identified these integration categories that seem relevant:" + +[List only applicable categories with reasons from brief] + +"Let's go through each of these, then check if there are others you need." + +--- + +**Go through each relevant category systematically:** + +**3A: Authentication & Identity** +- "How will users authenticate?" (OAuth, email/password, SSO, passwordless) +- "Which providers?" (Google, Microsoft, Auth0, etc.) +- **Document for each:** + - Service name & purpose + - Business rules (token lifetime, MFA requirements) + - Priority (must-have/nice-to-have) + - Cost estimate + - Technical risk (high/medium/low) + +**3B: Payment Processing** (if applicable) +- "Do you need payment processing?" +- "Which payment providers?" (Stripe, PayPal, Klarna, Swish, regional systems) +- "What payment methods?" (credit cards, bank transfers, mobile payments, digital wallets) +- "What currencies do you need to support?" +- "Do you need subscription/recurring billing?" +- **Document for each:** + - Service name & purpose + - **Business rules:** + - Supported payment methods + - Currency handling + - Refund policies and workflows + - Failed payment retry logic + - Subscription management (if applicable) + - Tax calculation and collection + - Invoice generation requirements + - Payment confirmation/receipt delivery + - **Compliance needs:** PCI-DSS requirements + - **Integration complexity:** Webhooks, payment status tracking + - Priority & cost (transaction fees, monthly costs) + - Technical risk level + +**3C: Communication Services** +- "Do you need to send emails?" → Which service? (SendGrid, Mailgun, AWS SES, Postmark) +- "Do you need SMS?" → Which service? (Twilio, MessageBird, Vonage) +- "Push notifications?" → Which service? (Firebase Cloud Messaging, OneSignal, Pusher) +- "In-app messaging or chat?" → Which service? (Twilio, Stream, PubNub) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - Message templates and customization + - Delivery guarantees and retries + - Opt-out/unsubscribe handling + - Bounce and complaint management + - Multi-language support + - Transactional vs marketing messages + - Volume estimates (messages per month) + - Priority & cost + +**3D: Search Services** (if applicable) +- "Do you need advanced search functionality?" +- "Which service?" (Algolia, Elasticsearch, Typesense, Meilisearch) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - What needs to be searchable? + - Faceted search requirements + - Auto-complete/type-ahead needs + - Search result ranking logic + - Filter and sort options + - Multi-language search + - Index size estimates + - Query volume expectations + - Priority & cost + +**3E: Maps & Location** (if applicable) +- "Do you need maps or geolocation?" +- "Which service?" (Google Maps, Mapbox, OpenStreetMap, Here) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - Geocoding (address → coordinates) + - Reverse geocoding (coordinates → address) + - Route calculation + - Distance/duration estimation + - Map display and interaction + - Geofencing requirements + - API call limits and caching strategy + - Accuracy requirements + - Expected API call volume + - Cost per API call + - Priority & risk level + +**3F: Data & Analytics** +- "What analytics do you need?" (Google Analytics, Mixpanel, Amplitude, custom) +- "Error tracking?" (Sentry, Rollbar, Bugsnag) +- "Application monitoring?" (New Relic, Datadog, AppDynamics) +- "User session recording?" (FullStory, Hotjar, LogRocket) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - Events to track + - User privacy considerations + - Data retention policies + - GDPR compliance for tracking + - Custom dashboards/reports needed + - Data volume estimates + - Priority & cost + +**3G: Storage & Media** +- "Do you need file/image storage?" (S3, Azure Blob, Google Cloud Storage, Cloudinary) +- "CDN for assets?" (CloudFlare, Fastly, AWS CloudFront) +- "Video hosting/streaming?" (Vimeo, YouTube, Mux, AWS Media Services) +- "Document processing?" (PDF generation, document conversion) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - File size limits + - Supported file types + - Image/video processing (resizing, transcoding) + - Retention policies and backup + - Access control (public/private) + - Virus scanning requirements + - Volume estimates (storage, bandwidth) + - Priority & cost + +**3H: Calendar & Scheduling** (if applicable) +- "Do you need calendar integrations?" +- "Which services?" (Google Calendar, Outlook/Microsoft 365, iCal) +- "Scheduling/booking systems?" (Calendly-style booking) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - Event creation and updates + - Availability checking + - Timezone handling + - Recurring events + - Reminders and notifications + - Priority & cost + +**3I: Social Media & Content** (if applicable) +- "Do you need social media integrations?" +- "Which platforms?" (Facebook, Twitter/X, LinkedIn, Instagram) +- "Social login?" (covered in 3A, but cross-reference) +- "Content sharing?" (Open Graph, Twitter Cards) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - What data to fetch/post + - Authentication flow + - Rate limits + - Content moderation needs + - Priority & cost + +**3J: Customer Support & Help** (if applicable) +- "Do you need customer support tools?" +- "Which services?" (Intercom, Zendesk, Helpscout, Crisp) +- "Live chat?" (service or custom) +- "Knowledge base/docs?" (service or custom) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - User identification and context + - Ticket creation workflow + - SLA requirements + - Multi-language support + - Priority & cost + +**3K: Marketing & Growth** (if applicable) +- "Do you need marketing automation?" +- "Which services?" (Mailchimp, HubSpot, ActiveCampaign) +- "A/B testing?" (Optimizely, VWO, custom) +- "Feature flags?" (LaunchDarkly, Flagsmith, custom) +- **Document for each:** + - Service name & purpose + - **Business rules:** + - Audience segmentation + - Campaign triggers + - Testing methodology + - Rollout strategies + - Priority & cost + +**3L: Domain-Specific APIs** +- "Any other APIs specific to your domain?" (industry-specific services) +- Examples: Weather APIs, financial data, shipping/logistics, government data, industry databases +- **Document for each:** + - Service name & purpose + - Business rules & constraints + - Data format requirements + - Priority & risk level + +**After completing all categories:** + +"Let me list all the external services we've identified... [summarize]" + +**Ask:** "Are there any other external services, APIs, or integrations we should include? Anything we missed?" + +**Output:** Create `01-Integration-Map.md` with all services categorized and documented. + +--- + +### Step 4: Identify Features Needing Technical Validation + +**Goal:** Determine which features need Proofs of Concept (PoCs). + +Review the Feature Impact Analysis and ask: +- **Which features are innovative or unproven?** +- **Which features depend on external APIs that might have limitations?** +- **Which features have unknown performance characteristics?** +- **Which features might not be technically feasible?** + +**Red Flags That Suggest PoC Needed:** +- "Can we actually get X data from Y service?" +- "Will this perform fast enough?" +- "Does this API return data in a usable format?" +- "Can we achieve real-time updates at scale?" + +Create a list of features requiring validation, prioritized by: +1. **High Feature Impact Score** (from Phase 2) + **High Technical Risk** +2. **Medium Feature Impact** + **High Technical Risk** +3. **High Feature Impact** + **Medium Technical Risk** + +--- + +### Step 5: Technical Proofs of Concept (PoCs) + +**Goal:** Validate that risky features are technically feasible. + +For each feature identified in Step 4: + +1. **Define the Question:** + - What exactly needs to be proven? + - Example: "Can we get walking time between two coordinates from Google Maps API?" + +2. **Create or Request PoC:** + - If development team is available: Assign PoC task + - If conducting PoC now: Guide user through quick validation + - Document the approach taken + +3. **Document Results:** + - **Status:** ✅ Proven / ⚠️ Limited / ❌ Not Feasible + - **Findings:** What worked, what didn't + - **Limitations:** Edge cases, performance concerns, cost implications + - **Recommendation:** Go / No-Go / Modify Feature + +4. **Code Snippets:** Include working code examples when possible + +**Output:** Create `02-Technical-Proofs-Of-Concept.md` documenting all PoC work. + +**Positive Framing:** +- When features work: "Great! This proves [feature] is technically sound. Design can proceed with confidence." +- When features have limitations: "Valuable discovery! We found [limitation] early. This helps design account for it from the start." +- When features don't work: "Important learning! This saves weeks of design work on an infeasible feature. Let's explore alternatives." + +--- + +### Step 6: Security & Compliance Framework + +**Goal:** Systematically define security, authentication, and compliance through detailed discussion. + +**Freyja's Approach:** + +"Security is critical. Let's go through each security area methodically and document all business rules and requirements." + +**6A: Authentication** + +Ask systematically: + +1. "How will users authenticate?" (List options: email/password, OAuth, SSO, passwordless, biometric) +2. "Do you need multi-factor authentication?" +3. "What's your session management approach?" + - Session lifetime? + - Remember me functionality? + - Concurrent session handling? +4. **Business Rules to Capture:** + - Password requirements (length, complexity, expiration) + - Account lockout policies + - Password reset flow + - Session timeout rules + +**6B: Authorization** + +Ask systematically: + +1. "What user roles do you need?" (List them: admin, user, moderator, etc.) +2. "What can each role do?" (Go through each role) +3. "Do you need row-level security?" (Can users only see their own data?) +4. "How will API access be controlled?" +5. **Business Rules to Capture:** + - Permission matrix (role × action) + - Data visibility rules + - API rate limiting per role + - Admin capabilities and restrictions + +**6C: Data Protection** + +Ask systematically: + +1. "What sensitive data needs encryption at rest?" + - Passwords? (always yes) + - Personal information? + - Payment data? + - Other sensitive fields? +2. "TLS/HTTPS for all traffic?" (should be yes) +3. "What's your backup strategy?" + - Backup frequency? + - Retention period? + - Recovery time objective (RTO)? + - Recovery point objective (RPO)? +4. **Business Rules to Capture:** + - Encryption algorithms + - Key management approach + - Data deletion policies (right to be forgotten) + - Backup and recovery procedures + +**6D: Compliance & Regulations** + +Ask systematically about all regulatory requirements: + +1. **GDPR (EU General Data Protection Regulation):** + - "Do you have EU users or process EU citizen data?" + - If yes, document requirements: + - **Consent Management:** + - Cookie consent mechanism + - Data processing consent + - Consent withdrawal process + - **User Rights:** + - Right to access (data export) + - Right to deletion (right to be forgotten) + - Right to rectification (data correction) + - Right to data portability + - Right to object to processing + - **Data Protection:** + - Privacy policy requirements + - Data processing agreements + - Data breach notification procedures (72-hour rule) + - Data Protection Impact Assessment (DPIA) needs + - **Business Rules to Capture:** + - Consent storage and tracking + - Data retention periods + - Data deletion workflows + - User data export format + - Third-party data processor agreements + +2. **Other Privacy Regulations:** + - "Are you subject to CCPA (California)?" → California Consumer Privacy Act requirements + - "HIPAA (Healthcare)?" → Health data protection standards + - "PCI-DSS (Payments)?" → Payment card data security + - "COPPA (Children)?" → Children's online privacy protection + - **Business Rules for each applicable regulation** + +3. **Data Residency & Sovereignty:** + - "Must data stay in specific geographic regions?" + - "Any country-specific data laws?" + - **Business Rules to Capture:** + - Data storage location requirements + - Cross-border data transfer restrictions + - Regional compliance needs + +4. **Industry-Specific Regulations:** + - "Any industry-specific compliance?" (Financial, healthcare, education, etc.) + - **Business Rules to Capture:** + - Specific regulatory requirements + - Compliance documentation needs + - Regular audit requirements + +5. **Audit Logging & Compliance Tracking:** + - "Do you need audit trails for compliance?" + - "What actions must be logged?" + - **Business Rules to Capture:** + - Events requiring audit logs (user actions, data access, changes) + - Log retention period (often 7 years for compliance) + - Who can access audit logs + - Tamper-proof logging requirements + - Regular compliance reporting needs + +**After completing all security areas:** + +"Let me summarize our security framework... [summarize key points]" + +**Ask:** "Is there anything about security, privacy, or compliance we should add? Any requirements or constraints we missed?" + +**Output:** Create `03-Security-Framework.md` with all security rules and requirements documented. + +--- + +### Step 7: API Specifications (API-First Design) + +**Goal:** Define comprehensive API contracts through systematic category-by-category discussion. + +**Freyja explains:** + +"We're taking an API-first approach. By defining clear service contracts now, we enable backend development to proceed in parallel with UX design. These APIs will serve as the foundation for all future UI work." + +**7A: Authentication APIs** + +"Let's start with authentication. Based on our security framework, what auth endpoints do you need?" + +For each endpoint: +- Method & Path (e.g., `POST /api/auth/login`) +- Purpose & business value +- Request/response format with detailed schemas +- **Business Rules:** + - Token lifetime & refresh behavior + - Error responses (invalid credentials, locked account, etc.) + - Security requirements (HTTPS, rate limiting, etc.) +- Status (planned/in-progress/complete) + +Common auth endpoints: login, logout, token refresh, password reset, email verification + +**7B: Core Entity APIs (CRUD Operations)** + +"Now let's define APIs for your main data entities." + +Go through each entity from the data model systematically: + +For each entity, define all CRUD operations: +- `GET /api/{entity}` - List with pagination +- `GET /api/{entity}/:id` - Get single item +- `POST /api/{entity}` - Create new +- `PUT /api/{entity}/:id` - Update existing +- `DELETE /api/{entity}/:id` - Delete item + +**Business Rules for each:** + - Validation rules (required fields, formats, constraints) + - Authorization (who can perform this operation?) + - Pagination parameters (page size, sorting, filtering) + - Related data inclusion (nested objects, joins) + - Business logic constraints + +**7C: External Integration APIs** + +"Which external services need API endpoints? Let's create wrappers for each." + +For each external service from Step 3: +- Method & Path +- Purpose ("Wraps Google Maps API to get walking time") +- Request/response format +- **Business Rules:** + - Pre-call validation + - Caching strategy + - Fallback behavior on external failure + - Rate limiting + - Cost tracking per call +- External service dependencies + +**7D: Business Logic APIs** + +"What calculations or business operations need dedicated endpoints?" + +Examples: availability checks, pricing, recommendations, aggregations + +For each: +- Method & Path +- Purpose & business value +- Request/response format +- **Business Rules:** + - Calculation logic + - Data sources + - Edge cases & error handling + - Performance expectations +- Dependencies + +**After defining all APIs:** + +"Let me summarize the API surface... [list by category]" + +**Ask:** "Are there any other API operations we should include? Any data needs we forgot?" + +**Output:** Create `04-API-Specifications.md` with complete service contracts. + +--- + +### Step 8: Data Models & Performance Requirements + +**Goal:** Document database schemas and performance benchmarks. + +**Freyja's Approach:** + +"Let's formalize the data model and set clear performance expectations." + +**8A: Data Models** + +"We identified your core entities earlier. Now let's document the complete data model." + +For each entity: +- Entity name & purpose +- All fields with types, constraints, defaults +- Relationships to other entities (one-to-many, many-to-many) +- Indexes for performance +- **Business Rules:** + - Data validation rules + - Required vs. optional fields + - Unique constraints + - Cascade delete behavior + - Audit trail needs + +Create entity relationship diagram (ERD) showing all connections. + +**8B: Performance Requirements** + +"What are your performance and scalability expectations?" + +Document systematically: +- **Response Times:** Expected latency for each API category +- **Throughput:** Concurrent users, requests per second +- **Data Volume:** Expected record counts, storage needs +- **Availability:** Uptime requirements (99%, 99.9%, 99.99%?) +- **Scalability:** Growth projections and scaling triggers + +**Ask:** "Any other data modeling or performance considerations we should capture?" + +**Outputs:** +- `05-Data-Models.md` - Complete schemas and ERD +- `06-Performance-Requirements.md` - Benchmarks and scalability specs + +--- + +### Step 9: Technical Constraints & Acceptance Criteria + +**Goal:** Create UX design handoff document and define success criteria. + +**9A: Technical Constraints Document** + +"This document tells the UX team what they need to know about technical possibilities and limitations." + +**Include:** +- **What's Possible:** Validated features from PoCs, platform capabilities +- **What Has Limitations:** Technical constraints, API limits, performance characteristics +- **What Affects Design:** Loading states, offline behavior, real-time vs. polling +- **What's Expensive:** Cost-sensitive features requiring careful UX + +**9B: Acceptance Criteria** + +"How do we know when each platform component is 'done'?" + +For each major platform area (auth, integrations, security, etc.): +- **Functional Criteria:** What must work? +- **Performance Criteria:** How fast/scalable must it be? +- **Security Criteria:** What security standards must be met? +- **Testing Criteria:** What tests must pass? + +**Ask:** "Any other constraints or success criteria we should document?" + +**Outputs:** +- `07-Technical-Constraints.md` - UX design handoff +- `08-Acceptance-Criteria.md` - Testable success definitions + +--- + +### Step 10: Platform Backlog Recommendations + +**Goal:** Recommend platform infrastructure work for BMM to organize into epics and stories, prioritized by Feature Impact Analysis. + +**Freyja explains:** + +"Based on all the technical requirements we've documented AND the Feature Impact Analysis from Phase 2, let me suggest how this platform work could be organized for development. We'll prioritize platform work that enables your highest-impact features first." + +**10A: Review Feature Impact Analysis** + +"Let's look at your high-priority features from Phase 2..." + +Read the Feature Impact Analysis (B-Trigger-Map/03-Feature-Impact-Analysis.md) and identify: +- **Must Have features** (high scores, high for primary persona) +- **Consider for MVP features** (balanced scores) +- **Platform dependencies** - What platform work is needed to enable each high-impact feature? + +**10B: Identify Recommended Initiatives & Epics** + +"Based on your Feature Impact Analysis and technical requirements, here are the major platform initiatives I recommend:" + +For each recommended epic, note which high-priority features it enables: + +**Initiative: Platform Foundation** + +- **Epic: Trusted User Access** (Authentication & user management) + - Suggested from: Security Framework, API Specifications (auth endpoints) + - **Enables features:** [List high-impact features requiring authentication] + - **Feature Impact scores:** [Reference specific features from Phase 2] + - Business value: Enable secure user access and identity management + - Key deliverables: Auth system, user management, session handling + +- **Epic: [External Service] Integration** (One per major integration) + - Suggested from: Integration Map, API Specifications (integration endpoints) + - **Enables features:** [List high-impact features requiring this integration] + - **Feature Impact scores:** [Reference specific features from Phase 2] + - Business value: Connect to [service] to enable [specific high-priority features] + - Key deliverables: Service integration, error handling, data sync + +- **Epic: Data Platform Foundation** (Database, models, synchronization) + - Suggested from: Data Models, Performance Requirements + - **Enables features:** [List high-impact features requiring data storage] + - **Feature Impact scores:** [Reference specific features from Phase 2] + - Business value: Reliable data storage and access for all features + - Key deliverables: Database setup, schema implementation, migrations + +- **Epic: Enterprise Security & Compliance** + - Suggested from: Security Framework, Acceptance Criteria + - **Enables features:** [Security-dependent features] + - Business value: Meet security and compliance requirements + - Key deliverables: Encryption, audit logging, compliance controls + +- **Epic: High-Performance Infrastructure** + - Suggested from: Performance Requirements, Platform Architecture + - **Enables features:** [Performance-sensitive features from Phase 2] + - Business value: Scalable, responsive system that meets performance targets + - Key deliverables: Caching, optimization, monitoring + +**10C: Recommended Development Sequence (Priority-Driven)** + +"Here's the order I'd recommend, based on Feature Impact Analysis:" + +**Priority 1: Enable Must-Have Features** +1. **Foundation First:** Core infrastructure (hosting, database, basic security) +2. **High-Impact Dependencies:** Platform work needed for Must-Have features + - [Epic] enables [Feature] (Score: X) for [Primary Persona] + - [Epic] enables [Feature] (Score: Y) for [Primary Persona] + +**Priority 2: Risk Mitigation** +3. **Complex Integrations:** External APIs that are risky or complex (fail fast) + - [Integration Epic] enables [Feature] (Score: X) + +**Priority 3: Secondary Features** +4. **Remaining Integrations:** Other external services +5. **Advanced Features:** Performance optimization, advanced security + +**Priority 4: Operations** +6. **Monitoring & Tools:** Logging, analytics, maintenance tools + +**10D: Feature-to-Epic Mapping** + +"Here's how each high-priority feature maps to platform work:" + +Create a table: +| Feature (from Phase 2) | Score | Priority | Required Platform Epics | Notes | +|------------------------|-------|----------|-------------------------|-------| +| [Feature Name] | 7 | Must Have | Trusted User Access, Data Platform | Needs auth + storage | +| [Feature Name] | 7 | Must Have | [Integration] Epic, Data Platform | Critical integration | +| [Feature Name] | 5 | Must Have | Data Platform, High-Performance | Primary persona critical | + +**10E: API Contracts for Future UI Development** + +"These API specifications are ready for frontend development:" +- [List key API categories organized by priority features they enable] +- Backend can implement these in parallel with Phase 4 (UX Design) + +**10F: Dependencies & Parallel Work** + +"Key dependencies to consider:" +- What must be done before high-impact features can be built? +- What can be developed independently in parallel? +- What provides the most risk reduction AND feature enablement if done early? + +**Ask:** "Does this platform work organization make sense based on your feature priorities? Any initiatives or priorities you'd adjust?" + +**Output:** Create `09-Platform-Backlog-Recommendations.md` with: +- **Feature Impact Summary** - High-priority features from Phase 2 +- **Feature-to-Epic Mapping** - Clear connections between features and platform work +- Recommended initiative structure +- Suggested epic breakdown with business value statements +- **Priority-driven development sequence** - Based on Feature Impact Analysis +- Dependencies and parallel work opportunities +- API contract readiness for future UI +- Notes for BMM agents on implementation approach + +**Handoff to BMM:** "These recommendations, informed by your Feature Impact Analysis, will guide BMM agents when they create the actual E-Backlog/ structure with detailed epics and stories. They'll know exactly which platform work enables your highest-value features." + +--- + +### Step 11: Finalize the PRD + +**Goal:** Create the master PRD that references all Phase 3 work. + +**Freyja explains:** + +"The PRD is your single source of truth. It starts here with technical foundation and will grow during Phase 4 as functional requirements are added from UX design." + +**PRD Structure:** + +```markdown +# Product Requirements Document: [Project Name] + +*Phase 3 Complete: Technical Foundation Established* +*Last Updated: [Date]* + +--- + +## 1. Executive Summary + +[Link to Product Brief from Phase 1] +[Link to Trigger Map from Phase 2] + +--- + +## 2. Technical Foundation (Phase 3) + +### 2.1 Platform Architecture +[Link to C-Requirements/00-Platform-Architecture.md] + +### 2.2 External Integrations +[Link to C-Requirements/01-Integration-Map.md] + +### 2.3 Technical Validation +[Link to C-Requirements/02-Technical-Proofs-Of-Concept.md] + +### 2.4 Security & Compliance +[Link to C-Requirements/03-Security-Framework.md] + +### 2.5 API Specifications +[Link to C-Requirements/04-API-Specifications.md] + +### 2.6 Data Models +[Link to C-Requirements/05-Data-Models.md] + +### 2.7 Performance Requirements +[Link to C-Requirements/06-Performance-Requirements.md] + +### 2.8 Technical Constraints +[Link to C-Requirements/07-Technical-Constraints.md] + +### 2.9 Acceptance Criteria +[Link to C-Requirements/08-Acceptance-Criteria.md] + +--- + +## 3. Platform Backlog Recommendations + +[Link to C-Requirements/09-Platform-Backlog-Recommendations.md] + +**Summary:** +- **Recommended Initiatives:** [List] +- **Suggested Epics:** [Count] +- **API Contracts Ready:** [Key APIs] +- **Ready for BMM:** Platform requirements complete for backlog creation + +--- + +## 4. Functional Requirements (Phase 4) + +*This section will be populated during Phase 4 (UX Design) as each page/scenario is completed.* + +### [Feature Area 1] +*Coming from Phase 4* + +### [Feature Area 2] +*Coming from Phase 4* + +--- + +## 5. Next Steps + +**For BMM Agents:** +- Use platform backlog recommendations to create E-Backlog/ structure +- Create detailed epics and stories from requirements documents +- Establish implementation roadmap with dependencies + +**For Phase 4 (UX Design):** +- Technical constraints document provides design boundaries +- API specifications define data available to UI +- Begin UX design with confidence in technical feasibility + +--- + +## 6. Change Log + +- [Date] - Phase 3 complete: Technical foundation established +- [Date] - Platform backlog recommendations provided for BMM +``` + +**Output:** Create `C-Requirements/10-PRD.md` + +--- + +### Step 12: Summary and Completeness Check + +**Freyja congratulates the user:** + +"Excellent work! We've systematically documented your technical foundation. Let me summarize what we've created:" + +**Review each document:** + +1. ✅ **Platform Architecture** - Technology stack, infrastructure, data model +2. ✅ **Integration Map** - All external services with business rules +3. ✅ **Technical Proofs of Concept** - Validated risky features +4. ✅ **Security Framework** - Authentication, authorization, compliance rules +5. ✅ **API Specifications** - Service contracts for all endpoints (API-first) +6. ✅ **Data Models** - Complete schemas and ERD +7. ✅ **Performance Requirements** - Scalability and benchmarks +8. ✅ **Technical Constraints** - What UX design needs to know +9. ✅ **Acceptance Criteria** - Success definitions +10. ✅ **Platform Backlog Recommendations** - Suggested work organization for BMM +11. ✅ **PRD Initialized** - Ready to grow in Phase 4 + +**Completeness Check:** + +"Before we finish, let's make sure we haven't missed anything important:" + +**Ask systematically:** + +1. **"Looking at your platform architecture - is there any technology choice, constraint, or requirement we didn't discuss?"** + +2. **"For integrations - are there any external services, APIs, or third-party tools we forgot to include?"** + +3. **"Thinking about security - any authentication flows, data protection needs, or compliance requirements we should add?"** + +4. **"For API specifications - any endpoints, data operations, or service contracts we missed?"** + +5. **"Looking at the platform backlog recommendations - any initiatives, epics, or priorities we should adjust before handing off to BMM?"** + +6. **"Are there any business rules, limitations, or requirements that came to mind as we went through this that we should document somewhere?"** + +7. **"Anything about performance, scalability, or deployment we should capture?"** + +**If user identifies gaps:** +- Document the additional items in the appropriate files +- "Great catch! Let me add that to [relevant document]..." +- After adding, return to completeness check + +**When user confirms nothing missing:** + +"Perfect! Your technical foundation is solid and complete." + +**Parallel Workflows Enabled:** + +"With Phase 3 complete, multiple work streams can now proceed:" + +1. **BMM Backlog Creation:** + - BMM agents use platform backlog recommendations + - Create E-Backlog/ structure with detailed epics and stories + - Establish implementation roadmap + +2. **Backend/Platform Development:** + - Infrastructure setup can begin + - API endpoints can be implemented + - Database schema can be created + - External integrations can be configured + +3. **Phase 4: UX Design:** + - Design work proceeds with confidence about technical feasibility + - Technical constraints inform design decisions + - Each completed page will add functional requirements to the PRD + +**What happens next:** +- Platform backlog recommendations guide BMM agents in creating E-Backlog/ +- Development teams can begin platform work based on requirements +- Phase 4 (UX Design) can begin, informed by technical constraints + +**Ask:** "Would you like to proceed to Phase 4 (UX Design) now, hand off to BMM for backlog creation, or need time for backend development planning?" + +--- + +## Tips for Great Sessions + +### For Freyja the PM: + +**Validate Early, Often:** +- Don't let risky features proceed without PoC validation +- "Let's prove this works before investing in design" + +**Positive Language:** +- Frame discoveries as valuable, not failures +- "Great that we learned this now, not after design is complete" + +**Stay Connected to Strategy:** +- Reference Feature Impact Analysis scores when prioritizing PoCs +- High-impact features deserve thorough validation + +**Enable Parallel Work:** +- Think about what backend teams can start building immediately +- Experimental endpoints should focus on clear, achievable tasks + +**Document for Design:** +- Technical Constraints doc is crucial for Phase 4 success +- Be specific about what design needs to accommodate + +--- + +## Template Files + +Use these templates to structure outputs: + +- `templates/platform-architecture.template.md` +- `templates/technical-constraints.template.md` +- `templates/experimental-endpoints.template.md` + +--- + +*Phase 3 workflow for Whiteport Design Studio (WDS) methodology* + diff --git a/src/modules/wds/workflows/3-prd-platform/templates/experimental-endpoints.template.md b/src/modules/wds/workflows/3-prd-platform/templates/experimental-endpoints.template.md new file mode 100644 index 00000000..6e8fbd06 --- /dev/null +++ b/src/modules/wds/workflows/3-prd-platform/templates/experimental-endpoints.template.md @@ -0,0 +1,197 @@ +# Experimental Endpoints + +**Project:** {{project_name}} +**Date:** {{date}} +**Phase:** 3 - PRD Platform (Technical Foundation) + +--- + +## Purpose + +These are early API specifications for endpoints we know we'll need. Setting them up now enables: +- Early backend development (parallel with UX design) +- Validation that our data model works +- Fail-fast discovery of integration issues + +--- + +## Endpoint Status Key + +- **📝 Stub:** Specification only, not implemented +- **🚧 In Progress:** Currently being built +- **✅ Working:** Implemented and tested +- **❌ Blocked:** Waiting on dependency or decision + +--- + +## Authentication Endpoints + +{{#each auth_endpoints}} +### {{this.method}} {{this.path}} + +**Status:** {{this.status}} +**Purpose:** {{this.purpose}} + +**Request:** +```json +{{this.request_example}} +``` + +**Response:** +```json +{{this.response_example}} +``` + +**Notes:** {{this.notes}} + +--- +{{/each}} + +## Core CRUD Operations + +{{#each crud_endpoints}} +### {{this.method}} {{this.path}} + +**Status:** {{this.status}} +**Purpose:** {{this.purpose}} +**Entity:** {{this.entity}} + +**Request:** +```json +{{this.request_example}} +``` + +**Response:** +```json +{{this.response_example}} +``` + +**Dependencies:** {{this.dependencies}} +**Notes:** {{this.notes}} + +--- +{{/each}} + +## External Integration Endpoints + +{{#each integration_endpoints}} +### {{this.method}} {{this.path}} + +**Status:** {{this.status}} +**Purpose:** {{this.purpose}} +**External Service:** {{this.external_service}} + +**Request:** +```json +{{this.request_example}} +``` + +**Response:** +```json +{{this.response_example}} +``` + +**Validates:** +- {{#each this.validates}} +- {{this}} +{{/each}} + +**Cost per Call:** {{this.cost_per_call}} +**Rate Limits:** {{this.rate_limits}} +**Notes:** {{this.notes}} + +--- +{{/each}} + +## Business Logic Endpoints + +{{#each logic_endpoints}} +### {{this.method}} {{this.path}} + +**Status:** {{this.status}} +**Purpose:** {{this.purpose}} + +**Request:** +```json +{{this.request_example}} +``` + +**Response:** +```json +{{this.response_example}} +``` + +**Business Rules:** +{{#each this.business_rules}} +- {{this}} +{{/each}} + +**Notes:** {{this.notes}} + +--- +{{/each}} + +## Error Handling + +### Standard Error Response + +```json +{ + "error": { + "code": "ERROR_CODE", + "message": "Human-readable message", + "details": {}, + "timestamp": "ISO8601 timestamp" + } +} +``` + +### Common Error Codes + +{{#each error_codes}} +- **{{this.code}}** ({{this.http_status}}): {{this.description}} +{{/each}} + +--- + +## API Conventions + +### Base URL +``` +{{api_base_url}} +``` + +### Authentication +{{api_authentication_method}} + +### Request Headers +``` +{{api_request_headers}} +``` + +### Response Format +{{api_response_format}} + +--- + +## Development Tasks + +These endpoints are also tracked in `E-PRD-Finalization/` as handoff tasks: + +{{#each development_tasks}} +- [ ] **{{this.endpoint}}** - {{this.description}} (Priority: {{this.priority}}) +{{/each}} + +--- + +## Next Steps + +1. **Backend Team:** Implement stubs for all endpoints +2. **Frontend/Design:** Reference these specs when designing UI +3. **Integration Testing:** Validate external service connections +4. **Update Status:** Mark endpoints as ✅ Working when complete + +--- + +*Phase 3 artifact for {{project_name}}* + diff --git a/src/modules/wds/workflows/3-prd-platform/templates/platform-architecture.template.md b/src/modules/wds/workflows/3-prd-platform/templates/platform-architecture.template.md new file mode 100644 index 00000000..77d6c74e --- /dev/null +++ b/src/modules/wds/workflows/3-prd-platform/templates/platform-architecture.template.md @@ -0,0 +1,145 @@ +# Platform Architecture + +**Project:** {{project_name}} +**Date:** {{date}} +**Phase:** 3 - PRD Platform (Technical Foundation) + +--- + +## Technology Stack + +### Backend +- **Framework/Language:** {{backend_framework}} +- **Runtime:** {{backend_runtime}} +- **Rationale:** {{backend_rationale}} + +### Frontend +- **Framework:** {{frontend_framework}} +- **UI Library:** {{ui_library}} +- **Rationale:** {{frontend_rationale}} + +### Database +- **Primary Database:** {{primary_database}} +- **Type:** {{database_type}} +- **Rationale:** {{database_rationale}} + +{{#if secondary_database}} +- **Secondary Database:** {{secondary_database}} +- **Purpose:** {{secondary_purpose}} +{{/if}} + +--- + +## Architecture Style + +**Approach:** {{architecture_style}} + +{{#if architecture_style == "Monolith"}} +- Single codebase deployment +- Simplified development and deployment +- {{monolith_rationale}} +{{/if}} + +{{#if architecture_style == "Microservices"}} +- Service boundaries: {{service_boundaries}} +- Communication: {{service_communication}} +- {{microservices_rationale}} +{{/if}} + +{{#if architecture_style == "Serverless"}} +- Functions: {{serverless_functions}} +- Triggers: {{serverless_triggers}} +- {{serverless_rationale}} +{{/if}} + +--- + +## Infrastructure & Hosting + +### Platform +- **Cloud Provider:** {{cloud_provider}} +- **Hosting Type:** {{hosting_type}} +- **Rationale:** {{infrastructure_rationale}} + +### Services +{{#each infrastructure_services}} +- **{{this.name}}:** {{this.description}} +{{/each}} + +--- + +## Data Model + +### Core Entities + +{{#each core_entities}} +#### {{this.name}} + +**Purpose:** {{this.purpose}} + +**Key Fields:** +{{#each this.fields}} +- `{{this.name}}` ({{this.type}}) - {{this.description}} +{{/each}} + +**Relationships:** +{{#each this.relationships}} +- {{this.type}} {{this.target}} - {{this.description}} +{{/each}} + +{{/each}} + +### Entity Relationship Diagram + +``` +{{entity_diagram}} +``` + +--- + +## Performance Requirements + +- **Response Time:** {{response_time_target}} +- **Concurrent Users:** {{concurrent_users_target}} +- **Availability:** {{availability_target}} +- **Data Volume:** {{data_volume_estimate}} + +--- + +## Scalability Strategy + +{{scalability_strategy}} + +--- + +## Development Environment + +- **Version Control:** {{version_control}} +- **CI/CD:** {{cicd_platform}} +- **Testing Strategy:** {{testing_strategy}} +- **Local Development:** {{local_dev_setup}} + +--- + +## Technical Constraints + +{{#each technical_constraints}} +- **{{this.area}}:** {{this.constraint}} +{{/each}} + +--- + +## Cost Estimates + +### Monthly Operating Costs (Estimated) + +{{#each cost_estimates}} +- **{{this.service}}:** {{this.cost}} {{this.currency}} +{{/each}} + +**Total Estimated:** {{total_monthly_cost}} {{currency}}/month + +--- + +*Phase 3 artifact for {{project_name}}* + diff --git a/src/modules/wds/workflows/3-prd-platform/templates/technical-constraints.template.md b/src/modules/wds/workflows/3-prd-platform/templates/technical-constraints.template.md new file mode 100644 index 00000000..c25ea1e3 --- /dev/null +++ b/src/modules/wds/workflows/3-prd-platform/templates/technical-constraints.template.md @@ -0,0 +1,173 @@ +# Technical Constraints Document + +**Project:** {{project_name}} +**Date:** {{date}} +**Audience:** UX Design Team +**Phase:** 3 → 4 Handoff + +--- + +## Purpose + +This document summarizes technical decisions and constraints that inform UX design work. It answers: "What do designers need to know about what's technically possible, expensive, or constrained?" + +--- + +## ✅ What's Possible + +### Validated Features + +{{#each validated_features}} +#### {{this.feature_name}} + +**Status:** {{this.status}} +**What Works:** {{this.what_works}} +**Design Implications:** {{this.design_implications}} + +{{/each}} + +### Platform Capabilities + +{{#each platform_capabilities}} +- **{{this.capability}}:** {{this.description}} +{{/each}} + +--- + +## ⚠️ What Has Limitations + +### Technical Limitations + +{{#each limitations}} +#### {{this.area}} + +**Constraint:** {{this.constraint}} +**Why It Matters:** {{this.impact}} +**Design Guidance:** {{this.design_guidance}} + +{{/each}} + +### External API Constraints + +{{#each api_constraints}} +- **{{this.service}}:** {{this.constraint}} - {{this.design_impact}} +{{/each}} + +--- + +## ⏱️ What Affects Timing + +### Performance Characteristics + +{{#each performance_characteristics}} +#### {{this.operation}} + +- **Expected Time:** {{this.time}} +- **Design Need:** {{this.design_need}} +- **UX Pattern:** {{this.ux_pattern}} + +{{/each}} + +### Connection Requirements + +{{#each connection_requirements}} +- **{{this.feature}}:** {{this.requirement}} - {{this.design_impact}} +{{/each}} + +--- + +## 💰 What's Expensive + +### Cost-Sensitive Features + +{{#each expensive_features}} +#### {{this.feature}} + +**Cost Driver:** {{this.cost_driver}} +**Per-Use Cost:** {{this.per_use_cost}} +**Design Guidance:** {{this.design_guidance}} + +{{/each}} + +--- + +## 🌐 Platform Compatibility + +### Browser Support +{{browser_support}} + +### Device Support +{{device_support}} + +### Accessibility +{{accessibility_considerations}} + +--- + +## 🔒 Security Constraints + +### Authentication +{{authentication_constraints}} + +### Data Handling +{{data_handling_constraints}} + +### Compliance +{{compliance_constraints}} + +--- + +## 📱 Offline Behavior + +{{#if offline_support}} +### What Works Offline +{{offline_capabilities}} + +### What Requires Connection +{{online_requirements}} + +### Sync Strategy +{{sync_strategy}} +{{else}} +**Offline Mode:** Not supported - All features require active connection +{{/if}} + +--- + +## 🎯 Design Recommendations + +Based on technical validation: + +{{#each design_recommendations}} +### {{this.category}} + +{{this.recommendation}} + +**Rationale:** {{this.rationale}} + +{{/each}} + +--- + +## ❓ Questions for Design Team + +{{#if open_questions}} +{{#each open_questions}} +- {{this}} +{{/each}} +{{else}} +No open questions at this time. +{{/if}} + +--- + +## Next Steps + +- **For UX Design (Phase 4):** Use this document to inform design decisions +- **For Development:** Technical specs are in other Phase 3 documents +- **Updates:** This document will be updated if new constraints emerge during design + +--- + +*Phase 3 → 4 Handoff Document for {{project_name}}* + diff --git a/src/modules/wds/workflows/3-prd-platform/workflow.yaml b/src/modules/wds/workflows/3-prd-platform/workflow.yaml new file mode 100644 index 00000000..a2a04430 --- /dev/null +++ b/src/modules/wds/workflows/3-prd-platform/workflow.yaml @@ -0,0 +1,34 @@ +name: "Phase 3: PRD Platform (Technical Foundation)" +agent: "Freyja the PM" +description: "Establish technical foundation, validate risky features, and set up experimental endpoints" +version: "1.0.0" + +paths: + - instructions.md + +templates: + - templates/platform-architecture.template.md + - templates/technical-constraints.template.md + - templates/experimental-endpoints.template.md + +outputs: + folder: "C-Requirements" + artifacts: + - "00-Platform-Architecture.md" + - "01-Integration-Map.md" + - "02-Technical-Proofs-Of-Concept.md" + - "03-Security-Framework.md" + - "04-Experimental-Endpoints.md" + - "05-Technical-Constraints.md" + - "06-PRD.md" + +inputs_required: + - "A-Product-Brief" # Phase 1 output + - "B-Trigger-Map/03-Feature-Impact-Analysis.md" # Phase 2 output + +optional_inputs: + - "Development team availability for PoC work" + - "Existing technical constraints" + +estimated_duration: "2-4 hours (plus PoC development time)" + diff --git a/src/modules/wds/workflows/paths/design-system-only.yaml b/src/modules/wds/workflows/paths/design-system-only.yaml new file mode 100644 index 00000000..1b0d6dc8 --- /dev/null +++ b/src/modules/wds/workflows/paths/design-system-only.yaml @@ -0,0 +1,62 @@ +# WDS Design System Only Path +# Context + Phases 4, 5 - for building component libraries + +path_name: "Design System Only" +path_id: "design-system-only" +description: "Build a component library without full product design" + +phases: + - phase: 1 + name: "Project Brief" + artifact: "Project Brief" + folder_letter: "A" + folder_number: "01" + folder_name: "Product-Brief" + required: true + brief_options: + - level: "simplified" + workflows: + - id: "simplified-brief" + required: true + agent: "saga-analyst" + command: "simplified-brief" + output: "Simplified brief: scope, design principles, target applications" + note: "Establish the design system's purpose and constraints" + - level: "complete" + workflows: + - id: "product-exploration" + required: true + agent: "saga-analyst" + command: "product-exploration" + output: "Complete Project Brief" + + - phase: 4 + name: "UX Design" + artifact: "Component Designs" + folder_letter: "C" + folder_number: "02" + folder_name: "Scenarios" + required: true + workflows: + - id: "ux-design" + required: true + agent: "baldr-ux" + command: "ux-design" + output: "Component specifications and examples" + note: "Design components through example usage scenarios" + + - phase: 5 + name: "Design System" + artifact: "Component Library" + folder_letter: "D" + folder_number: "02" + folder_name: "Design-System" + required: true + workflows: + - id: "design-system" + required: true + agent: "baldr-ux" + command: "design-system" + output: "Complete component documentation, HTML showcase" + note: "The primary deliverable for this path" + diff --git a/src/modules/wds/workflows/paths/digital-strategy.yaml b/src/modules/wds/workflows/paths/digital-strategy.yaml new file mode 100644 index 00000000..eb570dc2 --- /dev/null +++ b/src/modules/wds/workflows/paths/digital-strategy.yaml @@ -0,0 +1,39 @@ +# WDS Digital Strategy Path +# Phases 1, 2 only - discovery and research without design execution + +path_name: "Digital Strategy" +path_id: "digital-strategy" +description: "Discovery and strategic planning without design execution" + +phases: + - phase: 1 + name: "Project Brief" + artifact: "Project Brief" + folder_letter: "A" + folder_number: "01" + folder_name: "Product-Brief" + required: true + brief_level: "complete" + workflows: + - id: "product-exploration" + required: true + agent: "saga-analyst" + command: "product-exploration" + output: "Complete Project Brief with vision, positioning, success criteria" + note: "Deep strategic exploration" + + - phase: 2 + name: "Trigger Mapping" + artifact: "Trigger Map" + folder_letter: "B" + folder_number: "02" + folder_name: "Trigger-Map" + required: true + workflows: + - id: "trigger-mapping" + required: true + agent: "saga-analyst" + command: "trigger-mapping" + output: "Trigger Map with personas, business goals, Feature Impact Analysis" + note: "Strategic user research and prioritization" + diff --git a/src/modules/wds/workflows/paths/feature-enhancement.yaml b/src/modules/wds/workflows/paths/feature-enhancement.yaml new file mode 100644 index 00000000..8301113f --- /dev/null +++ b/src/modules/wds/workflows/paths/feature-enhancement.yaml @@ -0,0 +1,93 @@ +# WDS Feature Enhancement Path +# Context + Phases 2, 4, 6 - for adding features to existing products + +path_name: "Feature Enhancement" +path_id: "feature-enhancement" +description: "Design workflow for adding features to existing products" + +phases: + - phase: 1 + name: "Project Brief" + artifact: "Project Brief" + folder_letter: "A" + folder_number: "01" + folder_name: "Product-Brief" + required: true + brief_options: + - level: "simplified" + workflows: + - id: "simplified-brief" + required: true + agent: "saga-analyst" + command: "simplified-brief" + output: "Simplified brief: feature scope, challenge, opportunity, goals" + note: "5-10 minutes - establish context for the feature" + - level: "complete" + workflows: + - id: "product-exploration" + required: true + agent: "saga-analyst" + command: "product-exploration" + output: "Complete Project Brief" + note: "When feature is strategically significant" + + - phase: 2 + name: "Trigger Mapping" + artifact: "Trigger Map" + folder_letter: "B" + folder_number: "02" + folder_name: "Trigger-Map" + required: true + workflows: + - id: "trigger-mapping" + required: true + agent: "saga-analyst" + command: "trigger-mapping" + output: "Feature-focused Trigger Map with user goals and priorities" + note: "Focus on the specific user needs this feature addresses" + + - phase: 4 + name: "UX Design" + artifact: "Scenarios" + folder_letter: "C" + folder_number: "02" + folder_name: "Scenarios" + required: true + workflows: + - id: "ux-design" + required: true + agent: "baldr-ux" + command: "ux-design" + output: "Feature specifications, prototypes, functional requirements" + note: "Design the new feature flows" + + - phase: 5 + name: "Design System" + artifact: "Component Library" + folder_letter: "D" + folder_number: "03" + folder_name: "Design-System" + conditional: "include_design_system" + workflows: + - id: "design-system" + conditional: "include_design_system" + agent: "baldr-ux" + command: "design-system" + output: "New components for the feature" + note: "Only if feature introduces new component patterns" + + - phase: 6 + name: "PRD Finalization" + artifact: "Feature PRD" + folder_letter: "E" + folder_number: "04" + folder_name: "PRD-Finalization" + required: true + workflows: + - id: "prd-finalization" + required: true + agent: "freyja-pm" + command: "prd-finalization" + output: "Feature requirements, integration notes, handoff" + note: "Compile feature requirements for development" + diff --git a/src/modules/wds/workflows/paths/full-product.yaml b/src/modules/wds/workflows/paths/full-product.yaml new file mode 100644 index 00000000..834008a0 --- /dev/null +++ b/src/modules/wds/workflows/paths/full-product.yaml @@ -0,0 +1,96 @@ +# WDS Full Product Path +# All 6 phases - complete design journey from vision to handoff + +path_name: "Full Product" +path_id: "full-product" +description: "Complete design methodology for new products, platforms, and complex applications" + +phases: + - phase: 1 + name: "Project Brief" + artifact: "Project Brief" + folder_letter: "A" + folder_number: "01" + folder_name: "Product-Brief" + required: true + brief_level: "complete" + workflows: + - id: "product-exploration" + required: true + agent: "saga-analyst" + command: "product-exploration" + output: "Complete Project Brief with vision, positioning, success criteria" + + - phase: 2 + name: "Trigger Mapping" + artifact: "Trigger Map" + folder_letter: "B" + folder_number: "02" + folder_name: "Trigger-Map" + required: true + workflows: + - id: "trigger-mapping" + required: true + agent: "saga-analyst" + command: "trigger-mapping" + output: "Trigger Map with personas, goals, Feature Impact Analysis" + + - phase: 3 + name: "PRD Platform" + artifact: "Technical Foundation" + folder_letter: "C" + folder_number: "03" + folder_name: "Platform-Requirements" + required: true + workflows: + - id: "prd-platform" + required: true + agent: "freyja-pm" + command: "prd-platform" + output: "Platform architecture, data model, proofs of concept" + + - phase: 4 + name: "UX Design" + artifact: "Scenarios" + folder_letter: "C" + folder_number: "03" + folder_name: "Scenarios" + required: true + workflows: + - id: "ux-design" + required: true + agent: "baldr-ux" + command: "ux-design" + output: "Page specifications, prototypes, functional requirements" + note: "Run iteratively for each scenario. Step 4E updates PRD." + + - phase: 5 + name: "Design System" + artifact: "Component Library" + folder_letter: "D" + folder_number: "04" + folder_name: "Design-System" + conditional: "include_design_system" + workflows: + - id: "design-system" + conditional: "include_design_system" + agent: "baldr-ux" + command: "design-system" + output: "Component documentation, HTML showcase" + note: "Runs in parallel with Phase 4" + + - phase: 6 + name: "PRD Finalization" + artifact: "Complete PRD" + folder_letter: "E" + folder_number: "05" + folder_name: "PRD-Finalization" + required: true + workflows: + - id: "prd-finalization" + required: true + agent: "freyja-pm" + command: "prd-finalization" + output: "Complete PRD, development roadmap, handoff package" + note: "Can run multiple times as design progresses" + diff --git a/src/modules/wds/workflows/paths/landing-page.yaml b/src/modules/wds/workflows/paths/landing-page.yaml new file mode 100644 index 00000000..192cfab0 --- /dev/null +++ b/src/modules/wds/workflows/paths/landing-page.yaml @@ -0,0 +1,54 @@ +# WDS Landing Page Path +# Context + Phases 4, optional 5 - streamlined for simple projects + +path_name: "Landing Page" +path_id: "landing-page" +description: "Streamlined design for marketing sites, single-page apps, and simple projects" + +phases: + - phase: 1 + name: "Project Brief" + artifact: "Project Brief" + folder_letter: "A" + folder_number: "01" + folder_name: "Product-Brief" + required: true + brief_level: "simplified" + workflows: + - id: "simplified-brief" + required: true + agent: "saga-analyst" + command: "simplified-brief" + output: "Simplified brief: scope, challenge, opportunity, goals" + note: "5-10 minutes - perfect for simple landing pages" + + - phase: 4 + name: "UX Design" + artifact: "Scenarios" + folder_letter: "C" + folder_number: "02" + folder_name: "Scenarios" + required: true + workflows: + - id: "ux-design" + required: true + agent: "baldr-ux" + command: "ux-design" + output: "Page specifications, prototypes" + note: "Usually just 1-3 pages for landing page projects" + + - phase: 5 + name: "Design System" + artifact: "Component Library" + folder_letter: "D" + folder_number: "03" + folder_name: "Design-System" + conditional: "include_design_system" + workflows: + - id: "design-system" + conditional: "include_design_system" + agent: "baldr-ux" + command: "design-system" + output: "Component documentation" + note: "Optional - skip for truly simple one-off pages" + diff --git a/src/modules/wds/workflows/paths/quick-prototype.yaml b/src/modules/wds/workflows/paths/quick-prototype.yaml new file mode 100644 index 00000000..998412fe --- /dev/null +++ b/src/modules/wds/workflows/paths/quick-prototype.yaml @@ -0,0 +1,39 @@ +# WDS Quick Prototype Path +# Context + Phase 4 - rapid prototyping with context + +path_name: "Quick Prototype" +path_id: "quick-prototype" +description: "Rapid prototyping with essential context" + +phases: + - phase: 1 + name: "Project Brief" + artifact: "Project Brief" + folder_letter: "A" + folder_number: "01" + folder_name: "Product-Brief" + required: true + brief_level: "simplified" + workflows: + - id: "simplified-brief" + required: true + agent: "saga-analyst" + command: "simplified-brief" + output: "Simplified brief: scope, challenge, opportunity, goals" + note: "5-10 minutes to establish context for agents" + + - phase: 4 + name: "UX Design" + artifact: "Prototype" + folder_letter: "C" + folder_number: "02" + folder_name: "Scenarios" + required: true + workflows: + - id: "ux-design" + required: true + agent: "baldr-ux" + command: "ux-design" + output: "Quick specifications and HTML prototypes" + note: "Focus on getting something visible fast" + diff --git a/src/modules/wds/workflows/wds-workflow-status-template.yaml b/src/modules/wds/workflows/wds-workflow-status-template.yaml new file mode 100644 index 00000000..26e5cd7b --- /dev/null +++ b/src/modules/wds/workflows/wds-workflow-status-template.yaml @@ -0,0 +1,87 @@ +# WDS Workflow Status Template +# Tracks progress through WDS design methodology + +# STATUS DEFINITIONS: +# ================== +# Initial Status (before completion): +# - required: Must be completed to progress +# - optional: Can be completed but not required +# - conditional: Required only if certain conditions met +# - skipped: Phase not included for this project type +# +# Completion Status: +# - {file-path}: File created/found (e.g., "docs/A-Product-Brief/product-brief.md") +# - complete: Phase finished +# - in-progress: Currently working on this phase + +# Project information +generated: "{{generated}}" +project: "{{project_name}}" +project_type: "{{project_type}}" +workflow_path: "{{workflow_path_file}}" + +# Configuration +config: + folder_prefix: "{{folder_prefix}}" # letters or numbers + folder_case: "{{folder_case}}" # title or lowercase + brief_level: "{{brief_level}}" # simplified or complete + include_design_system: {{include_design_system}} + component_library: "{{component_library}}" + +# Folder mapping (generated based on config) +folders: + product_brief: "{{folder_product_brief}}" + trigger_map: "{{folder_trigger_map}}" + platform_requirements: "{{folder_platform_requirements}}" + scenarios: "{{folder_scenarios}}" + design_system: "{{folder_design_system}}" + prd_finalization: "{{folder_prd_finalization}}" + +# Workflow status tracking +workflow_status: "{{workflow_items}}" + +# Example structure when populated: +# workflow_status: +# phase_1_project_brief: +# status: required +# agent: saga-analyst +# folder: A-Product-Brief/ +# brief_level: complete # or simplified +# artifacts: +# - project-brief.md +# phase_2_trigger_mapping: +# status: required +# agent: saga-analyst +# folder: B-Trigger-Map/ +# artifacts: +# - trigger-map.md +# - personas/ +# - feature-impact-analysis.md +# phase_3_prd_platform: +# status: required +# agent: freyja-pm +# folder: C-Platform-Requirements/ +# artifacts: +# - platform-architecture.md +# - data-model.md +# - proofs-of-concept/ +# phase_4_ux_design: +# status: required +# agent: baldr-ux +# folder: C-Scenarios/ +# artifacts: [] # Grows as scenarios are created +# phase_5_design_system: +# status: conditional # or skipped +# agent: baldr-ux +# folder: D-Design-System/ +# artifacts: +# - component-showcase.html +# - design-tokens.md +# phase_6_prd_finalization: +# status: required +# agent: freyja-pm +# folder: E-PRD-Finalization/ +# artifacts: +# - complete-prd.md +# - development-roadmap.md + diff --git a/src/modules/wds/workflows/workflow-init/instructions.md b/src/modules/wds/workflows/workflow-init/instructions.md new file mode 100644 index 00000000..c80df759 --- /dev/null +++ b/src/modules/wds/workflows/workflow-init/instructions.md @@ -0,0 +1,306 @@ +# WDS Workflow Init - Project Setup Instructions + +The workflow execution engine is governed by: {project-root}/{bmad_folder}/core/tasks/workflow.xml +You MUST have already loaded and processed: wds-workflow-init/workflow.yaml +Communicate in {communication_language} with {user_name} + + + + +Welcome to Whiteport Design Studio, {user_name}! 🎨 + +I'm here to help you set up your design project. WDS provides a structured approach to design - from strategic vision through detailed specifications. + +Let's figure out which phases you need. + +Tell me about your project in a few sentences. What are you designing? +Store user_description +Analyze description for project indicators: +- "landing page", "single page", "simple" → landing-page path +- "product", "platform", "app", "system", "full" → full-product path +- "strategy", "research", "discovery", "planning" → digital-strategy path +- "design system", "components", "library" → design-system path +- "feature", "enhancement", "addition" → feature-enhancement path +- "quick", "prototype", "poc", "test" → quick-prototype path + +user_description + + + +Based on what you shared, this sounds like a **{{detected_project_type}}** project. + +Does that sound right? + +1. Yes, that's correct +2. No, let me explain more +3. Show me all the options + +Choice [1/2/3]: + + + Tell me more - what's the scope and complexity? + Re-analyze and update detected_project_type + Return to step 2 + + + + WDS supports these project types: + +**1. Full Product** 🚀 +All 6 phases - complete design journey from vision to handoff +Best for: New products, platforms, complex applications + +**2. Landing Page** 📄 +Phases 1 (Brief), 4 (Design), optional 5 (Design System) +Best for: Marketing sites, single-page apps, simple projects + +**3. Feature Enhancement** ✨ +Phases 2 (Trigger Map), 4 (Design), 6 (PRD Finalization) +Best for: Adding features to existing products + +**4. Digital Strategy** 🧭 +Phases 1 (Brief), 2 (Trigger Map) only +Best for: Discovery, research, product strategy + +**5. Design System Only** 🎨 +Phases 4 (Design), 5 (Design System) +Best for: Building component libraries + +**6. Quick Prototype** ⚡ +Phase 4 only +Best for: Rapid prototyping, proof of concepts + + Which fits your project? + +1. Full Product +2. Landing Page +3. Feature Enhancement +4. Digital Strategy +5. Design System Only +6. Quick Prototype + +Choice [1-6]: + Map choice to project_type + + +project_type + + + +Every WDS project starts with a Project Brief - so agents understand what you're building and why. + + + For **{{project_type}}** projects, a **Complete Project Brief** is included. + +This covers: +- Vision & positioning +- Target users (ICP) +- Success criteria +- Competitive landscape +- Strategic constraints + Set brief_level = "complete" + + + + For **{{project_type}}** projects, a **Simplified Project Brief** keeps things fast. + +This covers: +- Scope & challenge +- Opportunity +- Design goals + Set brief_level = "simplified" + + + + Project Brief depth: + +1. **Simplified** (5-10 min) + - Scope & challenge + - Opportunity + - Design goals + Best for: Quick features, time-pressured work + +2. **Complete** (30-60 min) + - Vision & positioning + - Target users (ICP) + - Success criteria + - Competitive landscape + Best for: When you want strategic clarity + +Choice [1/2]: + + + Set brief_level = "simplified" + + + + Set brief_level = "complete" + + + +brief_level + + + +WDS creates folders in your project's `docs/` directory. Let's configure how they're named. + +Folder prefix style: + +1. **Letters** (A-Product-Brief, B-Trigger-Map, C-...) + - Distinctive WDS branding + - Easy visual grouping + +2. **Numbers** (01-Product-Brief, 02-Trigger-Map, 03-...) + - Traditional sequential numbering + - Familiar format + +Choice [1/2]: +Set folder_prefix based on choice (letters/numbers) +folder_prefix + +Folder capitalization: + +1. **Title-Case** (A-Product-Brief, B-Trigger-Map) + - Easier to read for non-technical stakeholders + +2. **lowercase** (a-product-brief, b-trigger-map) + - Developer-friendly convention + +Choice [1/2]: +Set folder_case based on choice (title/lowercase) +folder_case + + + + + The **Design System** phase is optional but valuable for building reusable components. + + Include Design System phase? + +1. **Yes** - Build a component library alongside design work +2. **No** - Keep it simple, focus on page designs only +3. **Help me decide** + +Choice [1/2/3]: + + + Include Design System if: +- You have multiple pages with shared patterns +- You want consistent components across the product +- You're building for a team that needs a component library +- You plan to hand off to developers who need component docs + +Skip Design System if: +- It's a simple, one-off project +- You're using an existing design system (Material, Chakra, etc.) +- You need to move fast without component documentation + Based on this, include Design System? (y/n) + Set include_design_system based on answer + + + + Set include_design_system = true + + + + Set include_design_system = false + + + + + Set include_design_system = true + + +include_design_system + + + + + For the Design System, you can build custom components or use an existing library. + + Component library approach: + +1. **Custom** - Build your own from scratch +2. **Shadcn/ui** - Copy-paste React components (recommended for flexibility) +3. **Chakra UI** - Comprehensive React library +4. **Radix UI** - Headless accessible primitives +5. **Material UI** - Material Design components +6. **Tailwind CSS** - Utility-first styling (combine with headless) +7. **Other** - I'll specify later +8. **Undecided** - I'll choose during the project + +Choice [1-8]: + Set component_library based on choice + component_library + + + + +Load path file: {path_files}/{{project_type}}.yaml +Build workflow_items from path file +Apply brief_level setting (simplified or complete) +Apply include_design_system setting +Generate folder names based on folder_prefix and folder_case +Set generated date + +generated +workflow_path_file +workflow_items +folder_names +brief_level + + + +Your WDS project setup: + +**Project:** {{project_name}} +**Type:** {{project_type}} +**Project Brief:** {{#if brief_level == 'complete'}}Complete{{else}}Simplified{{/if}} +**Design System:** {{include_design_system}} +{{#if component_library}}**Component Library:** {{component_library}}{{/if}} + +**Phases enabled:** +{{#each enabled_phases}} +- Phase {{this.number}}: {{this.name}} → `{{this.folder}}/` +{{/each}} + +**Folder naming:** {{folder_prefix}} + {{folder_case}} +Example: `{{example_folder_name}}` + + +Create WDS workflow tracking file? (y/n) + + + Generate YAML from template with all variables + Save to {output_folder}/wds-workflow-status.yaml + Identify first workflow and agent + +✅ **Created:** {output_folder}/wds-workflow-status.yaml + +**Your WDS journey begins!** + +**First Phase:** {{first_phase_name}} +**Agent:** {{first_agent}} +**Folder:** {{first_folder}} + +To start, activate **{{first_agent}}** and begin {{first_phase_name}}. + +To check progress anytime: `/bmad:wds:workflows:workflow-status` + +Happy designing! 🎨 + + + + No problem! Run this workflow again when you're ready. + +You can also manually create your project structure: +{{#each enabled_phases}} +- Create `docs/{{this.folder}}/` for {{this.name}} +{{/each}} + +Happy designing! 🎨 + + + + + diff --git a/src/modules/wds/workflows/workflow-init/workflow.yaml b/src/modules/wds/workflows/workflow-init/workflow.yaml new file mode 100644 index 00000000..8134233e --- /dev/null +++ b/src/modules/wds/workflows/workflow-init/workflow.yaml @@ -0,0 +1,32 @@ +# WDS Workflow Init - Project Setup +name: wds-workflow-init +description: "Initialize a WDS design project by selecting phases based on project needs" +author: "Whiteport Design Studio" + +# Critical variables from config +config_source: "{project-root}/{bmad_folder}/wds/config.yaml" +output_folder: "{config_source}:output_folder" +user_name: "{config_source}:user_name" +project_name: "{config_source}:project_name" +communication_language: "{config_source}:communication_language" +document_output_language: "{config_source}:document_output_language" +date: system-generated + +# Folder naming configuration (set during init) +folder_prefix: "letters" # letters or numbers +folder_case: "title" # title or lowercase + +# Workflow components +installed_path: "{project-root}/{bmad_folder}/wds/workflows/workflow-init" +instructions: "{installed_path}/instructions.md" +template: "{project-root}/{bmad_folder}/wds/workflows/wds-workflow-status-template.yaml" + +# Path data files for different project types +path_files: "{project-root}/{bmad_folder}/wds/workflows/paths/" + +# Output configuration +default_output_file: "{output_folder}/wds-workflow-status.yaml" + +standalone: true +web_bundle: false + diff --git a/src/modules/wds/workflows/workflow-status/instructions.md b/src/modules/wds/workflows/workflow-status/instructions.md new file mode 100644 index 00000000..235924a1 --- /dev/null +++ b/src/modules/wds/workflows/workflow-status/instructions.md @@ -0,0 +1,142 @@ +# WDS Workflow Status - Progress Check Instructions + +You MUST have already loaded and processed: wds-workflow-status/workflow.yaml +Communicate in {communication_language} with {user_name} + + + + +Look for {output_folder}/wds-workflow-status.yaml + + + No WDS workflow tracking found for this project. + +To get started, run the workflow-init: +`/bmad:wds:workflows:workflow-init` + +Or activate any WDS agent (Saga, Freyja, or Baldr) and describe your project. + Exit workflow + + +Load and parse wds-workflow-status.yaml + + + +For each phase in workflow_status: +- Check if folder exists in docs/ +- Check if expected artifacts exist +- Update status (complete/in-progress/pending) + + +Identify: +- completed_phases: Phases with all artifacts +- current_phase: First incomplete required phase +- next_agent: Agent for current phase +- blocked_phases: Phases waiting on dependencies + + + + +**WDS Project Status** 🎨 + +**Project:** {{project_name}} +**Type:** {{project_type}} +**Design System:** {{include_design_system}} + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +{{#each phases}} +{{#if this.status == 'complete'}}✅{{/if}} +{{#if this.status == 'in-progress'}}🔄{{/if}} +{{#if this.status == 'pending'}}⏳{{/if}} +{{#if this.status == 'skipped'}}⏭️{{/if}} + **Phase {{this.number}}: {{this.name}}** + Agent: {{this.agent}} + Folder: `{{this.folder}}` + Status: {{this.status}} +{{#if this.artifacts}} + Artifacts: {{this.artifact_count}} created +{{/if}} + +{{/each}} + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +**Progress:** {{completed_count}}/{{total_count}} phases complete + +{{#if current_phase}} +**Current Focus:** Phase {{current_phase.number}} - {{current_phase.name}} +**Agent:** {{current_phase.agent}} +**Next Step:** {{current_phase.next_step}} +{{else}} +🎉 **All phases complete!** Your design work is ready for development handoff. +{{/if}} + + + + + + What would you like to do? + +1. **Continue** {{current_phase.name}} with {{current_phase.agent}} +2. **Jump to** a different phase +3. **View** phase details +4. **Exit** - I'll come back later + +Choice [1/2/3/4]: + + + To continue with **{{current_phase.name}}**: + +1. Activate **{{current_phase.agent}}** agent +2. Run: `/bmad:wds:workflows:{{current_phase.workflow_id}}` +3. Or just tell {{current_phase.agent}} what you want to work on + +Happy designing! 🎨 + + + + Which phase? +{{#each available_phases}} +{{this.number}}. {{this.name}} ({{this.status}}) +{{/each}} + +Choice: + To work on **Phase {{selected_phase.number}}: {{selected_phase.name}}**: + +Agent: **{{selected_phase.agent}}** +Folder: `{{selected_phase.folder}}` +Command: `/bmad:wds:workflows:{{selected_phase.workflow_id}}` + + + + Which phase to view? +{{#each phases}} +{{this.number}}. {{this.name}} +{{/each}} + +Choice: + **Phase {{selected.number}}: {{selected.name}}** + +**Purpose:** {{selected.description}} +**Agent:** {{selected.agent}} +**Output Folder:** `{{selected.folder}}` +**Status:** {{selected.status}} + +{{#if selected.artifacts}} +**Artifacts created:** +{{#each selected.artifacts}} +- {{this}} +{{/each}} +{{else}} +**Artifacts:** None yet +{{/if}} + +**What this phase produces:** +{{selected.produces}} + + + + + + diff --git a/src/modules/wds/workflows/workflow-status/workflow.yaml b/src/modules/wds/workflows/workflow-status/workflow.yaml new file mode 100644 index 00000000..633316aa --- /dev/null +++ b/src/modules/wds/workflows/workflow-status/workflow.yaml @@ -0,0 +1,22 @@ +# WDS Workflow Status - Progress Checker +name: wds-workflow-status +description: "Check WDS project progress - answers 'what should I do now?' for any agent" +author: "Whiteport Design Studio" + +# Critical variables from config +config_source: "{project-root}/{bmad_folder}/wds/config.yaml" +output_folder: "{config_source}:output_folder" +user_name: "{config_source}:user_name" +communication_language: "{config_source}:communication_language" +date: system-generated + +# Workflow components +installed_path: "{project-root}/{bmad_folder}/wds/workflows/workflow-status" +instructions: "{installed_path}/instructions.md" + +# Status file location +default_output_file: "{output_folder}/wds-workflow-status.yaml" + +standalone: true +web_bundle: false +