External/BMAD-METHOD
1
0
Fork 0
mirror of https://github.com/bmadcode/BMAD-METHOD.git synced 2025-12-29 16:14:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: Add documentation guides, simplify folder structure, and major workflow refactoring

Browse Source 
Created two comprehensive guides for v6 features:

**docs/agent-customization-guide.md**
- Complete guide for customizing agent names, personas, memories, and behaviors
- Update-safe customization via bmad/_cfg/agents/ configuration files
- Real-world examples (TDD setup, multilingual agents, custom workflows)
- Troubleshooting and best practices

**docs/web-bundles-gemini-gpt-guide.md**
- Comprehensive guide for using BMad agents in Gemini Gems and Custom GPTs
- Critical setup rules with exact configuration text required
- Cost-saving strategy: web planning → local implementation (60-80% savings)
- Platform comparison (Gemini Gems strongly recommended over Custom GPTs)
- Complete workflow examples showing full planning-to-implementation cycle
- Team bundle guidance (Gemini 2.5 Pro+ only)

**README.md updates**
- Added prominent links in v6 Core Enhancements section
- Created new "Customization & Sharing" documentation category
- Web Bundles feature highlighted with direct guide link

**Unified output folder structure across all modules:**

**Before (confusing):**
- output_folder: Main docs
- game_design_docs: Separate design folder
- tech_docs: Separate technical folder
- dev_ephemeral_location: Separate ephemeral folder outside docs

**After (simplified):**
- output_folder: Single location for ALL AI-generated artifacts (default: "docs")
  - Clearer prompt: "Where should AI Generated Artifacts be saved?"
- sprint_artifacts: Phase 4 ephemeral content now WITHIN output_folder
  - BMM: {output_folder}/stories (stories, context, reports)
  - BMGD: {output_folder}/sprint-artifacts
  - No longer in separate {bmad_folder}-ephemeral location

**Benefits:**
- One clear location for all planning artifacts (PRD, Architecture, UX, etc.)
- Phase 4 ephemeral items logically grouped within output folder
- Eliminated confusing separate folder proliferation
- sprint_artifacts now configurable per module

**Files changed:**
- src/core/_module-installer/install-config.yaml
- src/modules/bmm/_module-installer/install-config.yaml
- src/modules/bmgd/_module-installer/install-config.yaml

**Also cleaned up BMGD config:**
- Renamed: specified_framework → primary_platform (clearer naming)
- Removed: unused data_path variable

Replaced old "project_level" (0-4) system with new "selected_track" terminology:
- **quick-flow**: Bug fixes and small features (replaces Level 0-1)
- **bmad-method**: Full planning track (replaces Level 2-3)
- **enterprise-bmad-method**: Extended planning (replaces Level 4)

**Core workflow updates:**
- solutioning-gate-check: Complete rewrite of validation logic for track-based artifacts
- architecture: Updated context detection, error handling, and messaging for tracks
- workflow-init: Updated artifact detection patterns for track-based paths
- All workflow status paths updated (method-greenfield, method-brownfield, enterprise-*)

Unified variable naming conventions across all workflows:
- {output_folder} → {output-folder} (hyphenated format)
- {dev_ephemeral_location} → {sprint_artifacts} (clearer purpose)
- Hardcoded status file paths → {workflow_status_file} variable

Fixed corrupted variable patterns throughout workflow files:
- {output*folder} → {output-folder}
- {ephemeral*location} → {sprint_artifacts}
- \_prd* → *prd* (escaped underscore artifacts)
- **\*\***\_\_\_**\*\*** → proper field placeholders

Affected patterns included malformed glob patterns, template variables, and markdown formatting artifacts from previous edits.

**Architecture workflow (create-architecture):**
- Fixed: "Decision Architecture" → "Create Architecture" (consistent naming)
- Improved PRD not found handling with exit/continue options
- Better user guidance when running standalone vs. within workflow path
- Removed hardcoded Level checks, now track-aware
- Enhanced validation checklist formatting (□ → - [])
- Typo fixes: "mulitple" → "multiple"

**Solutioning gate check:**
- Complete validation logic rewrite for track-based system
- Removed Level-specific artifact expectations
- Simplified document discovery (track determines what exists)
- Better analysis prompts and user feedback

**Workflow-init:**
- Updated artifact detection patterns for new folder structure
- Fixed corrupt glob patterns throughout
- Better sprint_artifacts location detection
- Improved workflow path assignment logic

**Various workflows:**
- Consistent variable naming across 40+ workflow files
- Improved error messages and user guidance
- Better markdown formatting (checkboxes, lists)
- Removed redundant validation criteria files (now inline)

Removed duplicate BMGD 4-production workflows (12 workflows):
- code-review, correct-course, create-story, dev-story
- epic-tech-context, retrospective, sprint-planning
- story-context, story-done, story-ready

**Why:** BMGD now uses shared BMM Phase 4 implementation workflows
**Benefit:** Single source of truth, no duplication to maintain

Also removed:
- validation-criteria.yaml (validation now inline in instructions)
- architecture-patterns.yaml references (patterns now managed differently)
- AUDIT-REPORT.md files (stale audit artifacts)

**BMB workflows:**
- Updated checklists for workflow and module creation
- Improved agent architecture documentation
- Minor instruction clarifications

**Core brainstorming workflow:**
- Updated README with usage examples
- Enhanced instructions and template clarity
- Better integration with other modules

**BMM installer:**
- Updated for track-based system
- sprint_artifacts configuration

**Tech Writer agent:**
- Minor configuration update for documentation workflows

Removed 200+ files that should not be in repository:
- Installed agent markdown files (analyst, architect, dev, pm, sm, tea, etc.)
- Complete workflow instruction copies
- Documentation duplicates (quick-start, agents-guide, workflows-*)
- Test architecture knowledge base (22 files, 14,000+ lines)
- Configuration files (config.yaml, team definitions)

These are generated during installation and should not be version controlled.

Removed 21 pre-generated XML bundles:
- BMM agents (analyst, architect, dev, pm, sm, tea, tech-writer, ux-designer)
- BMGD agents (game-architect, game-designer, game-dev, game-scrum-master)
- CIS agents (brainstorming-coach, creative-problem-solver, etc.)
- Team bundles (team-fullstack, team-gamedev, creative-squad)

**Why:** Users should generate fresh bundles via `npm run bundle` to get latest changes and customizations.

- **2 new documentation files** (comprehensive guides)
- **98 source files modified** (299 insertions, 6,567 deletions)
- **3 installer config files simplified** (major folder structure improvement)
- **200+ .bmad/ artifacts removed** (should not be in repo)
- **21 web-bundle files removed** (users regenerate as needed)
- **12 duplicate workflows removed** (BMGD consolidation)
- **40+ workflows updated** (track system, variable standardization, corruption fixes)
This commit is contained in:
Brian Madison
2025-11-11 12:22:31 -06:00
parent 280652566c
commit 2d99833b9e
318 changed files with 904 additions and 115532 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
docs/agent-customization-guide.md Normal file
View File

@@ -0,0 +1,208 @@
# Agent Customization Guide
Customize BMad agents without modifying core files. All customizations persist through updates.
## Quick Start
**1. Locate Customization Files**
After installation, find agent customization files in:
```
bmad/_cfg/agents/
├── core-bmad-master.customize.yaml
├── bmm-dev.customize.yaml
├── bmm-pm.customize.yaml
└── ... (one file per installed agent)
```
**2. Edit Any Agent**
Open the `.customize.yaml` file for the agent you want to modify. All sections are optional - customize only what you need.
**3. Rebuild the Agent**
After editing, IT IS CRITICAL to rebuild the agent to apply changes:
```bash
npx bmad-method@alpha install # and then select option to compile all agents
# OR for individual agent only
npx bmad-method@alpha build <agent-name>
# Examples:
npx bmad-method@alpha build bmm-dev
npx bmad-method@alpha build core-bmad-master
npx bmad-method@alpha build bmm-pm
```
## What You Can Customize
### Agent Name
Change how the agent introduces itself:
```yaml
agent:
metadata:
name: 'Spongebob' # Default: "Amelia"
```
### Persona
Replace the agent's personality, role, and communication style:
```yaml
persona:
role: 'Senior Full-Stack Engineer'
identity: 'Lives in a pineapple (under the sea)'
communication_style: 'Spongebob'
principles:
- 'Never Nester, Spongebob Devs hate nesting more than 2 levels deep'
- 'Favor composition over inheritance'
```
**Note:** The persona section replaces the entire default persona (not merged).
### Memories
Add persistent context the agent will always remember:
```yaml
memories:
- 'Works at Krusty Krab'
- 'Favorite Celebrity: David Hasslehoff'
- 'Learned in Epic 1 that its not cool to just pretend that tests have passed'
```
### Custom Menu Items
Add your own workflows to the agent's menu:
```yaml
menu:
- trigger: my-workflow
workflow: '{project-root}/custom/my-workflow.yaml'
description: My custom workflow
- trigger: deploy
action: '#deploy-prompt'
description: Deploy to production
```
**Don't include:** `*` prefix or `help`/`exit` items - these are auto-injected.
### Critical Actions
Add instructions that execute before the agent starts:
```yaml
critical_actions:
- 'Always check git status before making changes'
- 'Use conventional commit messages'
```
### Custom Prompts
Define reusable prompts for `action="#id"` menu handlers:
```yaml
prompts:
- id: deploy-prompt
content: |
Deploy the current branch to production:
1. Run all tests
2. Build the project
3. Execute deployment script
```
## Real-World Examples
**Example 1: Customize Developer Agent for TDD**
```yaml
# bmad/_cfg/agents/bmm-dev.customize.yaml
agent:
metadata:
name: 'TDD Developer'
memories:
- 'Always write tests before implementation'
- 'Project uses Jest and React Testing Library'
critical_actions:
- 'Review test coverage before committing'
```
**Example 2: Add Custom Deployment Workflow**
```yaml
# bmad/_cfg/agents/bmm-dev.customize.yaml
menu:
- trigger: deploy-staging
workflow: '{project-root}/.bmad-custom/deploy-staging.yaml'
description: Deploy to staging environment
- trigger: deploy-prod
workflow: '{project-root}/.bmad-custom/deploy-prod.yaml'
description: Deploy to production (with approval)
```
**Example 3: Multilingual Product Manager**
```yaml
# bmad/_cfg/agents/bmm-pm.customize.yaml
persona:
role: 'Bilingual Product Manager'
identity: 'Expert in US and LATAM markets'
communication_style: 'Clear, strategic, with cultural awareness'
principles:
- 'Consider localization from day one'
- 'Balance business goals with user needs'
memories:
- 'User speaks English and Spanish'
- 'Target markets: US and Latin America'
```
## Tips
- **Start Small:** Customize one section at a time and rebuild to test
- **Backup:** Copy customization files before major changes
- **Update-Safe:** Your customizations in `_cfg/` survive all BMad updates
- **Per-Project:** Customization files are per-project, not global
- **Version Control:** Consider committing `_cfg/` to share customizations with your team
## Module vs. Global Config
**Module-Level (Recommended):**
- Customize agents per-project in `bmad/_cfg/agents/`
- Different projects can have different agent behaviors
**Global Config (Coming Soon):**
- Set defaults that apply across all projects
- Override with project-specific customizations
## Troubleshooting
**Changes not appearing?**
- Make sure you ran `npx bmad-method build <agent-name>` after editing
- Check YAML syntax is valid (indentation matters!)
- Verify the agent name matches the file name pattern
**Agent not loading?**
- Check for YAML syntax errors
- Ensure required fields aren't left empty if you uncommented them
- Try reverting to the template and rebuilding
**Need to reset?**
- Delete the `.customize.yaml` file
- Run `npx bmad-method build <agent-name>` to regenerate defaults
## Next Steps
- **[BMM Agents Guide](../src/modules/bmm/docs/agents-guide.md)** - Learn about all 12 BMad Method agents
- **[BMB Create Agent Workflow](../src/modules/bmb/workflows/create-agent/README.md)** - Build completely custom agents
- **[BMM Complete Documentation](../src/modules/bmm/docs/README.md)** - Full BMad Method reference

473
docs/web-bundles-gemini-gpt-guide.md Normal file
View File

@@ -0,0 +1,473 @@
# Using BMad Web Bundles in Gemini Gems & Custom GPTs
Web bundles package BMad agents as self-contained XML files that work in Gemini Gems and Custom GPTs. Everything the agent needs - instructions, workflows, dependencies - is bundled into a single file.
## What Are Web Bundles?
Web bundles are standalone XML files containing:
- Complete agent persona and instructions
- All workflows and dependencies
- Interactive menu system
- Party mode for multi-agent collaboration
- No external files required
**Perfect for:** Uploading a single file to a Gemini GEM or Custom GPT to use BMad Method from the Web, generally at a huge cost savings, at the expense of some quality and convenience of using locally.
## Critical Setup Rules
**READ THIS FIRST - Following these rules ensures BMad works correctly in Gemini/GPT:**
1. **ONE file per Gem/GPT** - Upload exactly ONE XML file per Gemini Gem or Custom GPT instance. Do NOT combine multiple agent files.
2. **Use the setup instructions** - When creating your Gem/GPT, you MUST add the configuration prompt (shown in Quick Start below) so it knows how to read the XML file.
3. **Enable Canvas/Code Execution** - This is ESSENTIAL for document generation workflows (PRD, Architecture, etc.). Enable this in your Gem/GPT settings.
4. **Gemini Gems are strongly preferred** - They work significantly better than Custom GPTs for BMad workflows.
5. **Team bundles = Gemini 2.5 Pro+ only** - Team bundles (multiple agents) have terrible performance in Custom GPTs due to context limits. Only use them with Gemini 2.5 Pro or higher.
6. **Create separate Gems for each agent** - Make a PM Gem, an Architect Gem, a Developer Gem, etc. Don't try to combine them (except via official team bundles).
## Quick Start
### 1. Get Web Bundle Files
**Option A: Download Pre-Bundled Files (Quickest)**
Download ready-to-use bundles directly from GitHub:
**[→ Browse Web Bundles on GitHub](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/web-bundles)**
Navigate to the module folder (bmm, bmb, cis, bmgd) → agents folder → download the `.xml` file you need.
**Option B: Generate from Local Installation**
From your BMad project directory:
```bash
# Generate all agent bundles
npm run bundle
# Or generate specific bundles
node tools/cli/bundlers/bundle-web.js module bmm
node tools/cli/bundlers/bundle-web.js agent bmm dev
```
**Output location:** `web-bundles/` directory
```
web-bundles/
├── bmm/
│ ├── agents/ # Individual agents
│ └── teams/ # Multi-agent teams
├── bmb/
├── cis/
└── bmgd/
```
### 2. Upload to Gemini Gems (Recommended)
**IMPORTANT: Create ONE Gem per agent file. Do NOT upload multiple agent files to a single Gem.**
**Create a Gem:**
1. Go to [Google AI Studio](https://aistudio.google.com/)
2. Click "New Gem" or "Create Gem"
3. Give your Gem a name (e.g., "BMad PM Agent")
4. **Enable "Code execution" for best results with document generation**
5. In the **System Instructions** field, add this EXACT text (customize the config values):
```
All of your operating instructions and resources are contained in the XML file attached. Read in the initial agent block and instructions to understand it. You will not deviate from the character and rules outlined in the attached!
CONFIG.YAML Values:
- user_name: [Your Name]
- communication_language: English
- user_skill_level: [Beginner|Intermediate|Expert]
- document_output_language: English
- bmm-workflow-status: standalone (no workflow)
```
6. **Upload ONE XML file** (e.g., `pm.xml`) - either attach as a file or paste contents
7. Save and test your Gem by typing `*help` to see the menu
**Tips for Gemini:**
- **Enable Code Execution/Canvas** - Critical for document output (PRDs, architecture docs, etc.)
- **Use Gemini 2.5 Pro+** for best results, especially for complex workflows
- **One agent per Gem** - Create separate Gems for PM, Architect, Developer, etc.
- Test the agent by triggering menu items with `*workflow-name`
### 3. Upload to Custom GPTs
**IMPORTANT: Create ONE Custom GPT per agent file. Do NOT upload multiple agent files to a single GPT.**
**Create a Custom GPT:**
1. Go to [ChatGPT](https://chat.openai.com/)
2. Click your profile → "My GPTs" → "Create a GPT"
3. Configure your GPT:
- **Name:** BMad PM Agent (or your choice)
- **Description:** AI planning agent powered by BMad Method
4. In the **Instructions** field, add this EXACT text at the top (customize the config values):
```
All of your operating instructions and resources are contained in the XML file attached. Read in the initial agent block and instructions to understand it. You will not deviate from the character and rules outlined in the attached!
CONFIG.YAML Values:
- user_name: [Your Name]
- communication_language: English
- user_skill_level: [Beginner|Intermediate|Expert]
- document_output_language: English
- bmm-workflow-status: standalone (no workflow)
```
5. **Below that text**, paste the entire contents of ONE XML file (e.g., `pm.xml`)
6. **Enable "Canvas" in ChatGPT settings** for better document output
7. Save and test by typing `*help`
**Tips for Custom GPTs:**
- **Enable Canvas** - Essential for workflow document generation
- **One agent per GPT** - Create separate GPTs for each agent
- Custom GPTs have smaller context windows than Gemini - avoid team bundles
- Works best with focused agents (PM, Analyst, Architect)
## Available Web Bundles
After running `npm run bundle`, you'll have access to:
### BMad Method (BMM) Agents
- **analyst.xml** - Business analysis and requirements gathering
- **architect.xml** - System architecture and technical design
- **dev.xml** - Full-stack development and implementation
- **pm.xml** - Product management and planning
- **sm.xml** - Scrum master and agile facilitation
- **tea.xml** - Test architecture and quality assurance
- **tech-writer.xml** - Technical documentation
- **ux-designer.xml** - User experience design
- **game-designer.xml** - Game design and mechanics
- **game-dev.xml** - Game development
- **game-architect.xml** - Game architecture
### BMad Builder (BMB) Agent
- **bmad-builder.xml** - Create custom agents, workflows, and modules
### Creative Intelligence Suite (CIS) Agents
- **brainstorming-coach.xml** - Creative brainstorming facilitation
- **design-thinking-coach.xml** - Human-centered problem solving
- **innovation-strategist.xml** - Innovation and strategy
- **creative-problem-solver.xml** - Breakthrough problem solving
- **storyteller.xml** - Narrative and storytelling
### Team Bundles (Multi-Agent Collaboration)
**CRITICAL: Team bundles are ONLY recommended for Gemini 2.5 Pro+ in the web. The experience is poor with Custom GPTs due to limited context windows.**
- **bmm/teams/team-fullstack.xml** - Full BMad Method development team
- **bmgd/teams/team-gamedev.xml** - Game development team
- **cis/teams/creative-squad.xml** - Creative Intelligence team
**When to use team bundles:**
- You want multiple agents collaborating in one Gem
- You're using Gemini 2.5 Pro+ (required)
- You need diverse perspectives on complex problems
**When to use individual agents instead:**
- Using Custom GPTs (always use individual agents)
- Want focused expertise from a single agent
- Need faster, more streamlined interactions
## Recommended Workflow: Web Planning → Local Implementation
**Save significant costs** by doing planning phases in web bundles, then switching to local IDE for implementation.
### Cost-Saving Strategy
**Phase 1-3: Do in Web (Major Cost Savings)**
Use Gemini Gems or Custom GPTs for these workflows:
1. **Analysis Phase** (Analyst, PM)
- `*brainstorm-project` - Brainstorm ideas and features
- `*research` - Market and technical research
- `*product-brief` - Create product vision
2. **Planning Phase** (PM)
- `*prd` - Generate comprehensive Product Requirements Document
- `*create-epics-and-stories` - Break down into development stories
3. **Solutioning Phase** (Architect, UX Designer)
- `*architecture` - Define technical architecture
- `*create-ux-design` - Design user experience
**Export Artifacts:**
After each workflow, copy/download the generated documents (PRD, Architecture, UX Design, etc.)
**Phase 4: Switch to Local IDE (Required for Implementation)**
1. Save exported artifacts to your project's `docs/` folder
2. Run local BMad installation with `*workflow-init`
3. BMad will detect the existing artifacts and update workflow status
4. Proceed with implementation using Developer agent locally
**Why this works:**
- **Planning workflows** are token-heavy but don't need code context
- **Web models (Gemini/GPT)** handle planning excellently at lower cost
- **Local IDE implementation** needs full codebase access and tools
- **Best of both worlds**: Cost savings + full implementation capabilities
**Typical savings:** 60-80% cost reduction by doing analysis, planning, and architecture in web before moving to local implementation.
## Using Web Bundles
### Basic Usage
**1. Load the Agent**
Upload or paste the XML file into Gemini/GPT. The agent will introduce itself and show its menu.
**2. Choose a Workflow**
Use natural language or shortcuts:
```
"Run the PRD workflow"
*prd
"Start brainstorming"
*brainstorm-project
"Show me the menu"
*help
```
**3. Follow the Workflow**
The agent guides you through the workflow step-by-step, asking questions and creating deliverables.
### Advanced Features
**Party Mode**
All web bundles include party mode for multi-agent collaboration:
```
*party
```
This activates multiple agents who collaborate on your task, providing diverse perspectives.
**Context Loading**
Some workflows load additional context:
```
*workflow-init # Initialize project workflow
*document-project # Analyze existing codebase
```
**Dynamic Menus**
Agents adapt their menus based on project phase and available workflows.
## Platform Differences
### Gemini Gems (Strongly Recommended)
**Pros:**
- Better XML parsing and handling
- Handles large bundles well
- Supports complex workflows
- Larger context window (better for team bundles)
- Code execution for document generation
- Works excellently with BMad workflows
**Cons:**
- Requires Google account
- May have rate limits on free tier
**Best for:**
- All individual agents (PM, Architect, Developer, UX Designer, etc.)
- Team bundles (requires Gemini 2.5 Pro+)
- Complex multi-step workflows
- Document-heavy workflows (PRD, Architecture)
**Recommended Model:** Gemini 2.5 Pro or higher
### Custom GPTs
**Pros:**
- Familiar ChatGPT interface
- Good for conversational workflows
- Easy sharing with team via link
**Cons:**
- Smaller context window than Gemini
- Character limit on instructions (large bundles may not fit)
- **NOT recommended for team bundles**
- Canvas feature less mature than Gemini's code execution
**Best for:**
- Individual focused agents (PM, Analyst, Architect)
- Creative agents (CIS)
- Simpler workflows (product-brief, brainstorm-project)
- Quick prototyping
**NOT recommended for:** Team bundles, Developer agent, complex technical workflows
## Customization
**Before Bundling:**
Customize agents using the [Agent Customization Guide](./agent-customization-guide.md):
1. Edit `bmad/_cfg/agents/<agent>.customize.yaml`
2. Rebuild: `npx bmad-method build <agent-name>`
3. Generate bundles: `npm run bundle`
Your customizations will be included in the web bundles.
**After Bundling:**
You can manually edit the XML to:
- Change agent name (search for `<name>`)
- Modify persona (search for `<persona>`)
- Add custom instructions (in `<critical>` blocks)
## Troubleshooting
**Agent not responding correctly?**
- Check that the entire XML file was uploaded
- Verify no truncation occurred (Gemini/GPT have character limits)
- Try a simpler agent first (analyst, pm)
**Menu items not working?**
- Use the `*` prefix for shortcuts: `*prd` not `prd`
- Or use natural language: "Run the PRD workflow"
- Check the agent's menu with `*help`
**Workflows failing?**
- Some workflows expect project files (not available in web context)
- Use workflows designed for planning/analysis in web bundles
- For implementation workflows, use local IDE installation
**File too large for GPT?**
- Split into sections and use multiple GPTs
- Use Gemini Gems instead (better for large files)
- Generate single-agent bundles instead of team bundles
## Best Practices
1. **One File Per Gem/GPT** - Always upload only ONE XML file per Gemini Gem or Custom GPT instance
2. **Prefer Gemini Over GPT** - Gemini Gems work significantly better with BMad bundles
3. **Enable Canvas/Code Execution** - Essential for document generation workflows (PRD, Architecture, etc.)
4. **Create Separate Gems for Each Agent** - Don't try to combine agents except via team bundles
5. **Team Bundles = Gemini 2.5 Pro+ Only** - Never use team bundles with Custom GPTs
6. **Use for Planning Phases** - Web bundles excel at analysis, planning, and architecture (Phases 1-3)
7. **Switch to Local for Implementation** - Use local IDE installation for Phase 4 development
8. **Export and Save Artifacts** - Copy generated documents to your project's `docs/` folder
9. **Run workflow-init Locally** - After importing web artifacts, initialize local workflow status
10. **Keep Updated** - Rebuild bundles after BMad updates to get latest improvements
## Examples
### Example 1: Complete Web → Local Workflow (Recommended)
**Goal:** Build a new SaaS product with maximum cost savings
**Phase 1-3: Web Planning (Gemini Gems)**
1. **Download bundles:**
- `bmm/agents/analyst.xml`
- `bmm/agents/pm.xml`
- `bmm/agents/architect.xml`
- `bmm/agents/ux-designer.xml`
2. **Create 4 separate Gemini Gems** (one per agent, enable Code Execution)
3. **Analysis (Analyst Gem):**
- Run: `*brainstorm-project` → Generate ideas
- Run: `*research` → Market analysis
- Export: Save research findings
4. **Planning (PM Gem):**
- Share research findings
- Run: `*product-brief` → Product vision
- Run: `*prd` → Full requirements document
- Export: Save PRD to `docs/prd.md`
5. **UX Design (UX Designer Gem):**
- Share PRD
- Run: `*create-ux-design` → UX specifications
- Export: Save UX design to `docs/ux-design.md`
6. **Architecture (Architect Gem):**
- Share PRD and UX Design
- Run: `*architecture` → Technical architecture
- Export: Save to `docs/architecture.md`
**Phase 4: Local Implementation**
7. **Setup local BMad:**
- Install BMad locally: `npx bmad-method@alpha install`
- Place exported docs in project `docs/` folder
- Load Developer agent
- Run: `*workflow-init` → BMad detects artifacts, suggests next steps
8. **Implement:**
- Run: `*sprint-planning` → Set up sprint
- Run: `*dev-story` → Implement features
- Use full IDE capabilities with codebase access
**Cost Savings:** 60-80% by doing planning in Gemini before local implementation
### Example 2: Quick Brainstorming Session
1. Download `cis/agents/brainstorming-coach.xml`
2. Create Gemini Gem with Code Execution enabled
3. Run: `*brainstorming`
4. Choose technique (e.g., SCAMPER, Mind Mapping)
5. Generate and refine ideas
6. Export results for team review
### Example 3: Architecture Review
1. Download `bmm/agents/architect.xml`
2. Create Gemini Gem (enable Code Execution)
3. Paste existing PRD into conversation
4. Run: `*architecture`
5. Collaborate on technical decisions
6. Export architecture document to `docs/architecture.md`
## Next Steps
- **[Agent Customization Guide](./agent-customization-guide.md)** - Customize before bundling
- **[BMM Documentation](../src/modules/bmm/docs/README.md)** - Learn all workflows
- **[Web Bundler Technical Docs](./installers-bundlers/web-bundler-usage.md)** - Advanced bundling options
- **[Contributing Guide](../CONTRIBUTING.md)** - Help improve web bundles
## Resources
- **[Google AI Studio](https://aistudio.google.com/)** - Create Gemini Gems
- **[Custom GPTs](https://chat.openai.com/gpts)** - Build Custom GPTs
- **[BMad Discord](https://discord.gg/gk8jAdXWmj)** - Get help and share your Gems/GPTs