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

advanced elicitation moved to workflows folder. core module extensive documentation added.

Browse Source
This commit is contained in:
Brian Madison
2025-12-28 19:44:55 +08:00
parent ea421adbf9
commit 8d679b177b
154 changed files with 680 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
docs/modules/bmb-bmad-builder/custom-content-installation.md Normal file
View File

@@ -0,0 +1,149 @@
# Custom Content Installation
This guide explains how to create and install custom BMAD content including agents, workflows, and modules. Custom content extends BMAD's functionality with specialized tools and workflows that can be shared across projects or teams.
For detailed information about the different types of custom content available, see [Custom Content](modules/bmb-bmad-builder/custom-content.md).
You can find example custom modules in the `samples/sample-custom-modules/` folder of the repository. Download either of the sample folders to try them out.
## Content Types Overview
BMAD Core supports several categories of custom content:
- Custom Stand Alone Modules
- Custom Add On Modules
- Custom Global Modules
- Custom Agents
- Custom Workflows
## Making Custom Content Installable
### Custom Modules
To create an installable custom module:
1. **Folder Structure**
- Create a folder with a short, abbreviated name (e.g., `cis` for Creative Intelligence Suite)
- The folder name serves as the module code
2. **Required File**
- Include a `module.yaml` file in the root folder (this drives questions for the final generated config.yaml at install target)
3. **Folder Organization**
Follow these conventions for optimal compatibility:
```
module-code/
module.yaml
agents/
workflows/
tools/
templates/
...
```
- `agents/` - Agent definitions
- `workflows/` - Workflow definitions
- Additional custom folders are supported but following conventions is recommended for agent and workflow discovery
**Note:** Full documentation for global modules and add-on modules will be available as support is finalized.
### Standalone Content (Agents, Workflows, Tasks, Tools, Templates, Prompts)
For standalone content that isn't part of a cohesive module collection, follow this structure:
1. **Module Configuration**
- Create a folder with a `module.yaml` file (similar to custom modules)
- Add the property `unitary: true` in the module.yaml
- The `unitary: true` property indicates this is a collection of potentially unrelated items that don't depend on each other
- Any content you add to this folder should still be nested under workflows and agents - but the key with stand alone content is they do not rely on each other.
- Agents do not reference other workflows even if stored in a unitary:true module. But unitary Agents can have their own workflows in their sidecar, or reference workflows as requirements from other modules - with a process known as workflow vendoring. Keep in mind, this will require that the workflow referenced from the other module would need to be available for the end user to install, so its recommended to only vendor workflows from the core module, or official bmm modules (See [Workflow Vendoring, Customization, and Inheritance](workflow-vendoring-customization-inheritance.md)).
2. **Folder Structure**
Organize content in specific named folders:
```
module-name/
module.yaml # Contains unitary: true
agents/
workflows/
templates/
tools/
tasks/
prompts/
```
3. **Individual Item Organization**
Each item should have its own subfolder:
```text
my-custom-stuff/
module.yaml
agents/
larry/larry.agent.md
curly/curly.agent.md
moe/moe.agent.md
moe/moe-sidecar/memories.csv
```
**Future Feature:** Unitary modules will support selective installation, allowing users to pick and choose which specific items to install.
**Note:** Documentation explaining the distinctions between these content types and their specific use cases will be available soon.
## Installation Process
### Prerequisites
Ensure your content follows the proper conventions and includes a `module.yaml` file (only one per top-level folder).
### New Project Installation
When setting up a new BMAD project:
1. The installer will prompt: `Would you like to install a local custom module (this includes custom agents and workflows also)? (y/N)`
2. Select 'y' to specify the path to your module folder containing `module.yaml`
### Existing Project Modification
To add custom content to an existing BMAD project:
1. Run the installer against your project location
2. Select `Modify BMAD Installation`
3. Choose the option to add, modify, or update custom modules
### Upcoming Features
- **Unitary Module Selection:** For modules with `type: unitary` (instead of `type: module`), you'll be able to select specific items to install
- **Add-on Module Dependencies:** The installer will verify and install dependencies for add-on modules automatically
## Quick Updates
When updates to BMAD Core or core modules (BMM, CIS, etc.) become available, the quick update process will:
1. Apply available updates to core modules
2. Recompile all agents with customizations from the `_config/agents` folder
3. Retain your custom content from a cached location
4. Preserve your existing configurations and customizations
This means you don't need to keep the source module files locally. When updates are available, simply point to the updated module location during the update process.
## Important Considerations
### Module Naming Conflicts
When installing unofficial modules, ensure unique identification to avoid conflicts:
1. **Module Codes:** Each module must have a unique code (e.g., don't use `bmm` for custom modules)
2. **Module Names:** Avoid using names that conflict with existing modules
3. **Multiple Custom Modules:** If creating multiple custom modules, use distinct codes for each
**Examples of conflicts to avoid:**
- Don't create a custom module with code `bmm` (already used by BMad Method)
- Don't name multiple custom modules with the same code like `mca`
### Best Practices
- Use descriptive, unique codes for your modules
- Document any dependencies your custom modules have
- Test custom modules in isolation before sharing
- Consider version numbering for your custom content to track updates

121
docs/modules/bmb-bmad-builder/custom-content.md Normal file
View File

@@ -0,0 +1,121 @@
# Custom Content
BMAD supports several categories of officially supported custom content that extend the platform's capabilities. Custom content can be created manually or with the recommended assistance of the BMad Builder (BoMB) Module. The BoMB Agents provides workflows and expertise to plan and build any custom content you can imagine.
This flexibility transforms the platform beyond its current capabilities, enabling:
- Extensions and add-ons for existing modules (BMad Method, Creative Intelligence Suite)
- Completely new modules, workflows, templates, and agents outside software engineering
- Professional services tools
- Entertainment and educational content
- Science and engineering workflows
- Productivity and self-help solutions
- Role-specific augmentation for virtually any profession
## Categories
- [Custom Content](#custom-content)
- [Categories](#categories)
- [Custom Stand Alone Modules](#custom-stand-alone-modules)
- [Custom Add On Modules](#custom-add-on-modules)
- [Custom Global Modules](#custom-global-modules)
- [Custom Agents](#custom-agents)
- [BMad Tiny Agents](#bmad-tiny-agents)
- [Simple and Expert Agents](#simple-and-expert-agents)
- [Custom Workflows](#custom-workflows)
## Custom Stand Alone Modules
Custom modules range from simple collections of related agents, workflows, and tools designed to work independently, to complex, expansive systems like the BMad Method or even larger applications.
Custom modules are [installable](./custom-content-installation.md) using the standard BMAD method and support advanced features:
- Optional user information collection during installation/updates
- Versioning and upgrade paths
- Custom installer functions with IDE-specific post-installation handling (custom hooks, subagents, or vendor-specific tools)
- Ability to bundle specific tools such as MCP, skills, execution libraries, and code
## Custom Add On Modules
Custom Add On Modules contain specific agents, tools, or workflows that expand, modify, or customize another module but cannot exist or install independently. These add-ons provide enhanced functionality while leveraging the base module's existing capabilities.
Examples include:
- Alternative implementation workflows for BMad Method agents
- Framework-specific support for particular use cases
- Game development expansions that add new genre-specific capabilities without reinventing existing functionality
Add on modules can include:
- Custom agents with awareness of the target module
- Access to existing module workflows
- Tool-specific features such as rulesets, hooks, subprocess prompts, subagents, and more
## Custom Global Modules
Similar to Custom Stand Alone Modules, but designed to add functionality that applies across all installed content. These modules provide cross-cutting capabilities that enhance the entire BMAD ecosystem.
Examples include:
- The current TTS (Text-to-Speech) functionality for Claude, which will soon be converted to a global module
- The core module, which is always installed and provides all agents with party mode and advanced elicitation capabilities
- Installation and update tools that work with any BMAD method configuration
Upcoming standards will document best practices for building global content that affects installed modules through:
- Custom content injections
- Agent customization auto-injection
- Tooling installers
## Custom Agents
Custom Agents can be designed and built for various use cases, from one-off specialized agents to more generic standalone solutions.
### BMad Tiny Agents
Personal agents designed for highly specific needs that may not be suitable for sharing. For example, a team management agent living in an Obsidian vault that helps with:
- Team coordination and management
- Understanding team details and requirements
- Tracking specific tasks with designated tools
These are simple, standalone files that can be scoped to focus on specific data or paths when integrated into an information vault or repository.
### Simple and Expert Agents
The distinction between simple and expert agents lies in their structure:
**Simple Agent:**
- Single file containing all prompts and configuration
- Self-contained and straightforward
**Expert Agent:**
- Similar to simple agents but includes a sidecar folder
- Sidecar folder contains additional resources: custom prompt files, scripts, templates, and memory files
- When installed, the sidecar folder (`[agentname]-sidecar`) is placed in the user memory location
- has metadata type: expert
The key distinction is the presence of a sidecar folder. As web and consumer agent tools evolve to support common memory mechanisms, storage formats, and MCP, the writable memory files will adapt to support these evolving standards.
Custom agents can be:
- Used within custom modules
- Designed as standalone tools
- Integrated with existing workflows and systems, if this is to be the case, should also include a module: <module name> if a specific module is intended for it to require working with
## Custom Workflows
Workflows are powerful, progressively loading sequence engines capable of performing tasks ranging from simple to complex, including:
- User engagements
- Business processes
- Content generation (code, documentation, or other output formats)
A custom workflow created outside of a larger module can still be distributed and used without associated agents through:
- Slash commands
- Manual command/prompt execution when supported by tools
At its core, a custom workflow is a single or series of prompts designed to achieve a specific outcome.

55
docs/modules/bmb-bmad-builder/index.md Normal file
View File

@@ -0,0 +1,55 @@
# BMB Module Documentation
Reference documentation for building BMAD agents and workflows.
## Agent Architecture
Comprehensive guides for each agent type (choose based on use case):
- [Understanding Agent Types](./understanding-agent-types.md) - **START HERE** - Architecture vs capability, "The Same Agent, Three Ways"
- [Simple Agent Architecture](./simple-agent-architecture.md) - Self-contained, optimized, personality-driven
- [Expert Agent Architecture](./expert-agent-architecture.md) - Memory, sidecar files, domain restrictions
- Module Agent Architecture _(TODO)_ - Workflow integration, professional tools
## Agent Design Patterns
- [Agent Menu Patterns](./agent-menu-patterns.md) - Menu handlers, triggers, prompts, organization
- [Agent Compilation](./agent-compilation.md) - What compiler auto-injects (AVOID DUPLICATION)
## Reference Examples
Production-ready examples in [bmb/reference/agents/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents):
**Simple Agents** ([simple-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/simple-examples))
- [commit-poet.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/simple-examples/commit-poet.agent.yaml) - Commit message artisan with style customization
**Expert Agents** ([expert-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/expert-examples))
- [journal-keeper/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/expert-examples/journal-keeper) - Personal journal companion with memory and pattern recognition
**Module Agents** ([module-examples/](https://github.com/bmad-code-org/BMAD-METHOD/tree/main/src/modules/bmb/reference/agents/module-examples))
- [security-engineer.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/module-examples/security-engineer.agent.yaml) - BMM security specialist with threat modeling
- [trend-analyst.agent.yaml](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/agents/module-examples/trend-analyst.agent.yaml) - CIS trend intelligence expert
## Installation Guide
For installing standalone simple and expert agents, see:
- [Custom Agent Installation](/docs/modules/bmb-bmad-builder/custom-content-installation.md)
## Key Concepts
### YAML to XML Compilation
Agents are authored in YAML with Handlebars templating. The compiler auto-injects:
1. **Frontmatter** - Name and description from metadata
2. **Activation Block** - Steps, menu handlers, rules (YOU don't write this)
3. **Menu Enhancement** - `*help` and `*exit` commands added automatically
4. **Trigger Prefixing** - Your triggers auto-prefixed with `*`
**Critical:** See [Agent Compilation](./agent-compilation.md) to avoid duplicating auto-injected content.
Source: `tools/cli/lib/agent/compiler.js`

149
docs/modules/cis-creative-intelligence-suite/index.md Normal file
View File

@@ -0,0 +1,149 @@
# CIS - Creative Intelligence Suite
AI-powered creative facilitation transforming strategic thinking through expert coaching across five specialized domains.
## Table of Contents
- [Core Capabilities](#core-capabilities)
- [Specialized Agents](#specialized-agents)
- [Interactive Workflows](#interactive-workflows)
- [Quick Start](#quick-start)
- [Key Differentiators](#key-differentiators)
- [Configuration](#configuration)
## Core Capabilities
CIS provides structured creative methodologies through distinctive agent personas who act as master facilitators, drawing out insights through strategic questioning rather than generating solutions directly.
## Specialized Agents
- **Carson** - Brainstorming Specialist (energetic facilitator)
- **Maya** - Design Thinking Maestro (jazz-like improviser)
- **Dr. Quinn** - Problem Solver (detective-scientist hybrid)
- **Victor** - Innovation Oracle (bold strategic precision)
- **Sophia** - Master Storyteller (whimsical narrator)
## Interactive Workflows
[View all workflows →](../workflows/README.md)
**5 Workflows** with **150+ Creative Techniques:**
### Brainstorming
36 techniques across 7 categories for ideation
- Divergent/convergent thinking
- Lateral connections
- Forced associations
### Design Thinking
Complete 5-phase human-centered process
- Empathize → Define → Ideate → Prototype → Test
- User journey mapping
- Rapid iteration
### Problem Solving
Systematic root cause analysis
- 5 Whys, Fishbone diagrams
- Solution generation
- Impact assessment
### Innovation Strategy
Business model disruption
- Blue Ocean Strategy
- Jobs-to-be-Done
- Disruptive innovation patterns
### Storytelling
25 narrative frameworks
- Hero's Journey
- Story circles
- Compelling pitch structures
## Quick Start
### Direct Workflow
```bash
# Start interactive session
workflow brainstorming
# With context document
workflow design-thinking --data /path/to/context.md
```
### Agent-Facilitated
```bash
# Load agent
agent cis/brainstorming-coach
# Start workflow
> *brainstorm
```
## Key Differentiators
- **Facilitation Over Generation** - Guides discovery through questions
- **Energy-Aware Sessions** - Adapts to engagement levels
- **Context Integration** - Domain-specific guidance support
- **Persona-Driven** - Unique communication styles
- **Rich Method Libraries** - 150+ proven techniques
## Configuration
Edit `/_bmad/cis/config.yaml`:
```yaml
output_folder: ./creative-outputs
user_name: Your Name
communication_language: english
```
## Module Structure
```
cis/
├── agents/ # 5 specialized facilitators
├── workflows/ # 5 interactive processes
│ ├── brainstorming/
│ ├── design-thinking/
│ ├── innovation-strategy/
│ ├── problem-solving/
│ └── storytelling/
├── tasks/ # Supporting operations
└── teams/ # Agent collaborations
```
## Integration Points
CIS workflows integrate with:
- **BMM** - Powers project brainstorming
- **BMB** - Creative module design
- **Custom Modules** - Shared creative resource
## Best Practices
1. **Set clear objectives** before starting sessions
2. **Provide context documents** for domain relevance
3. **Trust the process** - Let facilitation guide you
4. **Take breaks** when energy flags
5. **Document insights** as they emerge
## Related Documentation
- **[BMM Documentation](../../bmm/docs/index.md)** - Core BMad Method documentation
---
Part of BMad Method v6.0 - Transform creative potential through expert AI facilitation.

105
docs/modules/core/advanced-elicitation.md Normal file
View File

@@ -0,0 +1,105 @@
# Advanced Elicitation
**Push the LLM to rethink its work through 50+ reasoning methods—essentially, LLM brainstorming.**
Advanced Elicitation is the inverse of Brainstorming. Instead of pulling ideas out of you, the LLM applies sophisticated reasoning techniques to re-examine and enhance content it has just generated. It's the LLM brainstorming with itself to find better approaches, uncover hidden issues, and discover improvements it missed on the first pass.
---
## When to Use It
- After a workflow generates a section of content and you want to explore alternatives
- When the LLM's initial output seems adequate but you suspect there's more depth available
- For high-stakes content where multiple perspectives would strengthen the result
- To stress-test assumptions, explore edge cases, or find weaknesses in generated plans
- When you want the LLM to "think again" but with structured reasoning methods
---
## How It Works
### 1. Context Analysis
The LLM analyzes the current content, understanding its type, complexity, stakeholder needs, risk level, and creative potential.
### 2. Smart Method Selection
Based on context, 5 methods are intelligently selected from a library of 50+ techniques and presented to you:
| Option | Description |
| ----------------- | ---------------------------------------- |
| **1-5** | Apply the selected method to the content |
| **[r] Reshuffle** | Get 5 new methods selected randomly |
| **[a] List All** | Browse the complete method library |
| **[x] Proceed** | Continue with enhanced content |
### 3. Method Execution & Iteration
- The selected method is applied to the current content
- Improvements are shown for your review
- You choose whether to apply changes or discard them
- The menu re-appears for additional elicitations
- Each method builds on previous enhancements
### 4. Party Mode Integration (Optional)
If Party Mode is active, BMAD agents participate randomly in the elicitation process, adding their unique perspectives to the methods.
---
## Method Categories
| Category | Focus | Example Methods |
| ----------------- | ----------------------------------- | -------------------------------------------------------------- |
| **Core** | Foundational reasoning techniques | First Principles Analysis, 5 Whys, Socratic Questioning |
| **Collaboration** | Multiple perspectives and synthesis | Stakeholder Round Table, Expert Panel Review, Debate Club |
| **Advanced** | Complex reasoning frameworks | Tree of Thoughts, Graph of Thoughts, Self-Consistency |
| **Competitive** | Adversarial stress-testing | Red Team vs Blue Team, Shark Tank Pitch, Code Review Gauntlet |
| **Technical** | Architecture and code quality | Decision Records, Rubber Duck Debugging, Algorithm Olympics |
| **Creative** | Innovation and lateral thinking | SCAMPER, Reverse Engineering, Random Input Stimulus |
| **Research** | Evidence-based analysis | Literature Review Personas, Thesis Defense, Comparative Matrix |
| **Risk** | Risk identification and mitigation | Pre-mortem Analysis, Failure Mode Analysis, Chaos Monkey |
| **Learning** | Understanding verification | Feynman Technique, Active Recall Testing |
| **Philosophical** | Conceptual clarity | Occam's Razor, Ethical Dilemmas |
| **Retrospective** | Reflection and lessons | Hindsight Reflection, Lessons Learned Extraction |
---
## Key Features
- **50+ reasoning methods** — Spanning core logic to advanced multi-step reasoning frameworks
- **Smart context selection** — Methods chosen based on content type, complexity, and stakeholder needs
- **Iterative enhancement** — Each method builds on previous improvements
- **User control** — Accept or discard each enhancement before proceeding
- **Party Mode integration** — Agents can participate when Party Mode is active
---
## Workflow Integration
Advanced Elicitation is a core workflow designed to be invoked by other workflows during content generation:
| Parameter | Description |
| ---------------------- | --------------------------------------------------------- |
| **Content to enhance** | The current section content that was just generated |
| **Context type** | The kind of content being created (spec, code, doc, etc.) |
| **Enhancement goals** | What the calling workflow wants to improve |
### Integration Flow
When called from a workflow:
1. Receives the current section content that was just generated
2. Applies elicitation methods iteratively to enhance that content
3. Returns the enhanced version when user selects 'x' to proceed
4. The enhanced content replaces the original section in the output document
### Example
A specification generation workflow could invoke Advanced Elicitation after producing each major section (requirements, architecture, implementation plan). The workflow would pass the generated section, and Advanced Elicitation would offer methods like "Stakeholder Round Table" to gather diverse perspectives on requirements, or "Red Team vs Blue Team" to stress-test the architecture for vulnerabilities.
---
## Advanced Elicitation vs. Brainstorming
| | **Advanced Elicitation** | **Brainstorming** |
| ------------ | ------------------------------------------------- | --------------------------------------------- |
| **Source** | LLM generates ideas through structured reasoning | User provides ideas, AI coaches them out |
| **Purpose** | Rethink and improve LLM's own output | Unlock user's creativity |
| **Methods** | 50+ reasoning and analysis techniques | 60+ ideation and creativity techniques |
| **Best for** | Enhancing generated content, finding alternatives | Breaking through blocks, generating new ideas |

100
docs/modules/core/brainstorming.md Normal file
View File

@@ -0,0 +1,100 @@
# Brainstorming
**Facilitate structured creative sessions using 60+ proven ideation techniques.**
The Brainstorming workflow is an interactive facilitation system that helps you unlock your own creativity. The AI acts as coach, guide, and creative partner—using proven techniques to draw out ideas and insights that are already within you.
**Important:** Every idea comes from you. The workflow creates the conditions for your best thinking to emerge through guided exploration, but you are the source.
---
## When to Use It
- Breaking through creative blocks on a specific challenge
- Generating innovative ideas for products, features, or solutions
- Exploring a problem from completely new angles
- Systematically developing ideas from raw concepts to actionable plans
- Team ideation (with collaborative techniques) or personal creative exploration
---
## How It Works
### 1. Session Setup
Define your topic, goals, and any constraints.
### 2. Choose Your Approach
| Approach | Description |
|----------|-------------|
| **User-Selected** | Browse the full technique library and pick what appeals to you |
| **AI-Recommended** | Get customized technique suggestions based on your goals |
| **Random Selection** | Discover unexpected methods through serendipitous technique combinations |
| **Progressive Flow** | Journey systematically from expansive exploration to focused action planning |
### 3. Interactive Facilitation
Work through techniques with true collaborative coaching. The AI asks probing questions, builds on your ideas, and helps you think deeper—but your ideas are the source.
### 4. Idea Organization
All your generated ideas are organized into themes and prioritized.
### 5. Action Planning
Top ideas get concrete next steps, resource requirements, and success metrics.
---
## What You Get
A comprehensive session document that captures the entire journey:
- Topic, goals, and session parameters
- Each technique used and how it was applied
- Your contributions and the ideas you generated
- Thematic organization connecting related insights
- Prioritized ideas with action plans
- Session highlights and key breakthroughs
This document becomes a permanent record of your creative process—valuable for future reference, sharing with stakeholders, or continuing the session later.
---
## Technique Categories
| Category | Focus |
|----------|-------|
| **Collaborative** | Team dynamics and inclusive participation |
| **Creative** | Breakthrough thinking and paradigm shifts |
| **Deep** | Root cause analysis and strategic insight |
| **Structured** | Organized frameworks and systematic exploration |
| **Theatrical** | Playful, radical perspectives |
| **Wild** | Boundary-pushing, extreme thinking |
| **Biomimetic** | Nature-inspired solutions |
| **Quantum** | Quantum principles for innovation |
| **Cultural** | Traditional knowledge and cross-cultural approaches |
| **Introspective Delight** | Inner wisdom and authentic exploration |
---
## Key Features
- **Interactive coaching** — Pulls ideas *out* of you, doesn't generate them for you
- **On-demand loading** — Techniques loaded from a comprehensive library as needed
- **Session preservation** — Every step, insight, and action plan is documented
- **Continuation support** — Pause sessions and return later, or extend with additional techniques
---
## Workflow Integration
Brainstorming is a core workflow designed to be invoked and configured by other modules. When called from another workflow, it accepts contextual parameters:
| Parameter | Description |
|-----------|-------------|
| **Topic focus** | What the brainstorming should help discover or solve |
| **Guardrails** | Constraints, boundaries, or must-avoid areas |
| **Output goals** | What the final output needs to accomplish for the calling workflow |
| **Context files** | Project-specific guidance to inform technique selection |
### Example
When creating a new module in the BMad Builder workflow, Brainstorming can be invoked with guardrails around the module's purpose and a goal to discover key features, user needs, or architectural considerations. The session becomes focused on producing exactly what the module creation workflow needs.

64
docs/modules/core/core-tasks.md Normal file
View File

@@ -0,0 +1,64 @@
# Core Tasks
Core Tasks are reusable task definitions that can be invoked by any BMAD module, workflow, or agent. These tasks provide standardized functionality for common operations.
## Table of Contents
- [Index Docs](#index-docs) — Generate directory index files
- [Adversarial Review](#adversarial-review-general) — Critical content review
- [Shard Document](#shard-document) — Split large documents into sections
---
## Index Docs
**Generates or updates an index.md file documenting all documents in a specified directory.**
This task scans a target directory, reads file contents to understand their purpose, and creates a well-organized index with accurate descriptions. Files are grouped by type, purpose, or subdirectory, and descriptions are generated from actual content rather than guessing from filenames.
**Use it when:** You need to create navigable documentation for a folder of markdown files, or you want to maintain an updated index as content evolves.
**How it works:**
1. Scan the target directory for files and subdirectories
2. Group content by type, purpose, or location
3. Read each file to generate brief (3-10 word) descriptions based on actual content
4. Create or update index.md with organized listings using relative paths
**Output format:** A markdown index with sections for Files and Subdirectories, each entry containing a relative link and description.
---
## Adversarial Review (General)
**Performs a cynical, skeptical review of any content to identify issues and improvement opportunities.**
This task applies adversarial thinking to content review—approaching the material with the assumption that problems exist. It's designed to find what's missing, not just what's wrong, and produces at least ten specific findings. The reviewer adopts a professional but skeptical tone, looking for gaps, inconsistencies, oversights, and areas that need clarification.
**Use it when:** You need a critical eye on code diffs, specifications, user stories, documentation, or any artifact before finalizing. It's particularly valuable before merging code, releasing documentation, or considering a specification complete.
**How it works:**
1. Load the content to review (diff, branch, uncommitted changes, document, etc.)
2. Perform adversarial analysis with extreme skepticism—assume problems exist
3. Find at least ten issues to fix or improve
4. Output findings as a markdown list
**Note:** This task is designed to run in a separate subagent/process with read access to the project but no prior context, ensuring an unbiased review.
---
## Shard Document
**Splits large markdown documents into smaller, organized files based on level 2 (##) sections.**
Uses the `@kayvan/markdown-tree-parser` tool to automatically break down large documents into a folder structure. Each level 2 heading becomes a separate file, and an index.md is generated to tie everything together. This makes large documents more maintainable and allows for easier navigation and updates to individual sections.
**Use it when:** A markdown file has grown too large to effectively work with, or you want to break a monolithic document into manageable sections that can be edited independently.
**How it works:**
1. Confirm source document path and verify it's a markdown file
2. Determine destination folder (defaults to same location as source, folder named after document)
3. Execute the sharding command using npx @kayvan/markdown-tree-parser
4. Verify output files and index.md were created
5. Handle the original document—delete, move to archive, or keep with warning
**Handling the original:** After sharding, the task prompts you to delete, archive, or keep the original document. Deleting or archiving is recommended to avoid confusion and ensure updates happen in the sharded files only.

30
docs/modules/core/core-workflows.md Normal file
View File

@@ -0,0 +1,30 @@
# Core Workflows
Core Workflows are domain-agnostic workflows that can be utilized by any BMAD-compliant module, workflow, or agent. These workflows are installed by default and available at any time.
## Available Core Workflows
### [Party Mode](party-mode.md)
Orchestrate dynamic multi-agent conversations with your entire BMAD team. Engage with multiple specialized perspectives simultaneously—each agent maintaining their unique personality, expertise, and communication style.
### [Brainstorming](brainstorming.md)
Facilitate structured creative sessions using 60+ proven ideation techniques. The AI acts as coach and guide, using proven creativity methods to draw out ideas and insights that are already within you.
### [Advanced Elicitation](advanced-elicitation.md)
Push the LLM to rethink its work through 50+ reasoning methods—the inverse of brainstorming. The LLM applies sophisticated techniques to re-examine and enhance content it has just generated, essentially "LLM brainstorming" to find better approaches and uncover improvements.
---
## Workflow Integration
Core Workflows are designed to be invoked and configured by other modules. When called from another workflow, they accept contextual parameters to customize the session:
- **Topic focus** — Direct the session toward a specific domain or question
- **Additional personas** (Party Mode) — Inject expert agents into the roster at runtime
- **Guardrails** (Brainstorming) — Set constraints and boundaries for ideation
- **Output goals** — Define what the final output needs to accomplish
This allows modules to leverage these workflows' capabilities while maintaining focus on their specific domain and objectives.

11
docs/modules/core/global-core-config.md Normal file
View File

@@ -0,0 +1,11 @@
# Core Module Global Inheritable Config
The Core Modules module.yaml file defines configuration values that are useful and unique for all other modules to utilize, and by default all other modules installed will clone the values defined in the core module yaml.config into their own. It is possible for other modules to override these values, but the general intent it to accept the core module values and define their own values as needed, or extend the core values.
Currently, the core module.yaml config will define (asking the user upon installation, and recording to the core module config.yaml):
- `user_name`: string (defaults to the system defined user name)
- `communication_language`: string (defaults to english)
- `document_output_language`: string (defaults to english)
- `output_folder`: string (default `_bmad-output`)
An example of extending one of these values, in the BMad Method module.yaml it defines a planning_artifacts config, which will default to `default: "{output_folder}/planning-artifacts"` thus whatever the output_folder will be, this extended versions default will use the value from this core module and append a new folder onto it. The user can choose to replace this without utilizing the output_folder from the core if they so chose.

15
docs/modules/core/index.md Normal file
View File

@@ -0,0 +1,15 @@
# Core Module
The Core Module is installed with all installations of BMAD modules and provides common functionality that any module, workflow, or agent can take advantage of.
## Core Module Components
- **[Global Core Config](global-core-config.md)** — Inheritable configuration that impacts all modules and custom content
- **[Core Workflows](core-workflows.md)** — Domain-agnostic workflows usable by any module
- [Party Mode](party-mode.md) — Multi-agent conversation orchestration
- [Brainstorming](brainstorming.md) — Structured creative sessions with 60+ techniques
- [Advanced Elicitation](advanced-elicitation.md) — LLM rethinking with 50+ reasoning methods
- **[Core Tasks](core-tasks.md)** — Common tasks available across modules
- [Index Docs](core-tasks.md#index-docs) — Generate directory index files
- [Adversarial Review](core-tasks.md#adversarial-review-general) — Critical content review
- [Shard Document](core-tasks.md#shard-document) — Split large documents into sections

50
docs/modules/core/party-mode.md Normal file
View File

@@ -0,0 +1,50 @@
# Party Mode
**Orchestrate dynamic multi-agent conversations with your entire BMAD team.**
Party Mode brings together all your installed BMAD agents for collaborative discussions. Instead of working with a single agent, you can engage with multiple specialized perspectives simultaneously—each agent maintaining their unique personality, expertise, and communication style.
---
## When to Use It
- Exploring complex topics that would benefit from diverse expert perspectives
- Brainstorming with agents who can build on each other's ideas
- Getting a comprehensive view across multiple domains (technical, business, creative, strategic)
- Enjoying dynamic, agent-to-agent conversations where experts challenge and complement each other
---
## How It Works
1. Party Mode loads your complete agent roster and introduces the available team members
2. You present a topic or question
3. The facilitator intelligently selects 2-3 most relevant agents based on expertise needed
4. Agents respond in character, can reference each other, and engage in natural cross-talk
5. The conversation continues until you choose to exit
---
## Key Features
- **Intelligent agent selection** — The system analyzes your topic and selects the most relevant agents based on their expertise, capabilities, and principles
- **Authentic personalities** — Each agent maintains their unique voice, communication style, and domain knowledge throughout the conversation
- **Natural cross-talk** — Agents can reference each other, build on previous points, ask questions, and even respectfully disagree
- **Optional TTS integration** — Each agent response can be read aloud with voice configurations matching their personalities
- **Graceful exit** — Sessions conclude with personalized farewells from participating agents
---
## Workflow Integration
Party Mode is a core workflow designed to be invoked and configured by other modules. When called from another workflow, it accepts contextual parameters:
| Parameter | Description |
|-----------|-------------|
| **Topic focus** | Prebias the discussion toward a specific domain or question |
| **Additional personas** | Inject expert agents into the roster at runtime for specialized perspectives |
| **Participation constraints** | Limit which agents can contribute based on relevance |
### Example
A medical module workflow could invoke Party Mode with expert doctor personas added to the roster, and the conversation pre-focused on a specific diagnosis or treatment decision. The agents would then discuss the medical case with appropriate domain expertise while maintaining their distinct personalities and perspectives.