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

simplified and corrected a few mistakes in mode prompts

Browse Source
This commit is contained in:
Brian Madison
2025-04-25 22:54:05 -05:00
parent d1a4bb4c31
commit 5ec77473a6
15 changed files with 46 additions and 590 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
README.md
View File

@@ -1,12 +1,10 @@
# The BMad Code Method for Pairing Human-Agentic Workflow for Product Realization and Software Development
**Breakthrough Method Agile-Ai Driven-Development (BMAD)**
**Breakthrough Method Agile-Ai Driven-Development (BMAD-METHOD)**
Join in on the [Community Discussion Forum](https://github.com/bmadcode/BMAD-METHOD/discussions), help contribute, evolve, and advance the ideas laid out here. This is IDE Agnostic, works great with Cursor, Cline, RooCode, Augment and Aider! If it has an intelligent agent, this will help you tame it and keep the good vibes flowing!
Join in on the [Community Discussion Forum](https://github.com/bmadcode/BMAD-METHOD/discussions), help contribute, evolve, and advance the ideas laid out here. This is IDE Agnostic, works great with Cursor, Cline, RooCode, CoPilot etc...! If it has an intelligent agent, this will help you tame it and keep the good vibes flowing!
Also check out [Part 1 on the BMad Code YouTube channel](https://youtu.be/JbhiLUY_V2U) - feel free to comment, like, and subscribe also for future videos and updates.
Note: Depending on which tool you use - the [[prompts folder]](./ai-pm/prompts/) should be set to be ignored my your LLM codebase indexing (ie with cursor add them to .cursorindexingignore - cline and roo may differ).
Also check out [Part 1 and 2 on the BMad Code YouTube channel](https://youtu.be/JbhiLUY_V2U) - feel free to comment, like, and subscribe also for future videos and updates.
## Overview
@@ -30,77 +28,54 @@ The BMad Method is a comprehensive, step-by-step approach that transforms a prod
### Prerequisites
- An AI assistant capable of using these prompts (Claude, GPT-4, Gemini, etc.)
- Optional - Recommended: Access to Deep Research AI
- Optional burt HIGHLY Recommended: Access to Deep Research AI
- Basic understanding of Cursor / Cline / Roo / CoPilot Agent
- A software product or project idea you want to build with AI
### How to Use with your UI or IDE of choice
#### Gemini (Google)
- Configure a Custom Gem for each mode you want to use. For example, I recommend before even going into your IDE set up the ba, pm and ux Gems at a minimum, also potentially the architect. Especially if you intend to use deep research (which you might as well with it be so great) - you will want to make use of the custom modes in Gemini.
#### Cursor
- Ensure you have Custom Modes (Beta) turned on in your cursor options
- Create the Custom Modes for each of your intended agents, going into the advanced options to give them custom prompts (copied and modified as needed from the ./custom-mode-prompts folder)
#### RooCode
- Follow this [guide](https://publish.obsidian.md/aixplore/AI+Systems+%26+Architecture/custom-modes-quick-start) along with the prompts (copied and modified as needed from the ./custom-mode-prompts folder)
#### Other IDEs
Other IDEs do not yet seem to have the exact same way of creating custom modes - but you can still use this methodology through rules, plan/act modes, and using the mode prompts as a prompt to start a new chat session.
### Workflow
The BMad Method follows a structured workflow:
1. **Idea to Documentation**: Use the prompts in order to generate all necessary project documentation
2. **Agent Rules**: Prompt Output will recommend a baseline set of rules if so desired.
3. **Kanban-style Progress Tracking**: Move generated artifacts through the folders:
- `1-ToDo`: Sequentially ordered stories waiting to be implemented
- `2-InProgress`: Stories currently being implemented
- `3-Done`: Completed stories
1. **BA:** If your idea is vague or very ambitious and you are not even sure what would or should be in an MVP - start with the BA. Use this as your brainstorming buddy, check the market conditions and competitor analysis, and let it help you elicit features or ideas you may have never considered. It can also help you craft a great prompt to trigger deep research mode to really get advice and analysis of your fleshed out idea. The output will be a **Project Brief** which you will feed to the PM.
2. PM: Either give the PM the Project Brief, or describe manually your project if you understand it well enough. The PM will ask you clarifying questions until it feels comfortable drafting the PRD with enough detail to enable eventual agent development. This will include a high level story breakdown and sequence. The output will be a **PRD**. You can give some platform and technical ideas to the PM if you already know them - or wait to work with the architect. If you are already sure of the platform languages and libraries you are sure you want to use, best to specify them now, or even prior to this in the project brief.
3. UX Expert: This is a special purpose agent that is good at one thing, taking the idea from the PRD and helping elict and flesh out a prompt tuned to get great results from V0 or similar UI generators. But you can also use the UX Expert to just help flesh out more details for the PRD before we hit the architect.
4. Architect: If your project is technically complex, or you did not know all of the technical details with the PM, pull in the architect to produce an architecture document, and also ensure that it and the PRD are both in alignment. You can also push the Architect into Deep Research mode - use it to research potential alternative technologies, find if others have done similar things already (don't always need to reinvent the wheel), and maybe even suggest a whole new approach. If you do deep research, its best to take the time to understand it and ensure anything you want to use is incorporated back into the architecture draft and PRD. IF its so drastically different, you may want to go all the way back to the project brief. This is where upfront planning really plays off before we start burning up LLM agent credits!
5. PO: At this point, the PO may be unnecessary - but if you have produced a PRD, Architecture, and potentially some UX content - the PO is a good reviewer to ensure that our stories are high level but properly sequenced in the PRD - or can make updates as needed.
6. DEV: Finally we are ready for development! The Dev agent is set to work on 1 story at a time, and will create a story in draft mode for your review before starting to work on it. The story will follow the template in the ai folder and create it at /ai/stories/ following a naming convention of story-{epic}.{story}.md.
1. Once you approve of the story, the dev will work on it and update its progress. It will use the PRD and Architecture documents as reference to draft ths stories and ensure the level of detail is in the story.
2. It is recommended to start a new chat with each story - and potentially even after transitioning a story to In-Progress (from draft) so its starts with a clean context overhead ready to execute. But see what works best for your workflow.
3. I always recommend having tests done with each story (ideally even follow TDD) and ensure all stories are passing in the whole project. Once they are and the story is complete - commit and push to the remote!!!
## Prompt Sequence
## Why no prompts folder
The `prompts` folder contains carefully crafted prompts for each phase of development.
This is for the most broadly ambitious project MVP
The separate prompts folder was removed as it was redundant to maintain that along with the custom-mode-prompts. If you are using a tool without custom modes - the prompts still work as is, you will just use the idea and paste it into the chat to set up the LLMs operations, personality and behavior.
1. **Research Assistant: Analysis** (`0-research-assistant.md`): Optional deep research on your product concept
2. **Business Analyst: Project Brief** (`1-business-analyst.md`): Define your product idea and MVP scope
3. **Product Manager: PRD** (`2-PM.md`): Create detailed product requirements
4. **PM/UX/UI: UI Gen Prompt** (`3-PM-UX-Ui.md`): Define comprehensive UI/UX specifications
5. **Architecture Deep Research: PRD Updates** (`4-Arch-Deep.md`): Optional deep research step for Up tp date best practice and rules generation
6. **Architect: Arch Doc** (`5-Arch.md`): Create a detailed architectural blueprint
7. **Technical Product Owner: Epic Story List** (`6-PO.md`): Break down requirements into implementable stories
8. **Technical Scrum Master: Agent Story Files** (`7-SM.md`): Transform stories into Dev Agent ready super detailed stories (it is not recommended to generate all stories with this up front - instead favor using the /role-prompts/dev.md agent with builtin workflow to craft story 1 by 1 as needed to implement.)
## What about rules files?
## Key Benefits
- **Save Time and Money**: Predictable implementation flow with less costly rework or Agent credit burn that Vibe coding along produces
- **Consistent Documentation**: Generate comprehensive, aligned artifacts
- **AI-Optimized Workflow**: Structured Kanban Stories specifically designed for Human or AI implementation
- **Reduced Technical Debt**: Ensure architectural consistency from the start
- **Simplified Collaboration**: Clear artifacts for all stakeholders, Human and AI
## How To
Recommend checking out this video series starting with [Part 1 on the BMad Code YouTube channel](https://youtu.be/JbhiLUY_V2U) and also checking the [Discussion Forum](https://github.com/bmadcode/BMAD-METHOD/discussions) in the coming days where BMad and the community hopefully will share and collaborate and give further tweaks tips and tricks!
But the **Quick and Dirt**y is:
1. Clone this project
2. Start with the first prompt in `prompts/0-research-assistant.md` (or skip to 1 if research isn't needed) to do market research with an LLM's deep research capabilities
3. Follow each prompt in sequence, providing output from previous steps as context to the new prompt when indicated in the current prompt
4. One the PO generates the final story list, paste it back into the PRD.
5. Generate each detailed user story and implement it 1 by 1. The stories serve as the memory system and history of incremental agile development.
6. Track progress until all stories are completed to realize the MVP.
My recommendation is to take advantage of Google Gemini or ChatGPT web apps for generation of deep research brain storming, PRD, and deep research for the architecture if needed. Beyond that, its easy enough to take the pieces of artifacts needed to put the markdown into the project ai folder, and then use prompts from within the IDE to generate the file architecture, story list updates to the PRD from the PO, and eventual story generation.
## Modifications
This is just an idea of what works for me to increamentally build up complex applications from idea to inception. But I use variants of this to work in existing code bases, where I will lay out a PRD with task lists and use the architecture document to put in place guardrails and further details the LLM needs to understand if it is not already in place.
The sharing of all these prompts are just suggestions - I HIGHLY recommend you use these ideas to tweak and refine what works for you! Experiment with different models, and over time they will improve.
For small projects, just a PRD and the story files can be more than sufficient. And for more ambitious or unknowns, use the brainstorming step and deep research to help you out.
Valid produce artifacts for the application such as source trees, rules, architecture documentation can provide value beyond the initial implementation of the task at hand can can live with the project, usually moved into the docs folder, and also rules can be added to CONTRIBUTING.md. By putting rules in this file, it can be used by humans and ai tools.
For example in cursor, with a good contributing file, you can have an always rule to always reference the contributing.md file for its core rule set. And then if you use Cline or CoPilot, you can do similar with their rule systems or agent custom instructions.
You can still augment with rules files per your specific tool to put more guardrails in place. If you are going to use multiple tools and do not want to maintain a lot of different rule sets - you can instead add rules to non rules files such as docs, or contributing.md for example. And then just have a single rule that indicates the agent should reference these files when needed. YMMV with the approach - I have found it to work well enough - especially with the embedded agent modes rules.
## Future Enhancements
1. BMad Method Tool
2. Improved Gems
3. MCP Version if wanting to do fulling within the IDE
4. Optional Jira Integration
5. Optional Trello Integration
1. BMad Method MCP Tool
## Contributing