ros/BMAD-METHOD
1
0
Fork 0
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git synced 2026-01-30 04:32:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove gamedev and cis docs

Browse Source
This commit is contained in:
Brian Madison
2026-01-17 02:03:48 -06:00
parent 7990ad528c
commit d022e569bd
6 changed files with 288 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
docs/explanation/core-concepts/what-are-modules.md
View File

@@ -47,14 +47,14 @@ Innovation and creativity:
- Creative thinking techniques
- Innovation strategy workflows
- Storytelling and ideation
- [Available Here](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
- [Available Here](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
### BMad Game Dev (BMGD)
Game development specialization:
- Game design workflows
- Narrative development
- Performance testing frameworks
- [Available Here](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
- [Available Here](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
## Module Structure

2
docs/explanation/core-concepts/what-are-workflows.md
View File

@@ -163,7 +163,7 @@ Before building a workflow, answer these questions:
The best way to understand workflows is to study real examples. Look at the official BMad modules:
- **BMB (Module Builder)**: Workflow and agent creation workflows
- **BMB (Module Builder)**: Module, Workflow and Agent creation workflows
- **BMM (Business Method Module)**: Complete software development pipeline from brainstorming through sprint planning
- **BMGD (Game Development Module)**: Game design briefs, narratives, architecture
- **CIS (Creativity, Innovation, Strategy)**: Brainstorming, design thinking, storytelling, innovation strategy

2
docs/explanation/faq/tools-faq.md
View File

@@ -223,7 +223,7 @@ Yes! But the paradigm is fundamentally different from traditional agile teams.
### What is party mode and when should I use it?
Party mode is a unique multi-agent collaboration feature where ALL your installed agents (19+ from BMM, CIS, BMB, custom modules) discuss your challenges together in real-time.
Party mode is a unique multi-agent collaboration feature where ALL your installed modules agents discuss your challenges together in real-time or have some fun with any topic you have in mind.
**How it works:**

341
docs/explanation/philosophy/facilitation-over-generation.md
View File

@@ -1,106 +1,333 @@
---
title: "Facilitation Over Generation"
description: Understanding CIS's facilitation-first approach to creative work
description: Understanding a facilitation-first approach to AI workflows and creative collaboration
---
BMAD workflows take a fundamentally different approach from typical AI Prompts you will find. Instead of generating solutions directly, workflows act as facilitators who guide you through discovery processes, helping you arrive at insights and decisions yourself.
The Creative Intelligence Suite (CIS) takes a fundamentally different approach from typical AI tools. Instead of generating solutions directly, CIS agents act as master facilitators who guide you to discover insights yourself.
This has always been the magic of the BMad method - if you have used it you have felt it intuitively and noticed a difference - and it is through this document I want to really explain what this is. This is fundamental to understand if you are also interested in producing your own workflows or improving upon existing ones in any BMad related module.
## The Problem with Generation
Traditional AI approaches to creative work:
Traditional AI approaches to creative and knowledge work typically follow this pattern:
:::note[Generation Example]
**User:** "Give me marketing ideas"
**User:** "I need a comprehensive UX design for my e-commerce app"
**AI:** "Here are 10 marketing ideas..."
**AI:** [Immediately generates] "Here's a complete UX specification with modern dark theme, card-based product grid, left navigation, and checkout flow..."
:::
This approach:
- Produces generic, predictable outputs
- Removes human ownership of ideas
- Misses context and nuance
- Limits creative exploration
- Produces generic, predictable outputs that may not fit your actual needs
- Removes your ownership and understanding of the solution
- Misses critical context, constraints, and nuance
- Limits creative exploration to the AI's training data patterns
- Creates deliverables you can't explain or iterate on effectively
## The Facilitation Approach
CIS agents use strategic questioning:
Facilitative workflows use strategic questioning and guided discovery:
:::note[Facilitation Example]
**User:** "I need marketing ideas"
:::note[Facilitation Example from UX Design Workflow]
**User:** "I need a comprehensive UX design for my e-commerce app"
**CIS:** "What makes your customers choose you over alternatives? What's the one thing they always mention?"
**Workflow:** "Welcome! I'll act as your UX facilitator to help you discover the right approach. First, let me understand what documents you already have—do you have a product brief, PRD, or any research?"
**User:** "They say our support is exceptional"
**User:** "I have a product brief and some user research"
**CIS:** "Interesting! How might you make that exceptional support visible before they become customers?"
**Workflow:** "Great! Let me load those. [Loads documents] Now, what are the primary user goals for your e-commerce experience? What should users be able to accomplish?"
**User:** "They need to browse products quickly and complete purchases without friction"
**Workflow:** "Interesting! And what makes your e-commerce situation unique? What are the specific challenges or constraints you're working with?"
:::
This approach:
- Draws out insights already within you
- Maintains human ownership of ideas
- Captures context and nuance
- Enables deeper creative exploration
- Draws out insights and expertise already within you
- Maintains your ownership and understanding of decisions
- Captures your specific context, constraints, and goals
- Enables deeper exploration of your unique situation
- Creates outputs you can confidently explain and iterate on
## Real-World Examples from BMAD Workflows
### Brainstorming Workflow (from core module)
The brainstorming workflow demonstrates pure facilitation through its entire journey:
**Session Setup:**
```
"Welcome! I'm excited to facilitate your brainstorming session. I'll guide you
through proven creativity techniques to generate innovative ideas.
**What are we brainstorming about?** (The central topic or challenge)
**What specific outcomes are you hoping for?** (Types of ideas, solutions, or insights)
```
**Technique Selection - Offering Options:**
```
"Ready to explore technique approaches?
[1] User-Selected Techniques - Browse our complete technique library
[2] AI-Recommended Techniques - Get customized suggestions based on your goals
[3] Random Technique Selection - Discover unexpected creative methods
[4] Progressive Technique Flow - Start broad, then systematically narrow focus
Which approach appeals to you most?"
```
**Technique Execution - Interactive Coaching:**
The workflow doesn't generate ideas—it coaches you through techniques with genuine back-and-forth dialogue:
```
"Let's start with: What if you could remove all practical constraints?
I'm not just looking for a quick answer - I want to explore this together.
What immediately comes to mind? Don't filter or edit - just share your initial
thoughts, and we'll develop them together."
[User responds]
"That's interesting! Tell me more about [specific aspect you mentioned].
What would that look like in practice? How does that connect to your core goal?"
```
**Key facilitation behaviors:**
- Aims for 100+ ideas before suggesting organization
- Asks "Continue exploring?" or "Move to next technique?"—user controls pace
- Uses anti-bias protocols to force thinking in new directions every 10 ideas
- Builds on user's ideas with genuine creative contributions
- Keeps user in "generative exploration mode" as long as possible
**Organization - Collaborative Synthesis:**
```
"Outstanding creative work! You've generated an incredible range of ideas.
Now let's organize these creative gems and identify your most promising opportunities.
I'm analyzing all your generated ideas to identify natural themes and patterns.
**Emerging Themes I'm Identifying:**
- Theme 1: [Name] - Ideas: [list] - Pattern: [connection]
- Theme 2: [Name] - Ideas: [list] - Pattern: [connection]
Which themes or specific ideas stand out to you as most valuable?"
```
Result: A comprehensive brainstorming session document with **your** ideas, organized by **your** priorities, with **your** action plans.
### Create UX Design Workflow (from BMM method)
The UX design workflow facilitates a 14-step journey from project understanding to complete UX specification—**never making design decisions for you**.
**Step 1: Document Discovery (Collaborative Setup)**
```
"Welcome! I've set up your UX design workspace.
**Documents Found:**
- PRD: product-requirements.md
- Product brief: brief.md
**Files loaded:** [lists specific files]
Do you have any other documents you'd like me to include, or shall we continue?"
```
**Step 2: Project Understanding (Discovery Questions)**
```
"Based on the project documentation, let me confirm what I'm understanding...
**From the documents:** [summary of key insights]
**Target Users:** [summary from documents]
**Key Features/Goals:** [summary from documents]
Does this match your understanding? Are there any corrections or additions?"
```
Then it dives deeper with targeted questions:
```
"Let me understand your users better to inform the UX design:
**User Context Questions:**
- What problem are users trying to solve?
- What frustrates them with current solutions?
- What would make them say 'this is exactly what I needed'?"
```
**Step 3: Core Experience Definition (Guiding Insights)**
```
"Now let's dig into the heart of the user experience.
**Core Experience Questions:**
- What's the ONE thing users will do most frequently?
- What user action is absolutely critical to get right?
- What should be completely effortless for users?
- If we nail one interaction, everything else follows - what is it?
Think about the core loop or primary action that defines your product's value."
```
**Step 4: Emotional Response (Feelings-Based Design)**
```
"Now let's think about how your product should make users feel.
**Emotional Response Questions:**
- What should users FEEL when using this product?
- What emotion would make them tell a friend about this?
- How should users feel after accomplishing their primary goal?
Common emotional goals: Empowered and in control? Delighted and surprised?
Efficient and productive? Creative and inspired?"
```
**Step 5: Pattern Inspiration (Learning from Examples)**
```
"Let's learn from products your users already love and use regularly.
**Inspiration Questions:**
- Name 2-3 apps your target users already love and USE frequently
- For each one, what do they do well from a UX perspective?
- What makes the experience compelling or delightful?
For each inspiring app, let's analyze their UX success:
- What core problem does it solve elegantly?
- What makes the onboarding experience effective?
- How do they handle navigation and information hierarchy?"
```
**Step 9: Design Directions (Interactive Visual Exploration)**
The workflow generates 6-8 HTML mockup variations—but **you choose**:
```
"🎨 Design Direction Mockups Generated!
I'm creating a comprehensive HTML showcase with 6-8 full-screen mockup variations.
Each mockup represents a complete visual direction for your app's look and feel.
**As you explore the design directions, look for:**
✅ Which information hierarchy matches your priorities?
✅ Which interaction style fits your core experience?
✅ Which visual density feels right for your brand?
**Which approach resonates most with you?**
- Pick a favorite direction as-is
- Combine elements from multiple directions
- Request modifications to any direction
Tell me: Which layout feels most intuitive? Which visual weight matches your brand?"
```
**Step 12: UX Patterns (Consistency Through Questions)**
```
"Let's establish consistency patterns for common situations.
**Pattern Categories to Define:**
- Button hierarchy and actions
- Feedback patterns (success, error, warning, info)
- Form patterns and validation
- Navigation patterns
Which categories are most critical for your product?
**For [Critical Pattern Category]:**
What should users see/do when they need to [pattern action]?
**Considerations:**
- Visual hierarchy (primary vs. secondary actions)
- Feedback mechanisms
- Error recovery
- Accessibility requirements
How should your product handle [pattern type] interactions?"
```
**The Result:** A complete, production-ready UX specification document that captures **your** decisions, **your** reasoning, and **your** vision—documented through guided discovery, not generation.
## Key Principles
### 1. Questions Over Answers
CIS agents ask strategic questions rather than providing direct answers. This:
- Activates your own creative thinking
- Uncovers assumptions
- Reveals blind spots
- Builds on your domain knowledge
Facilitative workflows ask strategic questions rather than providing direct answers. This:
- Activates your own creative and analytical thinking
- Uncovers assumptions you didn't know you had
- Reveals blind spots in your understanding
- Builds on your domain expertise and context
### 2. Energy-Aware Sessions
### 2. Multi-Turn Conversation
CIS monitors engagement and adapts:
- Adjusts pace when energy flags
- Suggests breaks when needed
- Changes techniques to maintain momentum
- Recognizes productive vs. unproductive struggle
Facilitation uses progressive discovery, not interrogation:
- Ask 1-2 questions at a time, not laundry lists
- Think about responses before asking follow-ups
- Probe to understand deeper, not just collect facts
- Use conversation to explore, not just extract
### 3. Process Trust
### 3. Intent-Based Guidance
CIS uses proven methodologies:
- Design Thinking's 5 phases
- Structured brainstorming techniques
Workflows specify goals and approaches, not exact scripts:
- "Guide the user through discovering X" (intent)
- NOT "Say exactly: 'What is X?'" (prescriptive)
This allows the workflow to adapt naturally to your responses while maintaining structured progress.
### 4. Process Trust
Facilitative workflows use proven methodologies:
- Design Thinking's phases (Empathize, Define, Ideate, Prototype, Test)
- Structured brainstorming and creativity techniques
- Root cause analysis frameworks
- Innovation strategy patterns
You're not just having a conversation—you're following time-tested creative processes.
You're not just having a conversation—you're following time-tested processes adapted to your specific situation.
### 4. Persona-Driven Engagement
### 5. YOU Are the Expert
Each CIS agent has a distinct personality:
- **Carson** - Energetic, encouraging
- **Maya** - Jazz-like, improvisational
- **Dr. Quinn** - Analytical, methodical
- **Victor** - Bold, strategic
- **Sophia** - Narrative, imaginative
Facilitative workflows operate on a core principle: **you are the expert on your situation**. The workflow brings:
- Process expertise (how to think through problems)
- Facilitation skills (how to guide exploration)
- Technique knowledge (proven methods and frameworks)
These personas create engaging experiences that maintain creative flow.
You bring:
- Domain knowledge (your specific field or industry)
- Context understanding (your unique situation and constraints)
- Decision authority (what will actually work for you)
## When Generation is Appropriate
CIS does generate when appropriate:
- Synthesizing session outputs
- Documenting decisions
- Creating structured artifacts
- Providing technique examples
Facilitative workflows DO generate when appropriate:
- Synthesizing and structuring outputs after you've made decisions
- Documenting your choices and rationale
- Creating structured artifacts based on your input
- Providing technique examples or option templates
- Formatting and organizing your conclusions
But the core creative work happens through facilitated discovery.
But the **core creative and analytical work** happens through facilitated discovery, not generation.
## The Distinction: Facilitator vs Generator
| Facilitative Workflow | Generative AI |
| ------------------------------------- | --------------------------------------- |
| "What are your goals?" | "Here's the solution" |
| Asks 1-2 questions at a time | Produces complete output immediately |
| Multiple turns, progressive discovery | Single turn, bulk generation |
| "Let me understand your context" | "Here's a generic answer" |
| Offers options, you choose | Makes decisions for you |
| Documents YOUR reasoning | No reasoning visible |
| You can explain every decision | You can't explain why choices were made |
| Ownership and understanding | Outputs feel alien |
## Benefits
### For Individuals
- Deeper insights than pure generation
- Ownership of creative outputs
- Skill development in creative thinking
- More memorable and actionable ideas
- **Deeper insights** than pure generation—ideas connect to your actual knowledge
- **Full ownership** of creative outputs and decisions
- **Skill development** in structured thinking and problem-solving
- **More memorable and actionable** results—you understand the "why"
### For Teams
- Shared creative experience
- Aligned understanding
- Documented rationale
- Stronger buy-in to outcomes
- **Shared creative experience** building alignment and trust
- **Aligned understanding** through documented exploration
- **Documented rationale** for future reference and onboarding
- **Stronger buy-in** to outcomes because everyone participated in discovery
### For Implementation
- **Outputs match reality** because they emerged from your actual constraints
- **Easier iteration** because you understand the reasoning behind choices
- **Confident implementation** because you can defend every decision
- **Reduced rework** because facilitation catches issues early

1
docs/how-to/troubleshooting/bmgd-troubleshooting.md
View File

@@ -215,6 +215,5 @@ When reporting issues, include:
## Next Steps
- **[Quick Start Guide](/docs/tutorials/getting-started/quick-start-bmgd.md)** - Getting started
- **[Workflows Guide](/docs/reference/workflows/index.md)** - Workflow reference
- **[Glossary](/docs/reference/glossary/index.md)** - Terminology

260
docs/tutorials/getting-started/quick-start-bmgd.md
View File

@@ -1,260 +0,0 @@
---
title: "Getting Started with BMad Game Development"
description: Build games with BMad's Game Development Module
---
Build games faster using AI-powered workflows with specialized game development agents that guide you through preproduction, design, architecture, and implementation.
:::note[Module Extension]
BMGD (BMad Game Development) is a module that extends BMad Method. You'll need BMad installed first—see the [BMad v6 tutorial](/docs/tutorials/getting-started/getting-started-bmadv6.md) if you haven't installed it yet.
:::
## What You'll Learn
- Install and configure the BMGD module
- Understand game development phases and specialized agents
- Create a Game Brief and Game Design Document (GDD)
- Progress from concept to working game code
:::note[Prerequisites]
- **BMad Method installed** — Follow the main installation guide first
- **A game idea** — Even a rough concept is enough to start
- **AI-powered IDE** — Claude Code, Cursor, Windsurf, or similar
:::
:::tip[Quick Path]
**Install** → `npx bmad-method install` (select BMGD module)
**Preproduction** → Game Designer creates Game Brief
**Design** → Game Designer creates GDD (and Narrative if story-driven)
**Technical** → Game Architect creates Architecture
**Production** → Game SM manages sprints, Game Dev implements
**Always use fresh chats** for each workflow to avoid context issues.
:::
## Understanding BMGD
BMGD follows four game development phases with specialized agents for each:
| Phase | Name | What Happens |
| ----- | ------------- | ----------------------------------------------------------------- |
| 1 | Preproduction | Capture game vision, create Game Brief *(optional brainstorming)* |
| 2 | Design | Detail mechanics, systems, narrative in GDD |
| 3 | Technical | Plan engine, architecture, technical decisions |
| 4 | Production | Build game in sprints, story by story |
![BMGD Workflow Overview](./images/workflow-overview.jpg)
*Complete visual flowchart showing all phases, workflows, and agents for game development.*
### Game Development Agents
| Agent | When to Use |
| --------------------- | ----------------------------------------- |
| **Game Designer** | Brainstorming, Game Brief, GDD, Narrative |
| **Game Architect** | Architecture, technical decisions |
| **Game Developer** | Implementation, code reviews |
| **Game Scrum Master** | Sprint planning, story management |
| **Game QA** | Test framework, test design, automation |
| **Game Solo Dev** | Quick prototyping, indie development |
## Installation
If you haven't installed BMad yet:
```bash
npx bmad-method install
```
Or add BMGD to an existing installation:
```bash
npx bmad-method install --add-module bmgd
```
Verify your installation:
```
your-project/
├── _bmad/
│ ├── bmgd/ # Game development module
│ │ ├── agents/ # Game-specific agents
│ │ ├── workflows/ # Game-specific workflows
│ │ └── config.yaml # Module config
│ ├── bmm/ # Core method module
│ └── core/ # Core utilities
├── _bmad-output/ # Generated artifacts (created later)
└── .claude/ # IDE configuration (if using Claude Code)
```
## Step 1: Create Your Game Brief (Preproduction)
Load the **Game Designer** agent in your IDE, wait for the menu, then start with your game concept.
### Optional: Brainstorm First
If you have a vague idea and want help developing it:
```
Run brainstorm-game
```
The agent guides you through game-specific ideation techniques to refine your concept.
### Create the Game Brief
```
Run create-game-brief
```
The Game Designer walks you through:
- **Game concept** — Core idea and unique selling points
- **Design pillars** — The 3-5 principles that guide all decisions
- **Target market** — Who plays this game?
- **Fundamentals** — Platform, genre, scope, team size
When complete, you'll have `game-brief.md` in your `_bmad-output/` folder.
:::caution[Fresh Chats]
Always start a fresh chat for each workflow. This prevents context limitations from causing issues.
:::
## Step 2: Design Your Game
With your Game Brief complete, detail your game's design.
### Create the GDD
**Start a fresh chat** with the **Game Designer** agent.
```
Run create-gdd
```
The agent guides you through mechanics, systems, and game-type-specific sections. BMGD offers 24 game type templates that provide genre-specific structure.
When complete, you'll have `gdd.md` (or sharded into `gdd/` for large documents).
:::note[Narrative Design (Optional)]
For story-driven games, start a fresh chat and run `narrative` to create a Narrative Design Document covering story, characters, world, and dialogue.
:::
:::tip[Check Your Status]
Unsure what's next? Load any agent and run `workflow-status`. It tells you the next recommended workflow.
:::
## Step 3: Plan Your Architecture
**Start a fresh chat** with the **Game Architect** agent.
```
Run create-architecture
```
The architect guides you through:
- **Engine selection** — Unity, Unreal, Godot, custom, etc.
- **System design** — Core game systems and how they interact
- **Technical patterns** — Architecture patterns suited to your game
- **Structure** — Project organization and conventions
When complete, you'll have `game-architecture.md`.
## Step 4: Build Your Game
Once planning is complete, move to production. **Each workflow should run in a fresh chat.**
### Initialize Sprint Planning
Load the **Game Scrum Master** agent and run `sprint-planning`. This creates `sprint-status.yaml` to track all epics and stories.
### The Build Cycle
For each story, repeat this cycle with fresh chats:
| Step | Agent | Workflow | Purpose |
| ---- | -------- | -------------- | ---------------------------------- |
| 1 | Game SM | `create-story` | Create story file from epic |
| 2 | Game Dev | `dev-story` | Implement the story |
| 3 | Game QA | `automate` | Generate tests *(optional)* |
| 4 | Game Dev | `code-review` | Quality validation *(recommended)* |
After completing all stories in an epic, load the **Game SM** and run `retrospective`.
### Quick Prototyping Alternative
For rapid iteration or indie development, load the **Game Solo Dev** agent:
- `quick-prototype` — Rapid prototyping
- `quick-dev` — Flexible development without full sprint structure
## What You've Accomplished
You've learned the foundation of building games with BMad:
- Installed the BMGD module
- Created a Game Brief capturing your vision
- Detailed your design in a GDD
- Planned your technical architecture
- Understood the build cycle for implementation
Your project now has:
```
your-project/
├── _bmad/ # BMad configuration
├── _bmad-output/
│ ├── game-brief.md # Your game vision
│ ├── gdd.md # Game Design Document
│ ├── narrative-design.md # Story design (if applicable)
│ ├── game-architecture.md # Technical decisions
│ ├── epics/ # Epic and story files
│ └── sprint-status.yaml # Sprint tracking
└── ...
```
## Quick Reference
| Command | Agent | Purpose |
| ---------------------- | -------------- | ----------------------------- |
| `*brainstorm-game` | Game Designer | Guided game ideation |
| `*create-game-brief` | Game Designer | Create Game Brief |
| `*create-gdd` | Game Designer | Create Game Design Document |
| `*narrative` | Game Designer | Create Narrative Design |
| `*create-architecture` | Game Architect | Create game architecture |
| `*sprint-planning` | Game SM | Initialize sprint tracking |
| `*create-story` | Game SM | Create a story file |
| `*dev-story` | Game Dev | Implement a story |
| `*code-review` | Game Dev | Review implemented code |
| `*workflow-status` | Any | Check progress and next steps |
## Common Questions
**Do I need to create all documents?**
At minimum, create a Game Brief and GDD. Architecture is highly recommended. Narrative Design is only needed for story-driven games.
**Can I use the Game Solo Dev for everything?**
Yes, for smaller projects or rapid prototyping. For larger games, the specialized agents provide more thorough guidance.
**What game types are supported?**
BMGD includes 24 game type templates (RPG, platformer, puzzle, strategy, etc.) that provide genre-specific GDD sections.
**Can I change my design later?**
Yes. Documents are living artifacts—return to update them as your vision evolves. The SM agent has `correct-course` for scope changes.
## Getting Help
- **During workflows** — Agents guide you with questions and explanations
- **Community** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
- **Documentation** — [BMGD Workflow Reference](/docs/reference/workflows/bmgd-workflows.md)
- **Video tutorials** — [BMad Code YouTube](https://www.youtube.com/@BMadCode)
## Key Takeaways
:::tip[Remember These]
- **Always use fresh chats** — Load agents in new chats for each workflow
- **Game Brief first** — It informs everything that follows
- **Use game type templates** — 24 templates provide genre-specific GDD structure
- **Documents evolve** — Return to update them as your vision grows
- **Solo Dev for speed** — Use Game Solo Dev for rapid prototyping
:::
Ready to start? Load the **Game Designer** agent and run `create-game-brief` to capture your game vision.