The Official BMad-Method Masterclass (The Complete IDE Workflow)

Tech concepts & product workflow (Claude Code + IDE “agentic” workflow)

• BMAD method masterclass focused on running the full IDE workflow using Claude Code and its agents (no need to use a separate web UI/team stack).
• Emphasizes that even with strong context windows, you should keep inputs scoped by sharding large documents so agents only load what they need.

Supported development modes

Greenfield vs. Brownfield

• Greenfield: building from scratch (“clean green pasture”).
• Brownfield: working with existing apps (“cesspool”/messy legacy), which requires extra context steps (separate brownfield BRD/PRD/architecture flows).

Core agents and their roles (workflow chaining)

1. Analyst (Mary)

   • Used for brainstorming and producing a brainstorming artifact/document.
   • Also produces a Project Brief (from YAML templates) that feeds later stages.
   • Includes elicitation methods and embedded LLM instructions inside YAML templates, designed for interactive “work back and forth” rather than one-shot output.

2. Product Manager

   • Converts the Project Brief into a PRD (Product Requirements Document).
   • Produces:
     • Functional + non-functional requirements
     • Epics and user stories
     • MVP scoping (what to cut vs. keep post-MVP)
   • Uses advanced elicitation to go beyond “average LLM responses,” including “challenge” style techniques.

3. Architect

   • Produces architecture documents section-by-section.
   • Outputs include:
     • sequence diagrams
     • high-level architecture
     • error handling strategy
     • source tree / intended project structure
     • database/data model design
     • coding standards
     • technology stack with versions
   • Strongly warns against agent “drift” (later agents selecting different frameworks/packages) by generating and enforcing a sharded technology/version table.

4. Scrum Master

   • Takes epics/stories and drafts/updates developer-ready story files.
   • Supports:
     • draft next story (e.g., “draft 1.1” / next story sequencing)
     • correct course: detect midstream mistakes and pivot story/epic/architecture/tech-stack accordingly.

5. Developer (James)

   • Implements stories step-by-step following the templated story + architecture context.
   • Maintains story-level statuses like ready for review.
   • Creates internal to-dos mapped to the story’s tasks/subtasks.

6. QA Agent (Quinn)

   • Reviews produced code against story requirements and checks for “going off the rails.”
   • Gives compliance checks/improvements and helps ensure files are placed correctly.

Key IDE / Claude Code features and operational tips

• Claude Code activation in VS Code via commands (agent selection via slash menu).
• Model selection guidance
  • Many parts demonstrated on the $20 Claude Code plan using Sonnet
  • Suggestions to use Opus for harder tasks (notably architecture/QA) for better quality.
• Context management
  • Prefer starting a new chat after producing an output document (brainstorming, brief, PRD, etc.) to avoid polluting context.
  • Use commands like clear (clears conversation history/context) and avoid relying on compaction because it may forget important details.
  • If you close Claude Code, you can resume previous chats via command history (/res, selecting prior chat).
• Sharding + document splitting
  • Uses shard/MD-tree-style splitting to create per-epic/per-story docs.
  • Ensures later agents load only relevant sections (improves context usage and reduces overload).

Installation + project scaffolding (hands-on tutorial)

• Installation does not require cloning the full GitHub repo unless extending core/expansion packs.
• Setup is shown via:
  • npx bmad-method install
  • picking BMAD core and optional settings
  • selecting IDE targets (example shown: vanilla VS Code / Cloud Code only)
• The install also provides:
  • IDE slash-commands to invoke agents
  • extra commands for tasks that don’t require an agent

Artifacts produced (documents that drive the pipeline)

• Brainstorming document (multi-technique, coach-guided ideation; saved to Docs)
• Project Brief (bootstraps PRD)
• PRD (goals, rationale, tradeoffs, assumptions; functional/non-functional requirements; epics/stories)
• Architecture (sequence diagrams, data models, error handling, source tree, coding standards, technology versions)
• Sharded epics/stories for the Scrum Master → Developer loop

Tutorial emphasis: “interactive prompting” and “advanced elicitation”

• BMAD framing: the method isn’t just letting the LLM output everything.
• Brainstorming agent acts like a coach (prompts the user to answer questions).
• Advanced elicitations “cattle prod” the LLM to critique and improve its own outputs, including scope challenge and selecting MVP cuts.
• Examples of advanced techniques mentioned:
  • Brainstorming techniques list (e.g., six thinking hats, five W’s, role-playing)
  • Advanced elicitation menu items (e.g., critique/refine, logical flow analysis, and “what-if/only if” style retrospective)

Mini example project used

• A “simple to-do app” as the greenfield demo project:
  • Node.js + TypeScript
  • CLI-based development focus in the architecture/dev flow
  • CRUD-related stories (add/list/complete/delete/update)

Reviews / quality checks

No third-party product reviews in the typical sense; the “review” content is internal QA.

• QA agent checks code placement and requirement compliance
• Development includes status gates (review-ready checkpoints)

Main speakers / sources

• Speaker: Brian (creator of the BMAD method; also demonstrates the workflow in Claude Code / Cloud Code within an IDE)
• Primary systems referenced: Claude Code and its agent suite (Analyst/Mary, Product Manager, Architect, Scrum Master, Developer “James”, QA “Quinn”)
• Supporting community resources: BMAD method docs/GitHub, Discord, and “BMAD method” tutorials (mentioned as linked from README)