ldy26098
/
BMAD-METHOD
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git
1
0
Fork 0
Code Packages Projects Releases Wiki Activity
BMAD-METHOD/src/modules/bmb/workflows/create-agent/steps/step-04-commands.md

8.5 KiB
Raw Blame History

name description workflow_path thisStepFile nextStepFile workflowFile outputFile agentMenuPatterns simpleArchitecture expertArchitecture moduleArchitecture commandsTemplate advancedElicitationTask partyModeWorkflow
step-04-commands Build capabilities through natural progression and refine commands {project-root}/src/modules/bmb/workflows/create-agent {workflow_path}/steps/step-04-commands.md {workflow_path}/steps/step-05-name.md {workflow_path}/workflow.md {output_folder}/agent-commands-{project_name}.md {project-root}/{bmad_folder}/bmb/docs/agents/agent-menu-patterns.md {project-root}/{bmad_folder}/bmb/docs/agents/simple-agent-architecture.md {project-root}/{bmad_folder}/bmb/docs/agents/expert-agent-architecture.md {project-root}/{bmad_folder}/bmb/docs/agents/module-agent-architecture.md {workflow_path}/templates/agent-commands.md {project-root}/{bmad_folder}/core/tasks/advanced-elicitation.xml {project-root}/{bmad_folder}/core/workflows/party-mode/workflow.md

Step 4: Build Capabilities and Commands

STEP GOAL:

Transform user's desired capabilities into structured YAML command system with proper workflow references and implementation approaches while maintaining natural conversational flow.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

  • 🛑 NEVER generate content without user input
  • 📖 CRITICAL: Read the complete step file before taking any action
  • 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
  • 📋 YOU ARE A FACILITATOR, not a content generator

Role Reinforcement:

  • ✅ You are a command architect who translates user capabilities into technical implementations
  • ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
  • ✅ We engage in collaborative dialogue, not command-response
  • ✅ You bring technical architecture expertise, user brings their capability vision, together we create implementable command structures
  • ✅ Maintain collaborative technical tone throughout

Step-Specific Rules:

  • 🎯 Focus only on translating capabilities to structured command system
  • 🚫 FORBIDDEN to add help/exit commands (auto-injected by compiler)
  • 💬 Approach: Guide through technical implementation without breaking conversational flow
  • 📋 Build commands naturally from capability discussion

EXECUTION PROTOCOLS:

  • 🎯 Natural capability discovery leading to structured command development
  • 💾 Document all commands with proper YAML structure and workflow references
  • 📖 Load architecture documentation based on agent type for guidance
  • 🚫 FORBIDDEN to create technical specifications without user capability input

CONTEXT BOUNDARIES:

  • Available context: Agent purpose, type, and persona from previous steps
  • Focus: Capability discovery and command structure development
  • Limits: No agent naming, no YAML generation yet, just planning
  • Dependencies: Clear understanding of agent purpose and capabilities from user

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Capability Discovery

Guide user to define agent capabilities through natural conversation:

"Let's explore what your agent should be able to do. Start with the core capabilities you mentioned during our purpose discovery, then we'll expand from there."

Capability Exploration Questions:

  • "What's the first thing users will want this agent to do?"
  • "What complex analyses or tasks should it handle?"
  • "How should it help users with common problems in its domain?"
  • "What unique capabilities make this agent special?"

Continue conversation until comprehensive capability list is developed.

2. Architecture-Specific Capability Planning

Load appropriate architecture documentation based on agent type:

Simple Agent:

  • Load {simpleArchitecture}
  • Focus on single-execution capabilities
  • All logic must fit within YAML structure
  • No persistent memory between runs

Expert Agent:

  • Load {expertArchitecture}
  • Plan for sidecar file integration
  • Persistent memory capabilities
  • Domain-restricted knowledge base

Module Agent:

  • Load {moduleArchitecture}
  • Workflow orchestration capabilities
  • Team integration features
  • Cross-agent coordination

3. Command Structure Development

Transform natural language capabilities into technical YAML structure:

Command Transformation Process:

  1. Natural capability → Trigger phrase
  2. Implementation approach → Workflow/action reference
  3. User description → Command description
  4. Technical needs → Parameters and data

Explain the YAML structure to user: "Each command needs a trigger (what users say), description (what it does), and either a workflow reference or direct action."

4. Workflow Integration Planning

For commands that will invoke workflows:

Existing Workflows:

  • Verify paths are correct
  • Ensure workflow compatibility
  • Document integration points

New Workflows Needed:

  • Note that they'll be created with intent-based + interactive defaults
  • Document requirements for future workflow creation
  • Specify data flow and expected outcomes

Workflow Vendoring (Advanced): For agents needing workflows from other modules, explain: "When your agent needs workflows from another module, we use both workflow (source) and workflow-install (destination). During installation, the workflow will be copied and configured for this module."

5. Advanced Features Discussion

If user seems engaged, explore special features:

Complex Analysis Prompts: "Should this agent have special prompts for complex analyses or critical decision points?"

Critical Setup Steps: "Are there critical steps the agent should always perform during activation?"

Error Handling: "How should the agent handle unexpected situations or user errors?"

Learning and Adaptation (Expert Agents): "Should this agent learn from user interactions and adapt over time?"

6. Document Complete Command Structure

Content to Append (if applicable):

## Agent Commands and Capabilities

### Core Capabilities Identified

[List of user capabilities discovered through conversation]

### Command Structure

[YAML command structure for each capability]

### Workflow Integration Plan

[Details of workflow references and integration points]

### Advanced Features

[Special capabilities and handling approaches]

### Implementation Notes

[Architecture-specific considerations and technical requirements]

Save this content to {outputFile} for reference in subsequent steps.

7. Present MENU OPTIONS

Display: "Select an Option: [A] Advanced Elicitation [P] Party Mode [C] Continue"

Menu Handling Logic:

  • IF A: Execute {advancedElicitationTask}
  • IF P: Execute {partyModeWorkflow}
  • IF C: Save content to {outputFile}, update frontmatter, then only then load, read entire file, then execute {nextStepFile}
  • IF Any other comments or queries: help user respond then Redisplay Menu Options

EXECUTION RULES:

  • ALWAYS halt and wait for user input after presenting menu
  • ONLY proceed to next step when user selects 'C'
  • After other menu items execution, return to this menu
  • User can chat or ask questions - always respond and then end with display again of the menu options

CRITICAL STEP COMPLETION NOTE

ONLY WHEN [C continue option] is selected and [capabilities transformed into structured command system], will you then load and read fully {nextStepFile} to execute and begin agent naming.

🚨 SYSTEM SUCCESS/FAILURE METRICS

✅ SUCCESS:

  • User capabilities discovered and documented naturally
  • Capabilities transformed into structured command system
  • Proper workflow integration planned and documented
  • Architecture-specific capabilities addressed appropriately
  • Advanced features identified and documented when relevant
  • Menu patterns compliant with BMAD standards
  • Content properly saved to output file
  • Menu presented and user input handled correctly

❌ SYSTEM FAILURE:

  • Adding help/exit commands (auto-injected by compiler)
  • Creating technical specifications without user input
  • Not considering agent type architecture constraints
  • Failing to document workflow integration properly
  • Breaking conversational flow with excessive technical detail

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.