The BMad Method has undergone a significant transformation with our V2 (beta) release! The previous implementation (still available in the LEGACY-V1 folder) has been replaced by a drastically improved workflow and agent system in the CURRENT-V2 folder.

What's New in V2?

Optimized Agent Prompts: Completely revised agent prompts for better outputs
Standardized Templates: Comprehensive set of templates for consistent document creation
Streamlined Workflow: Clearer process from idea to deployment
Improved Agile Integration: Better support for agile methodologies
Agent vs Gem Agent Distinction: V2 has specific gems (agent with embedded templates) in parity with the IDE agents.

No Rules Required!

One of the biggest advantages of the BMad Method is that it doesn't require custom rules when using the custom agents. The dev agents and other personas are configured to automatically reference standards documents when coding. This provides two major benefits:

No Platform Lock-in: Work across any AI system without being tied to proprietary rule formats
Maximum Flexibility: Still compatible with rules-based systems like Claude or Cursor if you prefer that approach

This flexibility allows you to choose the implementation that works best for your workflow while maintaining consistent quality across your project.

What is the BMad Method?

The BMad Method is a revolutionary approach that elevates "vibe coding" to the next level—what I call "Vibe CEOing." Unlike the spontaneity of pure vibe coding for quick prototypes, this method helps you plan, execute, and keep your project on track. Build faster, cheaper, and easier while leveraging AI-driven processes to accelerate and enhance the entire product development lifecycle from ideation and market fit through agentic code implementation.

This V2 release incorporates valuable feedback from V1 users and draws inspiration from projects like Claude's memory bank and the Taskmaster project. However, the BMad Method goes further by providing a comprehensive framework for those who want to thoroughly define and develop projects from conception to completion.

This comprehensive, step-by-step approach transforms a product idea into a fully implemented application by:

Structuring the development process into distinct AI persona-based phases
Generating detailed artifacts at each phase
Using a sequential workflow to track progress
Enabling AI to code the full application based on generated specifications

The method is tool agnostic with a workflow built into the role-prompts, making it adaptable to any agentic coding toolset, IDE, or platform.

Join the Community Discussion Forum to help contribute and evolve these ideas.

Video Tutorials

The legacy workflow is explained in Part 1 and 2 on the BMad Code YouTube channel
A new tutorial for the V2 workflow will be coming soon - with a full end to end project build!

Coming Soon(ish)

A fully output of a simple and advanced project artifact files of executing the agents to build all the artifacts for a project build with prompt examples that lead to the output from the agents.
Exploration into leveraging MCP.

Workflow Visual Diagram

View Diagram

Custom Agent Overview

Analyst (Business Analyst (BA), Research Assistant (RA), Brainstorming Coach)

The Analyst agent is a versatile entry point into the BMad Method, operating in three distinct modes: Brainstorming Coach, Deep Research, and Project Briefing. It helps transform initial ideas or vague concepts into well-defined project briefs through creative ideation techniques, market analysis, or structured requirement gathering. In Brainstorming mode, it uses proven techniques like SCAMPER and "What if" scenarios to expand possibilities. The Deep Research mode generates comprehensive research prompts to explore market needs, competitors, and target users. Finally, the Project Briefing mode collaboratively builds a structured brief document with a dedicated PM Agent Handoff Prompt section that provides strategic guidance for the next phase. This agent is ideal for users who need help refining their vision before moving to detailed product definition.

Product Manager (PM)

The Product Manager agent excels at transforming high-level project briefs or initial ideas into comprehensive product specifications and actionable development plans. As a scope refinement specialist, the PM actively challenges assumptions about what features are truly necessary for the MVP, seeking opportunities to reduce complexity while ensuring perfect alignment with core business goals. The PM creates three key artifacts: a detailed Product Requirements Document (PRD) outlining goals, functional and non-functional requirements; a set of epic definitions that break down the work into independently deployable chunks; and an Initial Architect Prompt that captures critical technical decisions. Throughout the process, the PM engages in multiple rounds of scope refinement—first during initial scoping discussions, then after drafting the PRD, and finally after creating epics—always framing conversations around time, cost, and quality tradeoffs. The PM also identifies deployment considerations and testing requirements (if valued by stakeholders), ensuring each epic builds logically on previous ones with Epic 1 containing all necessary infrastructure setup. This agent is essential for users who need to translate their vision into a practical, well-structured development plan with appropriate scope for an MVP.

Architect

The Architect agent is an expert Solution/Software Architect that operates in three distinct modes to support technical design throughout the product development lifecycle. With deep knowledge across cloud platforms, architectures, databases, and programming languages, the Architect translates requirements into robust, scalable technical designs optimized for AI agent implementation.

Mode 1: Deep Research Prompt Generation

This mode creates comprehensive research prompts to investigate technology options, platforms, services, and implementation approaches before making architectural decisions. The Architect analyzes available project context, identifies research gaps, and structures detailed prompts that define clear objectives, outline specific questions, request comparative analysis, and establish evaluation frameworks for decision-making.

Gem Mode Bonus: The GEM version includes an extensive example research prompt template for backend technology stack evaluation that demonstrates how to structure comprehensive technology investigations. This template showcases how to define research objectives, specific technologies to investigate, evaluation dimensions, implementation considerations, and decision frameworks—providing a blueprint for creating targeted research prompts for any technical domain.

Mode 2: Architecture Creation

In this mode, the Architect designs and documents the complete technical architecture based on the PRD, epics, and project brief. The agent makes definitive technology decisions (not open-ended options), explains the rationale behind key selections, and produces all necessary technical artifacts including detailed architecture documentation, tech stack specifications, project structure, coding standards, API references, data models, environment variables, and testing strategies—all optimized for implementation by AI agents.

Mode 3: Master Architect Advisory

This mode provides ongoing technical guidance throughout the project, explaining concepts, suggesting updates to artifacts, and managing technical direction changes. The Architect assesses change impacts across the project, recommends minimally disruptive approaches for course corrections, identifies technical debt, and ensures all significant decisions are properly documented. The agent uses clear Mermaid diagrams to visually represent system structure and interactions when beneficial for clarity.

Product Owner (PO)

Scrum Master (SM)

Dev Agent (Dev)

Step-by-Step Process

Phase 0: Ideation (Optional)

Start with the Business Analyst (BA) agent if your idea is vague
The BA will help analyze market conditions and competitors
Output is a Project Brief used as input for the Product Manager

If you are unsure, start by saying something like the following to brainstorm with the BA with this simple goal eliciting prompt:

I have an idea for an app I want to brainstorm with you,
it can do (X)
so that (y)
for (Z) user(s)

Example: 'I have an idea for an app I want to brainstorm with you, it can help small business owners automatically generate professional social media content, so that they can maintain consistent online presence without hiring expensive marketing agencies, for time-starved entrepreneurs who know social media is important but don't have the skills or time to create quality content daily'

Phase 1: Product Definition

The Product Manager (PM) agent takes the project brief or your idea
PM creates a comprehensive Product Requirements Document (PRD) along with high level epic / story flow docs. (Separate files reduce overall context for future agents - this is in the V2+ version)
Initial epic breakdowns are drafted

Phase 2: Technical Design

The Architect agent reviews the PRD and creates an architecture document and in V2 granular artifacts that optimize for LLM context space of chosen future agents!
Architect identifies technical dependencies and reference files
Optional: Use Deep Research mode for more in-depth technical exploration

Phase 3: Refinement and Validation

PM, Architect, and Scrum Master collaborate to refine the plan
Product Owner (PO) validates scope, story sequence, and PRD alignment
Final documents are approved and indexed

Phase 4: Story Generation

Technical Scrum Master generates each story 1 at a time for the dev to complete, (OR in Gem/GPT mode it will do all remaining stories). The output story or stories are highly detailed stories with all technical details the agent will need to keep instructional context lean - not having to search all of the larger documents bloating its context with unnecessary information.

Phase 5: Development

The Developer Agent works on stories one at a time
Developer creates draft stories for review before implementation
Code and tests are committed, and story files are updated

Phase 6: Review and Acceptance

Code reviews by a new Dev Agent or Architect
Functionality reviews by User/QA
Story marked as Done when approved

Phase 6.5: Refactor (Optional Step)

Architect or Dev Agent in a new Content, or the User, refactor as needed and ensure if refactor changes structure that source tree diagrams and future implementation documents are updated as needed.
This is not required after most stories with properly following the phases before #5 producing a solid plan and architecture - but even the best plans can lead to the emergence of an idea for beautiful restructuring. Also, best laid plans can still lead to an agent doing less than ideal things that are better to correct.
Remember, the main key with refactoring at this stage is ensure all was working first, the full app and new functionality has passing tests and linting, has been committed, and pushed to the remote branch. Only then would I take on a major (or even minor refactor) in most cases. If I am doing the refactor myself, I have more trust and might do it before pushing and calling the story done. But with the agent, always lock down your working changes so you have an escape hatch to revert to!

Phase 7: Deployment

Developer Agent handles deployments
Infrastructure as Code is used for deployment commands
System is updated with the new functionality

Template Dependencies

Important: The agents (not gems) in this system rely on template files located in the CURRENT-V2/docs/templates folder. These templates should remain named as they are for proper functionality and put in your projects docs/templates folder, including:

architecture.md
story-template.md
prd.md
project-brief.md
etc... (all of the template files)

Custom GEMs and GPTs (Highly Recommended)

Using Agents with Web-Based AI Interfaces (Highly recommended, save lots of money, larger context windows, deep research is a game changer)

The gems folder contains agent instructions embedded with optimized web use instructions - streamlined for usage within the Gemini Gems, or OpenAIs custom GPT's. With both custom GPTs and Gemini Gems, you will attach the templates now instead of embedding them (as was the case with V1 of this system, that was not as easy to modify). This way, as you modify templates from the templates folder, if you want to change it in the web version just save it as a .txt extension and attach to the custom GEM or GPT.

Detailed set up and usage instructions are available in the folder also.

IDE Integration

The method works with any IDE or AI assistant with these approaches:

Custom Modes: For IDEs that support custom modes (Cursor, RooCode)
Custom Gems: For Gemini, create a Custom Gem for each agent
Direct Prompting: For any AI assistant, use the agent prompts directly

License

Contributing

Interested in improving the BMad Method? See our contributing guidelines.