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

a few things are broken, and big folder move incoming....

Browse Source
This commit is contained in:
Brian Madison
2025-06-10 17:03:25 -05:00
parent 0d59c686dd
commit cd5fc44de1
11 changed files with 1911 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
bmad-core/tasks/brainstorming-techniques.md Normal file
View File

@@ -0,0 +1,216 @@
# Brainstorming Techniques Task
This task provides a comprehensive toolkit of creative brainstorming techniques for ideation and innovative thinking. The analyst can use these techniques to facilitate productive brainstorming sessions with users.
## Process
### 1. Session Setup
[[LLM: Begin by understanding the brainstorming context and goals. Ask clarifying questions if needed to determine the best approach.]]
1. **Establish Context**
- Understand the problem space or opportunity area
- Identify any constraints or parameters
- Determine session goals (divergent exploration vs. focused ideation)
2. **Select Technique Approach**
- Option A: User selects specific techniques
- Option B: Analyst recommends techniques based on context
- Option C: Random technique selection for creative variety
- Option D: Progressive technique flow (start broad, narrow down)
### 2. Core Brainstorming Techniques
#### Creative Expansion Techniques
1. **"What If" Scenarios**
[[LLM: Generate provocative what-if questions that challenge assumptions and expand thinking beyond current limitations.]]
- What if we had unlimited resources?
- What if this problem didn't exist?
- What if we approached this from a child's perspective?
- What if we had to solve this in 24 hours?
2. **Analogical Thinking**
[[LLM: Help user draw parallels between their challenge and other domains, industries, or natural systems.]]
- "How might this work like [X] but for [Y]?"
- Nature-inspired solutions (biomimicry)
- Cross-industry pattern matching
- Historical precedent analysis
3. **Reversal/Inversion**
[[LLM: Flip the problem or approach it from the opposite angle to reveal new insights.]]
- What if we did the exact opposite?
- How could we make this problem worse? (then reverse)
- Start from the end goal and work backward
- Reverse roles or perspectives
4. **First Principles Thinking**
[[LLM: Break down to fundamental truths and rebuild from scratch.]]
- What are the absolute fundamentals here?
- What assumptions can we challenge?
- If we started from zero, what would we build?
- What laws of physics/economics/human nature apply?
#### Structured Ideation Frameworks
5. **SCAMPER Method**
[[LLM: Guide through each SCAMPER prompt systematically.]]
- **S**ubstitute: What can be substituted?
- **C**ombine: What can be combined or integrated?
- **A**dapt: What can be adapted from elsewhere?
- **M**odify/Magnify: What can be emphasized or reduced?
- **P**ut to other uses: What else could this be used for?
- **E**liminate: What can be removed or simplified?
- **R**everse/Rearrange: What can be reversed or reordered?
6. **Six Thinking Hats**
[[LLM: Cycle through different thinking modes, spending focused time in each.]]
- White Hat: Facts and information
- Red Hat: Emotions and intuition
- Black Hat: Caution and critical thinking
- Yellow Hat: Optimism and benefits
- Green Hat: Creativity and alternatives
- Blue Hat: Process and control
7. **Mind Mapping**
[[LLM: Create text-based mind maps with clear hierarchical structure.]]
```
Central Concept
├── Branch 1
│ ├── Sub-idea 1.1
│ └── Sub-idea 1.2
├── Branch 2
│ ├── Sub-idea 2.1
│ └── Sub-idea 2.2
└── Branch 3
└── Sub-idea 3.1
```
#### Collaborative Techniques
8. **"Yes, And..." Building**
[[LLM: Accept every idea and build upon it without judgment. Encourage wild ideas and defer criticism.]]
- Accept the premise of each idea
- Add to it with "Yes, and..."
- Build chains of connected ideas
- Explore tangents freely
9. **Brainwriting/Round Robin**
[[LLM: Simulate multiple perspectives by generating ideas from different viewpoints.]]
- Generate ideas from stakeholder perspectives
- Build on previous ideas in rounds
- Combine unrelated ideas
- Cross-pollinate concepts
10. **Random Stimulation**
[[LLM: Use random words, images, or concepts as creative triggers.]]
- Random word association
- Picture/metaphor inspiration
- Forced connections between unrelated items
- Constraint-based creativity
#### Deep Exploration Techniques
11. **Five Whys**
[[LLM: Dig deeper into root causes and underlying motivations.]]
- Why does this problem exist? → Answer → Why? (repeat 5 times)
- Uncover hidden assumptions
- Find root causes, not symptoms
- Identify intervention points
12. **Morphological Analysis**
[[LLM: Break down into parameters and systematically explore combinations.]]
- List key parameters/dimensions
- Identify possible values for each
- Create combination matrix
- Explore unusual combinations
13. **Provocation Technique (PO)**
[[LLM: Make deliberately provocative statements to jar thinking.]]
- PO: Cars have square wheels
- PO: Customers pay us to take products
- PO: The problem solves itself
- Extract useful ideas from provocations
### 3. Technique Selection Guide
[[LLM: Help user select appropriate techniques based on their needs.]]
**For Initial Exploration:**
- What If Scenarios
- First Principles
- Mind Mapping
**For Stuck/Blocked Thinking:**
- Random Stimulation
- Reversal/Inversion
- Provocation Technique
**For Systematic Coverage:**
- SCAMPER
- Morphological Analysis
- Six Thinking Hats
**For Deep Understanding:**
- Five Whys
- Analogical Thinking
- First Principles
**For Team/Collaborative Settings:**
- Brainwriting
- "Yes, And..."
- Six Thinking Hats
### 4. Session Flow Management
[[LLM: Guide the brainstorming session with appropriate pacing and technique transitions.]]
1. **Warm-up Phase** (5-10 min)
- Start with accessible techniques
- Build creative confidence
- Establish "no judgment" atmosphere
2. **Divergent Phase** (20-30 min)
- Use expansion techniques
- Generate quantity over quality
- Encourage wild ideas
3. **Convergent Phase** (15-20 min)
- Group and categorize ideas
- Identify patterns and themes
- Select promising directions
4. **Synthesis Phase** (10-15 min)
- Combine complementary ideas
- Refine and develop concepts
- Prepare summary of insights
### 5. Output Format
[[LLM: Present brainstorming results in an organized, actionable format.]]
**Session Summary:**
- Techniques used
- Number of ideas generated
- Key themes identified
**Idea Categories:**
1. **Immediate Opportunities** - Ideas that could be implemented now
2. **Future Innovations** - Ideas requiring more development
3. **Moonshots** - Ambitious, transformative ideas
4. **Insights & Learnings** - Key realizations from the session
**Next Steps:**
- Which ideas to explore further
- Recommended follow-up techniques
- Suggested research areas
## Important Notes
- Maintain energy and momentum throughout the session
- Defer judgment - all ideas are valid during generation
- Quantity leads to quality - aim for many ideas
- Build on ideas collaboratively
- Document everything - even "silly" ideas can spark breakthroughs
- Take breaks if energy flags
- End with clear next actions

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

@@ -7,13 +7,41 @@ This task guides you through creating a new BMAD agent that conforms to the agen
## 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
2. Load and understand the persona schema: `/bmad-core/schemas/persona-schema.yml`
3. Review existing agents in `/agents/` to understand naming patterns
4. Review existing personas in `/bmad-core/personas/` for reusable base personalities
5. Check existing teams in `/bmad-core/agent-teams/` for integration opportunities
6. Review workflows in `/bmad-core/workflows/` to understand where the agent might fit
## Process
### 1. Gather Core Agent Information
### 1. Determine Persona Strategy
Start by asking the user about their persona approach:
**"Are you creating this agent based on an existing persona?"**
#### Option A: Use Existing Persona
- List available personas from `/bmad-core/personas/`
- User selects or provides path to existing persona
- Agent will reference this persona file
- Allows customization through `customize` field
#### Option B: Create New Reusable Persona
- User wants to create a base persona for multiple agents
- Create both a persona file and agent file
- Good for creating variations (e.g., multiple dev agents with different specializations)
#### Option C: Create Self-Contained Agent
- User wants a unique, one-off agent
- Persona will be embedded in the agent's `customize` field
- `persona` field will be `null`
- Requires comprehensive persona definition in customize
### 2. Gather Core Agent Information
Based on the agent schema's required fields, collect:
@@ -23,22 +51,73 @@ Based on the agent schema's required fields, collect:
- **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
### 3. Define or Reference Persona
Create a comprehensive persona by exploring:
#### For Existing Persona (Option A):
- **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
- Set `persona: "bmad-core/personas/{persona-id}.md"`
- Use `customize` for minor adjustments (max 500 chars)
- Extract startup instructions from persona file
### 3. Identify Dependencies
#### For New Persona (Option B):
1. Create `/bmad-core/personas/{persona-id}.md` following persona schema:
```markdown
# Role: {Title} Agent
## Persona
- Role: {Descriptive Role Statement}
- Style: {Communication style and approach}
## Core {Title} Principles (Always Active)
- **{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]
## Critical Start Up Operating Instructions
- 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.
```
2. Set `persona: "bmad-core/personas/{persona-id}.md"` in agent
3. Extract startup instructions for agent's `startup` field
#### For Embedded Persona (Option C):
- Set `persona: null`
- Create comprehensive `customize` field (200+ chars) including:
- Character background and expertise
- Communication style
- Core principles and values
- Working approach
- Key motivations
- Define `startup` array with operating instructions
### 4. Define Startup Instructions
All agents now include startup instructions in the agent configuration:
```yaml
startup:
- "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."
- "[Additional agent-specific startup instructions]"
```
For agents with external personas, extract and adapt the startup instructions from the persona file.
### 5. Identify Dependencies
Analyze what resources the agent needs:
#### Tasks (from `/bmad-core/tasks/`)
- Review available tasks and identify which apply
- Common tasks most agents need:
- `advanced-elicitation` (for conversational depth)
@@ -47,150 +126,466 @@ Analyze what resources the agent needs:
- 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` following the schema-required structure:
(For user agents: `/bmad-core/personas/.{agent-id}.md`)
```markdown
# Role: {Title} Agent
## Persona
- Role: {Descriptive Role Statement}
- Style: {Communication style and approach}
## Core {Title} Principles (Always Active)
- **{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]
## Critical Start Up Operating Instructions
- 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.
[Add any agent-specific sections like Expertise, Workflow, etc.]
```
### 5. Create the Agent Configuration
### 6. Create the Agent Configuration
Create `/agents/{agent-id}.yml` conforming to the schema:
(For user agents: `/agents/.{agent-id}.yml`)
#### With External Persona:
```yaml
agent:
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
name: { Character Name }
id: { agent-id }
title: { Professional Title }
description: { 20-300 character description }
persona: bmad-core/personas/{persona-id}.md
customize: "" # or minor customizations
startup:
- { Startup instruction 1 }
- { Startup instruction 2 }
dependencies:
tasks:
- {task-id} # from identified tasks
templates:
- {template-id} # from identified templates
checklists:
- {checklist-id} # from identified checklists
data:
- {data-id} # from identified data files
utils:
- {util-id} # typically empty or specific utils
tasks: [{ task-ids }]
templates: [{ template-ids }]
checklists: [{ checklist-ids }]
data: [{ data-ids }]
utils: [{ util-ids }]
```
### 6. Team Integration Analysis
#### With Embedded Persona:
```yaml
agent:
name: { Character Name }
id: { agent-id }
title: { Professional Title }
description: { 20-300 character description }
persona: null
customize: >-
{Comprehensive persona definition including background, style,
principles, approach, and motivations - minimum 200 characters}
startup:
- { Startup instruction 1 }
- { Startup instruction 2 }
- { Additional instructions }
dependencies:
tasks: [{ task-ids }]
templates: [{ template-ids }]
checklists: [{ checklist-ids }]
data: [{ data-ids }]
utils: [{ util-ids }]
```
### 7. Team Integration Analysis
Review existing teams and suggest integration:
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
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
3. **Suggest teams** where this agent would add value
4. **Offer to update** team configurations
4. **Offer to update** team configurations:
```yaml
agents:
- bmad
- {existing-agents}
- {new-agent-id} # Add here
```
### 7. Workflow Integration Analysis
### 8. Workflow Integration Analysis
Review workflows and suggest where the agent fits:
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
3. **Suggest integration points**
4. **Document recommendations** for workflow updates if needed
### 8. Create IDE Agent (Optional)
### 9. Create IDE Agent Version
If the agent should also work in IDE environments:
After creating the full agent, offer to create an IDE-optimized version:
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
**"Would you like to create an IDE version of this agent for use in Cursor/Windsurf?"**
### 9. Validation and Testing
If yes, proceed with optimization:
#### 9.1 Confirm IDE Agent Details
- **IDE Agent Name**: Confirm or adjust the name (default: same as full agent)
- **Target Size**: Aim for under 3K characters (4K maximum)
- **Primary Focus**: Identify the ONE core capability to emphasize
#### 9.2 Size Optimization Process
**Key Insight**: Write for LLM comprehension, not human readability. LLMs understand dense, abbreviated content better than you might expect.
**CRITICAL REQUIREMENT**: All IDE agents MUST include the "Numbered Options Protocol" principle. This ensures:
- All lists presented with numbers (1, 2, 3...)
- Multiple options offered as numbered choices
- Sections/items referenced by number
- User can select by entering a number
1. **Use LLM-Optimized Language**
- Use abbreviations LLMs understand: API, REST, CRUD, JWT, etc.
- Dense keyword lists instead of sentences: "Expert: React, Node, AWS, Docker"
- Technical shorthand: "SOLID principles" not "Single responsibility, Open-closed..."
- Compressed syntax: "Focus: secure/scalable/tested APIs"
- Remove articles/connectors: "Creates PRDs, validates requirements" not "Creates the PRDs and validates all requirements"
2. **Extract Core Persona Elements**
- Compress to keyword phrases
- Stack related concepts with slashes: "PM/Strategy/Research"
- Use domain abbreviations
3. **Minimize File References**
- Only essential paths
- Use shortest valid references
4. **Streamline Commands**
- Terse descriptions
- Assume LLM context understanding
- Reference tasks by ID only
5. **Minimize Examples & Scripts**
- Minimal examples only (cut first if oversized)
- Replace full response scripts with instructions
- Example: Instead of "Say: 'I'll analyze your requirements and create...'"
- Use: "Acknowledge request, explain approach"
- Trust LLM to generate appropriate responses
6. **Compress Startup Instructions**
- Combine related directives
- Use imperative mood
- Eliminate politeness/filler
#### 9.3 Size Validation
After creating the IDE version:
1. **Check character count**: Must be under 4K (ideally under 3K)
2. **If too large**, identify issues:
- Too much embedded functionality → refactor to tasks
- Verbose descriptions → compress further
- Too many commands → prioritize core ones
3. **Warning if oversized**:
```
⚠️ WARNING: IDE agent is {size} characters (target: <3000)
Common issues:
- Too much logic embedded (should be in tasks)
- Verbose persona description
- Too many commands listed
Options:
1. Proceed anyway (may have issues in IDE)
2. Further optimize (recommended)
3. Refactor agent to use more external tasks
```
#### 9.4 IDE Agent Template
Create `/bmad-core/ide-agents/{agent-id}.ide.md`:
```markdown
# Role: {Title} IDE Agent
## File References
`taskroot`: `bmad-core/tasks/`
`templates`: `bmad-core/templates/`
{only essential references}
## Persona
- **Name:** {Name}
- **Role:** {Role}
- **Identity:** {Role/Domain/Specialty}
- **Focus:** {Primary-objective/key-outcomes}
- **Style:** {Trait1/trait2/trait3}
## Core Principles (Always Active)
- **{Principle}:** {LLM-friendly description}
- **{Principle}:** {Compressed key points}
- **Numbered Options Protocol:** Present options as numbered lists
## Critical Startup Operating Instructions
1. I'm {Role} {Name}. Type \*help for commands
2. {Core directive in imperative mood}
## Commands
- `*help` - Show commands as numbered list
- `*chat-mode` - Conversational mode + advanced-elicitation
- `*{cmd1}` - {Action verb + object}
- `*{cmd2}` - {Action verb + object}
{4-6 commands max}
```
#### 9.5 Optimization Examples
**Full Agent Persona** (500+ chars):
```
Elena is a meticulous Data Analyst with expertise in statistical analysis,
data visualization, and pattern recognition. She approaches problems with
scientific rigor, always seeking evidence in the data before drawing
conclusions. Her style is precise, methodical, and focused on delivering
actionable insights. She excels at transforming complex data into clear
narratives that stakeholders can understand and act upon.
```
**IDE Optimized (Human-Readable)** (150 chars):
```
- **Identity:** Data analysis expert specializing in statistics and visualization
- **Style:** Precise, evidence-driven, focused on actionable insights
```
**IDE Optimized (LLM-Optimized)** (95 chars):
```
- **Identity:** Data analyst: stats/viz/patterns
- **Style:** Precise/evidence-based/actionable
```
**More LLM Optimization Examples**:
Instead of: "Creates comprehensive PRDs with user stories, acceptance criteria, and success metrics"
Use: "Creates PRDs: user-stories/criteria/metrics"
Instead of: "Expert in React, Vue, Angular with deep knowledge of state management"
Use: "Expert: React/Vue/Angular, state-mgmt"
Instead of: "Validates requirements against business objectives and technical constraints"
Use: "Validates: reqs→objectives/constraints"
**Response Script Optimizations**:
Instead of: "Say: 'Hello! I'm Sarah, your Product Owner. I'll help validate your requirements. Here are the tasks I can help with: 1) Validate PRD, 2) Check architecture...'"
Use: "Greet as PO Sarah. List available tasks (numbered)"
Instead of: "Respond: 'I've analyzed your code and found 3 issues: First, the API endpoint lacks authentication...'"
Use: "Report findings with numbered list"
Instead of: "When user asks for help, say: 'I can assist with the following: 1. Creating test plans...'"
Use: "On help request: show numbered capabilities"
#### 9.6 Common Refactoring Needs
When agents are too large for IDE:
1. **Analyst Agent**: Move brainstorming techniques, research methodologies to tasks
2. **Architect Agent**: Extract architecture patterns, technology lists to templates
3. **PM Agent**: Move PRD sections, prioritization frameworks to tasks
4. **Dev Agent**: Extract coding standards, patterns to external docs
### 10. 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`
2. **Validate persona**: If external, ensure persona file exists and is valid
3. **Run build validation**: `npm run validate`
4. **Build the agent**: `npm run build:agent -a {agent-id}`
5. **Test in teams**: Build teams that include this agent
6. **Review output**: Check `/dist/agents/{agent-id}.txt`
## Examples
### Example 1: Agent with Existing Persona
```yaml
agent:
name: "Jennifer"
id: "pm-senior"
title: "Senior Product Manager"
description: "Experienced PM focused on enterprise product strategy and stakeholder management"
persona: "bmad-core/personas/pm.md"
customize: "Specializes in B2B SaaS products with emphasis on enterprise features and compliance requirements."
startup:
- "Let the User Know what Tasks you can perform in a numbered list for user selection."
- "Focus on enterprise-scale product challenges and stakeholder alignment."
- "Execute the Full Tasks as Selected."
dependencies:
tasks:
- "create-doc-from-template"
- "advanced-elicitation"
- "stakeholder-analysis"
templates:
- "prd-tmpl"
- "enterprise-prd-tmpl"
checklists:
- "pm-checklist"
- "enterprise-checklist"
data:
- "bmad-kb"
- "enterprise-patterns"
utils:
- "template-format"
```
### Example 2: Self-Contained Agent with Embedded Persona
```yaml
agent:
name: "Viktor"
id: "security-architect"
title: "Security Architect"
description: "Designs and reviews system security architecture ensuring robust protection against threats"
persona: null
customize: >-
Viktor is a seasoned Security Architect with 15 years defending critical systems.
His approach combines deep technical knowledge with practical risk assessment.
He thinks like an attacker to build better defenses, always considering the
full threat landscape. His style is thorough but pragmatic, focusing on
implementable security that doesn't cripple usability. Core principles include:
defense in depth, zero trust architecture, security by design not bolted on,
assume breach and plan accordingly, and balance security with user experience.
He excels at threat modeling, security reviews, and creating security guidelines
that developers can actually follow.
startup:
- "Let the User Know what security tasks you can perform in a numbered list for user selection."
- "Always start by understanding the threat model and compliance requirements."
- "Focus on practical, implementable security recommendations."
- "When conversing, offer advanced-elicitation for deeper security analysis."
dependencies:
tasks:
- "threat-modeling"
- "security-review"
- "create-doc-from-template"
templates:
- "security-architecture-tmpl"
- "threat-model-tmpl"
checklists:
- "security-checklist"
- "owasp-checklist"
data:
- "security-patterns"
- "compliance-frameworks"
utils:
- "security-tools"
```
## IDE Agent Best Practices
### What Makes a Good IDE Agent
1. **Single Focus**: Excel at ONE thing, not many
2. **Reference Heavy**: Use tasks/templates, don't embed logic
3. **Minimal Personality**: Just enough to be helpful
4. **Action Oriented**: Focus on WHAT they do, not WHO they are
5. **LLM-Optimized Language**: Dense, abbreviated, technical
6. **Concise Commands**: Clear, short command descriptions
### LLM-Friendly Abbreviations
Common abbreviations LLMs understand well:
- **Tech**: API, REST, GraphQL, CRUD, JWT, OAuth, CI/CD, K8s
- **Patterns**: MVC, SOLID, DRY, KISS, YAGNI, GoF
- **Roles**: PM, PO, QA, UX, DevOps, SRE, DBA
- **Processes**: TDD, BDD, MVP, PoC, UAT, A/B
- **Formats**: JSON, YAML, XML, CSV, MD
- **Concepts**: auth, viz, mgmt, config, reqs, docs
### Size Comparison Examples
❌ **Too Large** (Full Agent Style):
```yaml
The agent embodies deep expertise in API design, with years of experience
in RESTful services, GraphQL implementations, and microservice architectures.
They understand OAuth flows, JWT tokens, rate limiting strategies, caching
patterns, and have strong opinions about API versioning...
```
✅ **Just Right** (IDE Style):
```yaml
- **Identity:** API design expert specializing in REST and GraphQL
- **Focus:** Clean, secure, documented APIs following standards
```
### When NOT to Create IDE Version
Some agents may be too complex for IDE format:
- Agents with 10+ essential commands
- Agents requiring extensive context
- Agents that coordinate multiple other agents
- Orchestrator-type agents (like BMAD)
In these cases, recommend using the full agent in web platforms.
## Integration Checklist
After creating the agent, verify:
- [ ] Persona strategy chosen and implemented correctly
- [ ] Agent configuration validates against schema
- [ ] Persona file includes all required sections
- [ ] If external persona: file exists and is referenced correctly
- [ ] If embedded persona: customize field is comprehensive (200+ chars)
- [ ] Startup instructions included in agent configuration
- [ ] All referenced dependencies exist
- [ ] Team integration suggestions documented
- [ ] Workflow integration points identified
- [ ] Build completes without errors
- [ ] Agent output is under size limits (if applicable)
- [ ] IDE agent created (if requested)
- [ ] IDE agent under 4K characters (ideally under 3K)
- [ ] IDE agent functionality preserved
- [ ] Refactoring completed if agent was oversized
## Example Integration Analysis
## Troubleshooting Oversized Agents
When creating a "Security Expert" agent:
If an IDE agent exceeds size limits, check for:
**Team Integration:**
- `team-fullstack`: Add for security reviews in full-stack projects
- `team-no-ui`: Add for backend service security assessments
1. **Embedded Logic**: Move complex logic to tasks
- Example: Analyst's brainstorming techniques → create `brainstorming-techniques` task
2. **Verbose Descriptions**: Compress without losing meaning
**Workflow Integration:**
- `greenfield-*`: Security review after architecture phase
- `brownfield-*`: Security assessment before implementation
- Before: "Extensive experience in cloud architecture across AWS, Azure, and GCP"
- After: "Cloud architect (AWS/Azure/GCP)"
This ensures the new agent enhances existing capabilities rather than working in isolation.
3. **Too Many Commands**: Prioritize core functionality
- Keep: Primary creation/analysis commands
- Remove: Nice-to-have utility commands
4. **Inline Examples**: Remove all examples
- Let tasks provide examples
- Reference documentation instead
5. **Redundant Content**: Eliminate duplication
- Combine similar principles
- Merge related commands
This flexible approach allows users to create agents that either leverage existing personas for consistency or create unique, self-contained agents for specialized needs, with IDE-optimized versions for development environments.

328
bmad-core/tasks/create-deep-research-prompt.md
View File

@@ -1,55 +1,289 @@
# Deep Research Phase
# Create Deep Research Prompt Task
Leveraging advanced analytical capabilities, the Deep Research Phase with the PM is designed to provide targeted, strategic insights crucial for product definition. Unlike the broader exploratory research an Analyst might undertake, the PM utilizes deep research to:
- **Validate Product Hypotheses:** Rigorously test assumptions about market need, user problems, and the viability of specific product concepts.
- **Refine Target Audience & Value Proposition:** Gain a nuanced understanding of specific user segments, their precise pain points, and how the proposed product delivers unique value to them.
- **Focused Competitive Analysis:** Analyze competitors through the lens of a specific product idea to identify differentiation opportunities, feature gaps to exploit, and potential market positioning challenges.
- **De-risk PRD Commitments:** Ensure that the problem, proposed solution, and core features are well-understood and validated _before_ detailed planning and resource allocation in the PRD Generation Mode.
Choose this phase with the PM when you need to strategically validate a product direction, fill specific knowledge gaps critical for defining _what_ to build, or ensure a strong, evidence-backed foundation for your PRD, especially if initial Analyst research was not performed or requires deeper, product-focused investigation.
This task helps create comprehensive research prompts for various types of deep analysis. It can process inputs from brainstorming sessions, project briefs, market research, or specific research questions to generate targeted prompts for deeper investigation.
## Purpose
- To gather foundational information, validate concepts, understand market needs, or analyze competitors when a comprehensive Project Brief from an Analyst is unavailable or insufficient.
- To ensure the PM has a solid, data-informed basis for defining a valuable and viable product before committing to PRD specifics.
- To de-risk product decisions by grounding them in targeted research, especially if the user is engaging the PM directly without prior Analyst work or if the initial brief lacks necessary depth.
Generate well-structured research prompts that:
## Instructions
- Define clear research objectives and scope
- Specify appropriate research methodologies
- Outline expected deliverables and formats
- Guide systematic investigation of complex topics
- Ensure actionable insights are captured
<critical_rule>Note on Deep Research Execution:</critical_rule>
To perform deep research effectively, please be aware:
## Research Type Selection
- You may need to use this current conversational agent to help you formulate a comprehensive research prompt, which can then be executed by a dedicated deep research model or function.
- Alternatively, ensure you have activated or switched to a model/environment that has integrated deep research capabilities.
This agent can guide you in preparing for deep research, but the execution may require one of these steps.
[[LLM: First, help the user select the most appropriate research focus based on their needs and any input documents they've provided.]]
1. **Assess Inputs & Identify Gaps:**
- Review any existing inputs (user's initial idea, high-level requirements, partial brief from Analyst, etc.).
- Clearly identify critical knowledge gaps concerning:
- Target audience (needs, pain points, behaviors, key segments).
- Market landscape (size, trends, opportunities, potential saturation).
- Competitive analysis (key direct/indirect competitors, their offerings, strengths, weaknesses, market positioning, potential differentiators for this product).
- Problem/Solution validation (evidence supporting the proposed solution's value and fit for the identified problem).
- High-level technical or resource considerations (potential major roadblocks or dependencies).
2. **Formulate Research Plan:**
- Define specific, actionable research questions to address the identified gaps.
- Propose targeted research activities (e.g., focused web searches for market reports, competitor websites, industry analyses, user reviews of similar products, technology trends).
- <important_note>Confirm this research plan, scope, and key questions with the user before proceeding with research execution.</important_note>
3. **Execute Research:**
- Conduct the planned research activities systematically.
- Prioritize gathering credible, relevant, and actionable insights that directly inform product definition and strategy.
4. **Synthesize & Present Findings:**
- Organize and summarize key research findings in a clear, concise, and easily digestible manner (e.g., bullet points, brief summaries per research question).
- Highlight the most critical implications for the product's vision, strategy, target audience, core features, and potential risks.
- Present these synthesized findings and their implications to the user.
5. **Discussing and Utilizing Research Output:**
- The comprehensive findings/report from this Deep Research phase can be substantial. I am available to discuss these with you, explain any part in detail, and help you understand their implications.
- **Options for Utilizing These Findings for PRD Generation:**
1. **Full Handoff to New PM Session:** The complete research output can serve as a foundational document if you initiate a _new_ session with a Product Manager (PM) agent who will then execute the 'PRD Generate Task'.
2. **Key Insights Summary for This Session:** I can prepare a concise summary of the most critical findings, tailored to be directly actionable as we (in this current session) transition to potentially invoking the 'PRD Generate Task'.
- <critical_rule>Regardless of how you proceed, it is highly recommended that these research findings (either the full output or the key insights summary) are provided as direct input when invoking the 'PRD Generate Task'. This ensures the PRD is built upon a solid, evidence-based foundation.</critical_rule>
6. **Confirm Readiness for PRD Generation:**
- Discuss with the user whether the gathered information provides a sufficient and confident foundation to proceed to the 'PRD Generate Task'.
- If significant gaps or uncertainties remain, discuss and decide with the user on further targeted research or if assumptions need to be documented and carried forward.
- Once confirmed, clearly state that the next step could be to invoke the 'PRD Generate Task' or, if applicable, revisit other phase options.
### 1. Research Focus Options
Present these numbered options to the user:
1. **Product Validation Research**
- Validate product hypotheses and market fit
- Test assumptions about user needs and solutions
- Assess technical and business feasibility
- Identify risks and mitigation strategies
2. **Market Opportunity Research**
- Analyze market size and growth potential
- Identify market segments and dynamics
- Assess market entry strategies
- Evaluate timing and market readiness
3. **User & Customer Research**
- Deep dive into user personas and behaviors
- Understand jobs-to-be-done and pain points
- Map customer journeys and touchpoints
- Analyze willingness to pay and value perception
4. **Competitive Intelligence Research**
- Detailed competitor analysis and positioning
- Feature and capability comparisons
- Business model and strategy analysis
- Identify competitive advantages and gaps
5. **Technology & Innovation Research**
- Assess technology trends and possibilities
- Evaluate technical approaches and architectures
- Identify emerging technologies and disruptions
- Analyze build vs. buy vs. partner options
6. **Industry & Ecosystem Research**
- Map industry value chains and dynamics
- Identify key players and relationships
- Analyze regulatory and compliance factors
- Understand partnership opportunities
7. **Strategic Options Research**
- Evaluate different strategic directions
- Assess business model alternatives
- Analyze go-to-market strategies
- Consider expansion and scaling paths
8. **Risk & Feasibility Research**
- Identify and assess various risk factors
- Evaluate implementation challenges
- Analyze resource requirements
- Consider regulatory and legal implications
9. **Custom Research Focus**
[[LLM: Allow user to define their own specific research focus.]]
- User-defined research objectives
- Specialized domain investigation
- Cross-functional research needs
### 2. Input Processing
[[LLM: Based on the selected research type and any provided inputs (project brief, brainstorming results, etc.), extract relevant context and constraints.]]
**If Project Brief provided:**
- Extract key product concepts and goals
- Identify target users and use cases
- Note technical constraints and preferences
- Highlight uncertainties and assumptions
**If Brainstorming Results provided:**
- Synthesize main ideas and themes
- Identify areas needing validation
- Extract hypotheses to test
- Note creative directions to explore
**If Market Research provided:**
- Build on identified opportunities
- Deepen specific market insights
- Validate initial findings
- Explore adjacent possibilities
**If Starting Fresh:**
- Gather essential context through questions
- Define the problem space
- Clarify research objectives
- Establish success criteria
## Process
### 3. Research Prompt Structure
[[LLM: Based on the selected research type and context, collaboratively develop a comprehensive research prompt with these components.]]
#### A. Research Objectives
[[LLM: Work with the user to articulate clear, specific objectives for the research.]]
- Primary research goal and purpose
- Key decisions the research will inform
- Success criteria for the research
- Constraints and boundaries
#### B. Research Questions
[[LLM: Develop specific, actionable research questions organized by theme.]]
**Core Questions:**
- Central questions that must be answered
- Priority ranking of questions
- Dependencies between questions
**Supporting Questions:**
- Additional context-building questions
- Nice-to-have insights
- Future-looking considerations
#### C. Research Methodology
[[LLM: Specify appropriate research methods based on the type and objectives.]]
**Data Collection Methods:**
- Secondary research sources
- Primary research approaches (if applicable)
- Data quality requirements
- Source credibility criteria
**Analysis Frameworks:**
- Specific frameworks to apply
- Comparison criteria
- Evaluation methodologies
- Synthesis approaches
#### D. Output Requirements
[[LLM: Define how research findings should be structured and presented.]]
**Format Specifications:**
- Executive summary requirements
- Detailed findings structure
- Visual/tabular presentations
- Supporting documentation
**Key Deliverables:**
- Must-have sections and insights
- Decision-support elements
- Action-oriented recommendations
- Risk and uncertainty documentation
### 4. Prompt Generation
[[LLM: Synthesize all elements into a comprehensive, ready-to-use research prompt.]]
**Research Prompt Template:**
```
## Research Objective
[Clear statement of what this research aims to achieve]
## Background Context
[Relevant information from project brief, brainstorming, or other inputs]
## Research Questions
### Primary Questions (Must Answer)
1. [Specific, actionable question]
2. [Specific, actionable question]
...
### Secondary Questions (Nice to Have)
1. [Supporting question]
2. [Supporting question]
...
## Research Methodology
### Information Sources
- [Specific source types and priorities]
### Analysis Frameworks
- [Specific frameworks to apply]
### Data Requirements
- [Quality, recency, credibility needs]
## Expected Deliverables
### Executive Summary
- Key findings and insights
- Critical implications
- Recommended actions
### Detailed Analysis
[Specific sections needed based on research type]
### Supporting Materials
- Data tables
- Comparison matrices
- Source documentation
## Success Criteria
[How to evaluate if research achieved its objectives]
## Timeline and Priority
[If applicable, any time constraints or phasing]
```
### 5. Review and Refinement
[[LLM: Present the draft research prompt for user review and refinement.]]
1. **Present Complete Prompt**
- Show the full research prompt
- Explain key elements and rationale
- Highlight any assumptions made
2. **Gather Feedback**
- Are the objectives clear and correct?
- Do the questions address all concerns?
- Is the scope appropriate?
- Are output requirements sufficient?
3. **Refine as Needed**
- Incorporate user feedback
- Adjust scope or focus
- Add missing elements
- Clarify ambiguities
### 6. Next Steps Guidance
[[LLM: Provide clear guidance on how to use the research prompt.]]
**Execution Options:**
1. **Use with AI Research Assistant**: Provide this prompt to an AI model with research capabilities
2. **Guide Human Research**: Use as a framework for manual research efforts
3. **Hybrid Approach**: Combine AI and human research using this structure
**Integration Points:**
- How findings will feed into next phases
- Which team members should review results
- How to validate findings
- When to revisit or expand research
## Important Notes
- The quality of the research prompt directly impacts the quality of insights gathered
- Be specific rather than general in research questions
- Consider both current state and future implications
- Balance comprehensiveness with focus
- Document assumptions and limitations clearly
- Plan for iterative refinement based on initial findings