ros/BMAD-METHOD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

schema standardization and bmad ide orchesatrtor can do anything

Browse Source
This commit is contained in:
Brian Madison
2025-06-10 07:17:19 -05:00
parent 810a39658a
commit 0d59c686dd
74 changed files with 2087 additions and 58486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
bmad-core/tasks/brownfield-create-story.md
View File

@@ -8,7 +8,7 @@ Create a single user story for very small brownfield enhancements that can be co
**Use this task when:**
- The enhancement can be completed in a single story (2-4 hours of focused work)
- The enhancement can be completed in a single story
- No new architecture or significant design is required
- The change follows existing patterns exactly
- Integration is straightforward with minimal risk
@@ -128,33 +128,6 @@ Before finalizing the story, confirm:
- [ ] Success criteria are testable
- [ ] Rollback approach is simple
### 5. Handoff to Developer
Once the story is validated, provide this handoff to the Developer:
---
**Developer Handoff:**
"This is a focused brownfield story for an existing {{technology}} system.
**Integration Context:**
- Existing component: {{component/system}}
- Pattern to follow: {{existing pattern}}
- Key constraint: {{main constraint}}
**Critical Requirements:**
- Follow the existing {{pattern}} pattern exactly
- Ensure {{existing functionality}} continues working
- Test integration with {{specific component}}
**Verification:**
Please verify existing {{relevant functionality}} remains unchanged after implementation."
---
## Success Criteria
The story creation is successful when:

233
bmad-core/tasks/create-agent.md
View File

@@ -1,137 +1,196 @@
# Create Agent Task
This task helps you create a new BMAD agent for web platforms (Gemini, ChatGPT, etc.).
This task guides you through creating a new BMAD agent that conforms to the agent schema and integrates with existing teams and workflows.
**Note for User-Created Agents**: If you're creating a custom agent for your own use (not part of the core BMAD system), prefix the agent ID with a period (e.g., `.data-analyst`) to ensure it's gitignored and won't conflict with repository updates.
**Note for User-Created Agents**: If creating a custom agent for your own use (not part of the core BMAD system), prefix the agent ID with a period (e.g., `.data-analyst`) to ensure it's gitignored and won't conflict with repository updates.
## Prerequisites
1. Load and understand the agent schema: `/bmad-core/schemas/agent-schema.yml`
2. Review existing agents in `/agents/` to understand naming patterns
3. Check existing teams in `/bmad-core/agent-teams/` for integration opportunities
4. Review workflows in `/bmad-core/workflows/` to understand where the agent might fit
## Process
Follow these steps to create a new agent:
### 1. Gather Core Agent Information
### 1. Gather Basic Information
Based on the agent schema's required fields, collect:
Ask the user for:
- **Agent ID**: A short, lowercase identifier (e.g., `data-analyst`, `security-expert`)
- **Agent Name**: The character name (e.g., "Elena", "Marcus")
- **Title**: Professional title (e.g., "Data Analyst", "Security Expert")
- **Description**: A brief description of the agent's role and primary focus
- **Agent ID**: Following the schema pattern `^[a-z][a-z0-9-]*$` (e.g., `data-analyst`, `security-expert`)
- For user agents: prefix with period (`.data-analyst`)
- **Character Name**: Following pattern `^[A-Z][a-z]+$` (e.g., "Elena", "Marcus")
- **Professional Title**: 5-50 characters (e.g., "Data Analyst", "Security Expert")
- **Description**: 20-300 characters describing the agent's main goal and purpose
### 2. Define Personality and Expertise
Ask about:
Create a comprehensive persona by exploring:
- **Personality traits**: How should this agent behave? (professional, friendly, detail-oriented, etc.)
- **Communication style**: How do they speak? (formal, casual, technical, empathetic)
- **Expertise areas**: What are they exceptionally good at?
- **Years of experience**: How senior are they in their role?
- **Motivations**: What drives them to excel?
- **Identity**: Extended description of specialization (20+ characters)
- **Focus**: Primary objectives and responsibilities (20+ characters)
- **Style**: Communication and approach characteristics (20+ characters)
- **Core Principles**: At least 3 principles including the required "Numbered Options Protocol"
- **Experience Level**: Years in field and depth of expertise
- **Working Approach**: How they solve problems and deliver value
### 3. Identify Capabilities
### 3. Identify Dependencies
Determine what the agent can do:
Analyze what resources the agent needs:
- **Existing tasks**: Which existing tasks from `/bmad-core/tasks/` should this agent know?
- **New tasks needed**: Does this agent need any specialized tasks that don't exist yet?
- **Templates used**: Which document templates will this agent work with?
- **Checklists**: Which quality checklists apply to this agent's work?
#### Tasks (from `/bmad-core/tasks/`)
- Review available tasks and identify which apply
- Common tasks most agents need:
- `advanced-elicitation` (for conversational depth)
- `create-doc-from-template` (if they create documents)
- `execute-checklist` (if they validate work)
- Identify any new specialized tasks needed
#### Templates (from `/bmad-core/templates/`)
- Which document templates will this agent create/use?
- Match template pattern: `^[a-z][a-z0-9-]*-tmpl$`
#### Checklists (from `/bmad-core/checklists/`)
- Which quality checklists apply to their work?
- Match checklist pattern: `^[a-z][a-z0-9-]*-checklist$`
#### Data Files (from `/bmad-core/data/`)
- `bmad-kb` (if they need BMAD methodology knowledge)
- `technical-preferences` (if they make technical decisions)
- Other specialized data files
### 4. Create the Persona File
Create `/bmad-core/personas/{agent-id}.md` with this structure:
(For user-created agents, use `/bmad-core/personas/.{agent-id}.md`)
Create `/bmad-core/personas/{agent-id}.md` following the schema-required structure:
(For user agents: `/bmad-core/personas/.{agent-id}.md`)
```markdown
# {Agent Name} - {Title}
# Role: {Title} Agent
## Character Profile
## Persona
**Name:** {Agent Name}
**Title:** {Title}
**Experience:** {Years} years in {field}
- Role: {Descriptive Role Statement}
- Style: {Communication style and approach}
## Personality
## Core {Title} Principles (Always Active)
{Describe personality traits, communication style, and approach to work}
- **{Principle Name}:** {Detailed explanation}
- **{Principle Name}:** {Detailed explanation}
- **Numbered Options Protocol:** When presenting multiple options, always use numbered lists for easy selection
[Add more principles as needed]
## Core Expertise
## Critical Start Up Operating Instructions
{List main areas of expertise and specialization}
- Let the User Know what Tasks you can perform in a numbered list for user selection.
- Execute the Full Tasks as Selected. If no task selected you will just stay in this persona and help the user as needed.
- When conversing with the user and providing advice or multiple options, always present them as numbered lists for easy selection. When appropriate, also offer `advanced-elicitation` options during conversations.
## Responsibilities
{List key responsibilities in bullet points}
## Working Style
{Describe how they approach problems, collaborate, and deliver results}
## Motivations
{What drives them to excel in their role}
## Catchphrases
{Optional: Any signature phrases or ways of speaking}
[Add any agent-specific sections like Expertise, Workflow, etc.]
```
### 5. Create the Agent Configuration
Create `/agents/{agent-id}.yml` with this structure:
(For user-created agents, use `/agents/.{agent-id}.yml`)
Create `/agents/{agent-id}.yml` conforming to the schema:
(For user agents: `/agents/.{agent-id}.yml`)
```yaml
agent:
id: { agent-id }
name: { Agent Name }
title: { Title }
description: >-
{Full description of the agent's role and value}
persona: { agent-id }
customize: >-
{Any specific behavioral customizations}
name: {Character Name}
id: {agent-id}
title: {Professional Title}
description: {20-300 character description}
persona: bmad-core/personas/{agent-id}.md
customize: "" # or specific customizations
dependencies:
tasks:
- { list of task IDs }
- {task-id} # from identified tasks
templates:
- { list of template IDs }
- {template-id} # from identified templates
checklists:
- { list of checklist IDs }
- {checklist-id} # from identified checklists
data:
- { list of data file IDs }
- {data-id} # from identified data files
utils:
- template-format
- {util-id} # typically empty or specific utils
```
### 6. Create Any New Tasks
### 6. Team Integration Analysis
If new tasks were identified, create them in `/bmad-core/tasks/{task-name}.md`
(For user-created tasks, use `/bmad-core/tasks/.{task-name}.md`)
Review existing teams and suggest integration:
### 7. Test and Validate
1. **Load team configurations** from `/bmad-core/agent-teams/`
2. **Analyze fit** based on:
- Agent's role and expertise
- Team's description and purpose
- Existing agents in the team
- Workflows the team supports
1. Run `npm run validate` to check configuration
2. Run `npm run build:agent -a {agent-id}` to build the agent
3. Review the generated output in `/dist/agents/{agent-id}.txt`
3. **Suggest teams** where this agent would add value:
- For technical agents → suggest technical teams
- For UX/design agents → suggest teams with UI workflows
- For planning agents → suggest all teams
## Example Questions to Ask
4. **Offer to update** team configurations:
```yaml
agents:
- bmad
- {existing-agents}
- {new-agent-id} # Add here
```
1. "What will this agent be called? (ID like 'data-analyst')"
2. "What's their character name? (like 'Elena')"
3. "What's their professional title?"
4. "Describe their main role in 2-3 sentences."
5. "What personality traits should they have?"
6. "How many years of experience do they have?"
7. "What existing tasks should they know? (e.g., create-doc-from-template, execute-checklist)"
8. "Do they need any specialized tasks that don't exist yet?"
9. "Which document templates will they use?"
10. "What motivates them in their work?"
### 7. Workflow Integration Analysis
## Important Notes
Review workflows and suggest where the agent fits:
- Keep personas engaging but professional
- Ensure all referenced tasks, templates, and checklists exist
- Web agents can be more detailed than IDE agents (no size constraints)
- Consider how this agent will collaborate with existing team members
- Run validation after creating to catch any issues
1. **Load workflow definitions** from `/bmad-core/workflows/`
2. **Analyze workflow stages** to identify where this agent would contribute
3. **Suggest integration points**:
- Planning phases → analysts, PMs
- Design phases → UX experts, architects
- Implementation phases → developers
- Validation phases → QA, PO
4. **Document recommendations** for workflow updates if needed
### 8. Create IDE Agent (Optional)
If the agent should also work in IDE environments:
1. Create `/bmad-core/ide-agents/{agent-id}.ide.md`
2. Follow the IDE agent schema from `/bmad-core/schemas/ide-agent-schema.yml`
3. Include required commands (*help, *chat-mode) and startup instructions
### 9. Validation and Testing
1. **Validate against schema**: Ensure configuration matches agent-schema.yml
2. **Run build validation**: `npm run validate`
3. **Build the agent**: `npm run build:agent -a {agent-id}`
4. **Test in teams**: Build teams that include this agent
5. **Review output**: Check `/dist/agents/{agent-id}.txt`
## Integration Checklist
After creating the agent, verify:
- [ ] Agent configuration validates against schema
- [ ] Persona file includes all required sections
- [ ] All referenced dependencies exist
- [ ] Team integration suggestions documented
- [ ] Workflow integration points identified
- [ ] Build completes without errors
- [ ] Agent output is under size limits (if applicable)
## Example Integration Analysis
When creating a "Security Expert" agent:
**Team Integration:**
- `team-fullstack`: Add for security reviews in full-stack projects
- `team-no-ui`: Add for backend service security assessments
**Workflow Integration:**
- `greenfield-*`: Security review after architecture phase
- `brownfield-*`: Security assessment before implementation
This ensures the new agent enhances existing capabilities rather than working in isolation.

334
bmad-core/tasks/create-ide-agent.md
View File

@@ -1,148 +1,262 @@
# Create IDE Agent Task
This task helps you create a new BMAD agent optimized for IDE environments (Cursor, Windsurf, etc.).
This task guides you through creating a new BMAD IDE agent that conforms to the IDE agent schema and integrates effectively with workflows and teams.
**Note for User-Created IDE Agents**: If you're creating a custom IDE agent for your own use (not part of the core BMAD system), prefix the agent ID with a period (e.g., `.api-expert`) to ensure it's gitignored and won't conflict with repository updates.
**Note for User-Created IDE Agents**: If creating a custom IDE agent for your own use (not part of the core BMAD system), prefix the agent ID with a period (e.g., `.api-expert`) to ensure it's gitignored and won't conflict with repository updates.
## Important Constraints
## Prerequisites
IDE agents must be **compact and efficient** (target: under 2000 characters) to work well as slash commands.
1. Load and understand the IDE agent schema: `/bmad-core/schemas/ide-agent-schema.yml`
2. Review existing IDE agents in `/bmad-core/ide-agents/` for patterns and conventions
3. Review workflows in `/bmad-core/workflows/` to identify integration opportunities
4. Consider if this agent should also have a full agent counterpart
## Process
### 1. Gather Essential Information
### 1. Define Agent Core Identity
Ask the user for:
Based on the schema's required fields:
- **Agent ID**: Short, lowercase identifier (e.g., `api-expert`, `test-engineer`)
- **Slash command**: The command to activate (e.g., `/api`, `/test`)
- **Core purpose**: ONE primary function (IDE agents should be focused)
- **Role**: Must end with "IDE Agent" (pattern: `^.+ IDE Agent$`)
- Example: "API Specialist IDE Agent", "Test Engineer IDE Agent"
- **Agent ID**: Following pattern `^[a-z][a-z0-9-]*$`
- For user agents: prefix with period (`.api-expert`)
- **Primary Purpose**: Define ONE focused capability
### 2. Define Minimal Personality
### 2. Create File References
Keep it brief:
All IDE agents must include (per schema):
- **One-line personality**: A single trait or approach (e.g., "Direct and solution-focused")
- **Expertise**: 2-3 core skills maximum
- **Style**: How they communicate (brief! e.g., "Concise, code-first responses")
### 3. Identify Essential Capabilities
Be selective - IDE agents should be specialized:
- **1-2 primary tasks**: Only the most essential tasks
- **1 template maximum**: Only if absolutely necessary
- **Skip checklists**: Usually too large for IDE agents
- **Reuse existing tasks**: Creating new tasks for IDE agents is rare
### 4. Create the Compact IDE Agent
Create `/bmad-core/ide-agents/{agent-id}.ide.md` with this structure:
(For user-created agents, use `/bmad-core/ide-agents/.{agent-id}.ide.md`)
```markdown
# {Slash Command}
You are {Agent Name}, a {title/role}.
## Expertise
- {Skill 1}
- {Skill 2}
- {Skill 3 if essential}
## Approach
{One sentence about how you work}
## Focus
{One sentence about what you prioritize}
---
When activated with {slash command}, immediately focus on {primary purpose}.
```yaml
taskroot: "bmad-core/tasks/" # Required constant
templates: "bmad-core/templates/" # Optional but common
checklists: "bmad-core/checklists/" # Optional
default-template: "bmad-core/templates/{template-name}" # If agent creates documents
```
### 5. Size Optimization Techniques
Additional custom references as needed (e.g., `story-path`, `coding-standards`)
To keep agents small:
### 3. Define Persona (Schema Required Fields)
1. **Remove fluff**: No backstory, minimal personality
2. **Use references**: Reference tasks rather than inline instructions
3. **Be specific**: One job done well is better than many done poorly
4. **Trim lists**: Maximum 3-5 bullet points for any list
5. **Avoid examples**: Let referenced tasks handle examples
Create concise persona following schema structure:
### 6. Test the Agent
- **Name**: Character name (e.g., "Alex", "Dana")
- **Role**: Professional role title
- **Identity**: Extended specialization (20+ chars)
- **Focus**: Primary objectives (20+ chars)
- **Style**: Communication approach (20+ chars)
1. Check character count: `wc -c {agent-file}`
2. Ensure it's under 2000 characters
3. Test in your IDE with the slash command
4. Verify it can access referenced tasks
Keep descriptions brief for IDE efficiency!
## Example Questions (Keep it Simple!)
### 4. Core Principles (Minimum 3 Required)
1. "What's the slash command? (e.g., /api)"
2. "What's the ONE thing this agent does best?"
3. "In 5 words or less, describe their personality"
4. "What 1-2 existing tasks do they need?"
5. "Any special focus or constraints?"
Must include these based on schema validation:
## Example: Minimal API Expert
1. **Numbered Options Protocol** (REQUIRED): "When presenting multiple options, always use numbered lists for easy selection"
2. **[Domain-Specific Principle]**: Related to agent's expertise
3. **[Quality/Efficiency Principle]**: How they ensure excellence
4. Additional principles as needed (keep concise)
### 5. Critical Startup Operating Instructions
First instruction MUST announce name/role and mention *help (schema requirement):
```markdown
# /api
You are Alex, an API design expert.
## Expertise
- RESTful API design
- OpenAPI/Swagger specs
- API security patterns
## Approach
I provide immediate, practical API solutions with example code.
## Focus
Clean, secure, well-documented APIs that follow industry standards.
---
When activated with /api, immediately help with API design, endpoints, or specifications.
1. Announce your name and role, and let the user know they can say *help at any time to list the commands on your first response as a reminder even if their initial request is a question, wrapping the question. For Example 'I am {role} {name}, {response}... Also remember, you can enter `*help` to see a list of commands at any time.'
```
## Size Comparison
Add 2-5 additional startup instructions specific to the agent's role.
❌ **Too Large** (persona-style):
### 6. Commands (Minimum 2 Required)
Required commands per schema:
```markdown
Alex is a seasoned API architect with over 10 years of experience
building scalable systems. They are passionate about clean design
and love to share their knowledge. Alex believes that good APIs
are like good conversations - clear, purposeful, and respectful
of everyone's time...
- `*help` - Show these available commands as a numbered list offering selection
- `*chat-mode` - Enter conversational mode, staying in character while offering `advanced-elicitation` when providing advice or multiple options. Ends if other task or command is given
```
(Too much personality, not focused)
Add role-specific commands:
- Use pattern: `^\\*[a-z][a-z0-9-]*( \\{[^}]+\\})?$`
- Include clear descriptions (10+ chars)
- Reference tasks when appropriate
✅ **Just Right** (IDE-style):
### 7. Workflow Integration Analysis
Analyze where this IDE agent fits in workflows:
1. **Load workflow definitions** from `/bmad-core/workflows/`
2. **Identify integration points**:
- Which workflow phases benefit from this agent?
- Can they replace or augment existing workflow steps?
- Do they enable new workflow capabilities?
3. **Suggest workflow enhancements**:
- For technical agents → development/implementation phases
- For testing agents → validation phases
- For design agents → planning/design phases
- For specialized agents → specific workflow steps
4. **Document recommendations**:
```markdown
## Workflow Integration
This agent enhances the following workflows:
- `greenfield-service`: API design phase (between architecture and implementation)
- `brownfield-service`: API refactoring and modernization
- User can specify: {custom workflow integration}
```
### 8. Team Integration Suggestions
Consider which teams benefit from this IDE agent:
1. **Analyze team compositions** in `/bmad-core/agent-teams/`
2. **Suggest team additions**:
- Technical specialists → development teams
- Quality specialists → full-stack teams
- Domain experts → relevant specialized teams
3. **Document integration**:
```markdown
## Team Integration
Recommended teams for this agent:
- `team-fullstack`: Provides specialized {domain} expertise
- `team-no-ui`: Enhances backend {capability}
- User proposed: {custom team integration}
```
### 9. Create the IDE Agent File
Create `/bmad-core/ide-agents/{agent-id}.ide.md` following schema structure:
(For user agents: `/bmad-core/ide-agents/.{agent-id}.ide.md`)
```markdown
You are Alex, an API design expert.
Focus: RESTful design, OpenAPI specs, security patterns.
Style: Direct solutions with example code.
# Role: {Title} IDE Agent
## File References
`taskroot`: `bmad-core/tasks/`
`templates`: `bmad-core/templates/`
{additional references}
## Persona
- **Name:** {Name}
- **Role:** {Role}
- **Identity:** {20+ char description}
- **Focus:** {20+ char objectives}
- **Style:** {20+ char communication style}
## Core Principles (Always Active)
- **{Principle}:** {Description}
- **{Principle}:** {Description}
- **Numbered Options Protocol:** When presenting multiple options, always use numbered lists for easy selection
## Critical Startup Operating Instructions
1. Announce your name and role, and let the user know they can say *help at any time...
2. {Additional startup instruction}
3. {Additional startup instruction}
## Commands
- `*help` - Show these available commands as a numbered list offering selection
- `*chat-mode` - Enter conversational mode, staying in character while offering `advanced-elicitation`...
- `*{command}` - {Description of what it does}
{additional commands}
{Optional sections like Expertise, Workflow, Protocol, etc.}
```
(Minimal, focused, actionable)
### 10. Validation and Testing
## Important Notes
1. **Schema Validation**: Ensure all required fields are present
2. **Pattern Validation**: Check role name, command patterns
3. **Size Optimization**: Keep concise for IDE efficiency
4. **Command Testing**: Verify all commands are properly formatted
5. **Integration Testing**: Test in actual IDE environment
- **One agent, one job** - Don't try to do everything
- **Reference, don't repeat** - Use task dependencies
- **Test the size** - Must be under 2000 characters
- **Skip the story** - No background needed for IDE agents
- **Focus on action** - What they DO, not who they ARE
## Example: API Specialist IDE Agent
```markdown
# Role: API Specialist IDE Agent
## File References
`taskroot`: `bmad-core/tasks/`
`templates`: `bmad-core/templates/`
`default-template`: `bmad-core/templates/api-spec-tmpl`
## Persona
- **Name:** Alex
- **Role:** API Specialist
- **Identity:** REST API design expert specializing in scalable, secure service interfaces
- **Focus:** Creating clean, well-documented APIs that follow industry best practices
- **Style:** Direct, example-driven, focused on practical implementation patterns
## Core Principles (Always Active)
- **API-First Design:** Every endpoint designed with consumer needs in mind
- **Security by Default:** Authentication and authorization built into every design
- **Documentation Excellence:** APIs are only as good as their documentation
- **Numbered Options Protocol:** When presenting multiple options, always use numbered lists for easy selection
## Critical Startup Operating Instructions
1. Announce your name and role, and let the user know they can say *help at any time to list the commands on your first response as a reminder even if their initial request is a question, wrapping the question. For Example 'I am API Specialist Alex, {response}... Also remember, you can enter `*help` to see a list of commands at any time.'
2. Assess the API design context (REST, GraphQL, gRPC)
3. Focus on practical, implementable solutions
## Commands
- `*help` - Show these available commands as a numbered list offering selection
- `*chat-mode` - Enter conversational mode, staying in character while offering `advanced-elicitation` when providing advice or multiple options. Ends if other task or command is given
- `*design-api` - Design REST API endpoints for specified requirements
- `*create-spec` - Create OpenAPI specification using default template
- `*review-api` - Review existing API design for best practices
- `*security-check` - Analyze API security considerations
## Workflow Integration
This agent enhances the following workflows:
- `greenfield-service`: API design phase after architecture
- `brownfield-service`: API modernization and refactoring
- `greenfield-fullstack`: API contract definition between frontend/backend
## Team Integration
Recommended teams for this agent:
- `team-fullstack`: API contract expertise
- `team-no-ui`: Backend API specialization
- Any team building service-oriented architectures
```
## IDE Agent Creation Checklist
- [ ] Role name ends with "IDE Agent"
- [ ] All schema-required fields present
- [ ] Includes required File References
- [ ] Persona has all 5 required fields
- [ ] Minimum 3 Core Principles including Numbered Options Protocol
- [ ] First startup instruction announces name/role with *help
- [ ] Includes *help and *chat-mode commands
- [ ] Commands follow pattern requirements
- [ ] Workflow integration documented
- [ ] Team integration suggestions provided
- [ ] Validates against ide-agent-schema.yml
- [ ] Concise and focused on single expertise
## Best Practices
1. **Stay Focused**: IDE agents should excel at ONE thing
2. **Reference Tasks**: Don't duplicate task content
3. **Minimal Personality**: Just enough to be helpful
4. **Clear Commands**: Make it obvious what each command does
5. **Integration First**: Consider how agent enhances existing workflows
6. **Schema Compliance**: Always validate against the schema
This schema-driven approach ensures IDE agents are consistent, integrated, and valuable additions to the BMAD ecosystem.

287
bmad-core/tasks/create-team.md
View File

@@ -1,180 +1,223 @@
# Create Team Task
This task helps you create a NEW BMAD team bundle by combining existing agents from the BMAD-METHOD repository.
This task guides you through creating a new BMAD agent team that conforms to the agent-team schema and effectively combines agents for specific project types.
**Important**: This task is for CREATING new teams, not for listing what agents are available in the current bundle. To see agents in the current bundle, use `/agent-list`.
**Note for User-Created Teams**: If creating a custom team for your own use (not part of the core BMAD system), prefix the team name with a period (e.g., `.team-frontend`) to ensure it's gitignored and won't conflict with repository updates.
**Note for User-Created Teams**: If you're creating a custom team for your own use (not part of the core BMAD system), prefix the team ID with a period (e.g., `.team-frontend`) to ensure it's gitignored and won't conflict with repository updates.
## Prerequisites
1. Load and understand the team schema: `/bmad-core/schemas/agent-team-schema.yml`
2. Review existing teams in `/bmad-core/agent-teams/` for patterns and naming conventions
3. List available agents from `/agents/` to understand team composition options
4. Review workflows in `/bmad-core/workflows/` to align team capabilities
## Process
### 1. Define Team Basics
### 1. Define Team Purpose and Scope
Ask the user for:
Before selecting agents, clarify the team's mission:
- **Team ID**: Filename without extension (e.g., `team-frontend`, `team-planning`)
- **Team Name**: Display name (e.g., "Frontend Development Team")
- **Team Description**: What this team is designed to accomplish
- **Target Environment**: Usually "web" for team bundles
- **Team Purpose**: What specific problems will this team solve?
- **Project Types**: Greenfield, brownfield, or both?
- **Technical Scope**: UI-focused, backend-only, or full-stack?
- **Team Size Consideration**: Smaller teams (3-5 agents) for focused work, larger teams (6-8) for comprehensive coverage
### 2. List Available Agents for Team Creation
### 2. Create Team Metadata
When creating a new team, you can choose from these agents in the BMAD-METHOD repository:
Based on the schema requirements:
```
Agents available for team creation:
- analyst (Mary) - Project Analyst and Brainstorming Coach
- architect (Fred) - System Architecture Expert
- bmad (BMad) - BMAD Method Orchestrator
- ui-architect (Jane) - UI/UX Architecture Expert
- dev (James) - Full Stack Developer
- devops (Alex) - Platform Engineer
- fullstack-architect (Winston) - Holistic System Designer
- pm (John) - Product Manager
- po (Sarah) - Product Owner
- qa (Quinn) - Test Architect
- sm (Bob) - Scrum Master
- ux-expert (Sally) - UX Design Expert
```
- **Team Name**: Must follow pattern `^Team .+$` (e.g., "Team Frontend", "Team Analytics")
- For user teams: prefix with period (e.g., "Team .MyCustom")
- **Description**: 20-500 characters explaining team's purpose, capabilities, and use cases
- **File Name**: `/bmad-core/agent-teams/team-{identifier}.yml`
- For user teams: `/bmad-core/agent-teams/.team-{identifier}.yml`
**Note**: This list is for selecting agents when creating a NEW team configuration file. It does not reflect what agents are in your current bundle.
### 3. Select Agents Based on Purpose
### 3. Select Team Members
#### Discover Available Agents
For each agent the user wants to include:
1. List all agents from `/agents/` directory
2. Review each agent's role and capabilities
3. Consider agent synergies and coverage
1. Confirm the agent ID
2. Ask if they want to customize the persona for this team context
3. Note any special team dynamics or relationships
#### Agent Selection Guidelines
### 4. Optimize Team Composition
Based on team purpose, recommend agents:
Consider:
**For Planning & Strategy Teams:**
- `bmad` (required orchestrator)
- `analyst` - Requirements gathering and research
- `pm` - Product strategy and documentation
- `po` - Validation and approval
- `architect` - Technical planning (if technical planning needed)
- **Role coverage**: Does the team have all necessary skills?
- **Team size**: 3-7 agents is usually optimal
- **Collaboration**: How will these agents work together?
- **Use cases**: What problems will this team solve?
**For Design & UX Teams:**
- `bmad` (required orchestrator)
- `ux-expert` - User experience design
- `architect` - Frontend architecture
- `pm` - Product requirements alignment
- `po` - Design validation
**For Development Teams:**
- `bmad` (required orchestrator)
- `sm` - Sprint coordination
- `dev` - Implementation
- `qa` - Quality assurance
- `architect` - Technical guidance
**For Full-Stack Teams:**
- `bmad` (required orchestrator)
- `analyst` - Initial planning
- `pm` - Product management
- `ux-expert` - UI/UX design (if UI work included)
- `architect` - System architecture
- `po` - Validation
- Additional agents as needed
#### Special Cases
- **Using Wildcard**: If team needs all agents, use `["bmad", "*"]`
- **Validation**: Schema requires `bmad` in all teams
### 4. Select Workflows
Based on the schema's workflow enum values and team composition:
1. **Analyze team capabilities** against available workflows:
- `brownfield-fullstack` - Requires full team with UX
- `brownfield-service` - Backend-focused team
- `brownfield-ui` - UI/UX-focused team
- `greenfield-fullstack` - Full team for new projects
- `greenfield-service` - Backend team for new services
- `greenfield-ui` - Frontend team for new UIs
2. **Match workflows to agents**:
- UI workflows require `ux-expert`
- Service workflows benefit from `architect` and `dev`
- All workflows benefit from planning agents (`analyst`, `pm`)
3. **Apply schema validation rules**:
- Teams without `ux-expert` shouldn't have UI workflows
- Teams named "Team No UI" can't have UI workflows
### 5. Create Team Configuration
Create `/agent-teams/{team-id}.yml`:
(For user-created teams, use `/agent-teams/.{team-id}.yml`)
Generate the configuration following the schema:
```yaml
bundle:
name: { Team Name }
name: "{Team Name}" # Must match pattern "^Team .+$"
description: >-
{Detailed description of the team's purpose and capabilities}
{20-500 character description explaining purpose,
capabilities, and ideal use cases}
agents:
- { agent-id-1 }
- { agent-id-2 }
- { agent-id-3 }
# ... more agents
- bmad # Required orchestrator
- {agent-id-1}
- {agent-id-2}
# ... additional agents
workflows:
- {workflow-1} # From enum list
- {workflow-2}
# ... additional workflows
```
#### Using Wildcards
### 6. Validate Team Composition
You can use `"*"` (quoted) to include all available agents:
Before finalizing, verify:
```yaml
agents:
- bmad # Always include bmad first
- "*" # Include all other agents
```
1. **Role Coverage**: Does the team have all necessary skills for its workflows?
2. **Size Optimization**:
- Minimum: 2 agents (bmad + 1)
- Recommended: 3-7 agents
- Maximum with wildcard: bmad + "*"
3. **Workflow Alignment**: Can the selected agents execute all workflows?
4. **Schema Compliance**: Configuration matches all schema requirements
Or mix specific agents with wildcard:
### 7. Integration Recommendations
```yaml
agents:
- pm # Product Manager first
- architect # Then Architect
- "*" # Then all remaining agents
```
Document how this team integrates with existing system:
### 6. Validate and Build
1. **Complementary Teams**: Which existing teams complement this one?
2. **Handoff Points**: Where does this team hand off to others?
3. **Use Case Scenarios**: Specific project types ideal for this team
1. Run `npm run validate` to check configuration
2. Run `npm run build` to generate the team bundle
3. Review output in `/dist/teams/{team-filename}.txt`
### 8. Validation and Testing
## Example Teams
1. **Schema Validation**: Ensure configuration matches agent-team-schema.yml
2. **Build Validation**: Run `npm run validate`
3. **Build Team**: Run `npm run build:team -t {team-name}`
4. **Size Check**: Verify output is appropriate for target platform
5. **Test Scenarios**: Run sample workflows with the team
### Development Team
## Example Team Creation
### Example 1: API Development Team
```yaml
bundle:
name: Development Team Bundle
name: "Team API"
description: >-
Core development team for building features from story to deployment
Specialized team for API and backend service development. Focuses on
robust service architecture, implementation, and testing without UI
components. Ideal for microservices, REST APIs, and backend systems.
agents:
- sm # Sprint coordination
- dev # Implementation
- qa # Quality assurance
- devops # Deployment
- bmad
- analyst
- architect
- dev
- qa
- po
workflows:
- greenfield-service
- brownfield-service
```
### Planning Team
### Example 2: Rapid Prototyping Team
```yaml
bundle:
name: Planning Team Bundle
name: "Team Prototype"
description: >-
Strategic planning team for project inception and architecture
Agile team for rapid prototyping and proof of concept development.
Combines planning, design, and implementation for quick iterations
on new ideas and experimental features.
agents:
- analyst # Requirements gathering
- pm # Product planning
- architect # System design
- po # Validation
- bmad
- pm
- ux-expert
- architect
- dev
workflows:
- greenfield-ui
- greenfield-fullstack
```
### Full-Stack Team
## Team Creation Checklist
```yaml
bundle:
name: Full-Stack Team Bundle
description: >-
Complete team for full-stack application development
- [ ] Team purpose clearly defined
- [ ] Name follows schema pattern "Team {Name}"
- [ ] Description is 20-500 characters
- [ ] Includes bmad orchestrator
- [ ] Agents align with team purpose
- [ ] Workflows match team capabilities
- [ ] No conflicting validations (e.g., no-UI team with UI workflows)
- [ ] Configuration validates against schema
- [ ] Build completes successfully
- [ ] Output size appropriate for platform
agents:
- fullstack-architect # Holistic design
- design-architect # Frontend architecture
- dev # Implementation
- qa # Testing
- devops # Infrastructure
```
## Best Practices
## Questions to Ask
1. **Start Focused**: Create teams with specific purposes rather than general-purpose teams
2. **Consider Workflow**: Order agents by typical workflow sequence
3. **Avoid Redundancy**: Don't duplicate roles unless needed
4. **Document Rationale**: Explain why each agent is included
5. **Test Integration**: Verify team works well with selected workflows
6. **Iterate**: Refine team composition based on usage
1. "What should this team be called? (e.g., 'team-mobile')"
2. "What's the team's display name?"
3. "Describe the team's primary purpose"
4. "Which agents should be on this team? (list agent IDs)"
5. "Any special dynamics between team members?"
6. "What types of projects will this team handle?"
## Tips for Good Teams
- **Start small**: Begin with 3-4 core agents
- **Clear purpose**: Each team should have a specific focus
- **Complementary skills**: Agents should cover different aspects
- **Avoid redundancy**: Don't include agents with overlapping roles
- **Consider workflow**: Order agents by typical workflow sequence
## Common Team Patterns
1. **Scrum Team**: sm, dev, qa, po
2. **Planning Team**: analyst, pm, architect, po
3. **Design Team**: ux-expert, ui-architect, dev
4. **Full Organization**: All agents (for complex projects)
5. **Technical Team**: architect, dev, devops, qa
## Important Notes
- Teams reference existing agents - create agents first
- Keep team descriptions clear and purpose-driven
- Consider creating multiple focused teams rather than one large team
- Test team dynamics by running sample scenarios
This schema-driven approach ensures teams are well-structured, purposeful, and integrate seamlessly with the BMAD ecosystem.