Great work — V3 has become incredibly feature-rich and flexible

[Geserit2]

That said, the sheer range of customization options felt overwhelming. In my initial test, it was hard to tell who’s supposed to do what — everyone seems to be able to do everything, but at the same time, not really.

I’m sure the system is extremely powerful once you deeply understand the connections and workflows, and how to benefit from all the personalization. But as a starting point, it’s just too much.

What I’m missing is a clear, guided structure and a logical flow that makes it easy to get started.

[dracic]

But the BMAD Agent can tell you exactly that.

[dracic]

[dracic]

BMAD Agent can follow your logic and your language:

So:

1. BMAD AI lutmey vItu' DIS poHmey DasteghDI'.
2. SoH "Vibe CEO", AI lutmeylIj vItIvbe'.
3. qechmeyvam De' nI'qu' vISovrup.
4. DasteghDI' tlhapDI' ngebDaq je tlhapchoH.

[dracic]

I told BMAD to make mermaid chart of himself, then to explain it and explain overlapping tasks:

Explanation of the Workflow with Concise Agent Tasks:

1. Start Project: The initiation point for your project.
2. Need Deep Exploration?: You decide if initial ideation requires deep research.
   • Yes: Engage the Analyst, who performs "Brain Storming", "Deep Research", and "Project Briefing".
   • No / Has Brief: Proceed directly to the Product Manager (PM).
3. Product Manager (PM): Handles product definition and planning, capable of "Create Prd", "Correct Course", and "Create Deep Research Prompt".
4. Project Has UI?: Determine if your project involves a user interface.
   • Yes: Engage the Design Architect (DA) for UI/UX and frontend architecture. Their tasks include "Create Frontend Architecture", "Create Ai Frontend Prompt", and "Create UX/UI Spec".
   • No: Proceed directly to the Architect.
5. Architect (ARCH): Focuses on the main system architecture, performing "Create Architecture" and "Create Deep Research Prompt".
6. Product Owner (PO): Validates documents, ensures sequencing, and manages the backlog. Their tasks include "Checklist Run Task", "Draft a story for dev agent", "Extracts Epics and shard the Architecture", and "Correct Course".
7. PO or Scrum Master (SM): Responsible for generating individual user stories. The SM's tasks are "Checklist Run Task", "Correct Course", and "Draft a story for dev agent".
8. Developer Agents (DEV): Implement the user stories, their primary task being "Implement Stories".
9. Story Complete?: After implementation, verify story completion.
   • Yes: Loop back to the PO or SM to generate the next story.
   • No / Major Change: If there's an issue or a major change, the PO or SM can intervene for "Correct Course".
10. Project Done / MVP Achieved: The project concludes upon reaching the MVP.
11. End Workflow: The workflow terminates.

The overlapping tasks indicate areas where multiple agents have the capability or responsibility to initiate or participate in a specific activity, often with a slightly different focus or at a different stage of the workflow. This allows for flexibility and ensures that critical processes can be handled by the most appropriate agent given the current context or the user's preference.

Here are the key overlapping tasks:

1. "Correct Course"

   • Agents Involved: Product Manager (PM)[cite: 4], Product Owner (PO)[cite: 7], Scrum Master (SM)[cite: 8].
   • Explanation of Overlap: This task is crucial for adapting to changes or addressing issues that arise during the project.
     • PM's Focus: The PM, being the product strategist, would likely use "Correct Course" when the change impacts the core product vision, scope, or strategic goals outlined in the PRD. They might initiate it for major pivots or re-scoping[cite: 34, 35, 57, 58, 59, 60, 61].
     • PO's Focus: The PO, as the Agile Product Owner, is explicitly noted to "help midstream development replan or course correct if major changes occur"[cite: 394, 395]. Their "Correct Course" would focus on adjusting the backlog, re-prioritizing stories, and ensuring that the development sequence remains logical despite the change, all while considering the "change-checklist"[cite: 24, 354].
     • SM's Focus: The SM, as a technical Scrum Master, would use "Correct Course" to facilitate the team's adaptation to the change, ensuring the Scrum process isn't derailed and that impediments are addressed. Their role is more about the process of adapting rather than the strategic product changes itself, though they would also leverage the "change-checklist"[cite: 360, 361].
   • Purpose of Overlap: This overlap ensures that regardless of who identifies a need for correction (from product vision to daily development), there's an agent ready to guide the process, leveraging the change-checklist [cite: 24] for a structured approach.

2. "Create Deep Research Prompt"

   • Agents Involved: Product Manager (PM)[cite: 4], Architect (ARCH)[cite: 5].
   • Explanation of Overlap: This task is about formulating a detailed prompt to guide in-depth research, presumably by a dedicated research model or function.
     • PM's Focus: The PM would use this to validate product hypotheses, refine target audiences, conduct focused competitive analysis, or de-risk PRD commitments before detailed planning. It's about strategic insights for product definition[cite: 740, 741, 742, 743, 744, 745, 746].
     • Architect's Focus: The Architect would use this to research specific technical solutions, feasibility, new technologies, or complex integration patterns required for the architecture. Their research would directly inform technical design decisions[cite: 345].
   • Purpose of Overlap: This allows both product and technical leads to initiate targeted research for their respective domains, ensuring that all major decisions are data-informed. The output is a prompt, ready for a research execution tool.

3. "Checklist Run Task"

   • Agents Involved: Product Owner (PO)[cite: 7], Scrum Master (SM)[cite: 8].
   • Explanation of Overlap: This task is about validating documentation or processes against a predefined checklist.
     • PO's Focus: The PO uses this extensively for "PO Master Checklist" (for overall plan validation), "Story Draft Checklist" (for ensuring stories are ready for dev), and "Change Checklist" (for managing impacts of changes)[cite: 355]. Their focus is on the completeness and quality of product-related artifacts and the readiness of work for development[cite: 556].
     • SM's Focus: The SM also uses "Checklist Run Task" for "Change Checklist" and "Story DoD Checklist" (Definition of Done)[cite: 361]. The SM's application would be more about ensuring the process adherence, quality gates for development work (DoD), and helping the team facilitate changes effectively[cite: 577].
   • Purpose of Overlap: This ensures that critical validation steps and process adherence can be driven by either the PO (content and readiness focus) or the SM (process and quality-gate focus), depending on who is managing the immediate workflow.

4. "Draft a story for dev agent"

   • Agents Involved: Product Owner (PO)[cite: 7], Scrum Master (SM)[cite: 8].
   • Explanation of Overlap: This task involves preparing a comprehensive, self-contained, and actionable story file for a Developer Agent[cite: 831].
     • PO's Focus: The PO is primarily responsible for the product backlog and ensuring stories deliver value. They would draft stories directly based on the PRD and epics, ensuring acceptance criteria and technical context are clear for development[cite: 354, 564].
     • SM's Focus: The SM, especially a technical one, often works closely with the development team and the PO in refining stories. They might draft stories or assist in their refinement, particularly focusing on making them ready for implementation and ensuring they meet the "Story Draft Checklist" criteria for clarity and technical guidance[cite: 361, 232].
   • Purpose of Overlap: This reflects the collaborative nature of story refinement in Agile. While the PO owns what the story is, the SM often plays a critical role in facilitating how that story is prepared for the development team, ensuring it's technically sound and clear.

In summary, these overlaps are by design, allowing the BMAD Method to maintain flexibility and resilience. They enable different agents to step in based on their primary responsibilities and expertise, ensuring that critical project functions are always covered and that the team can adapt efficiently to various situations.

[OverlordBaconPants]

Seems odd it would generate a mermaid diagram with two "No" paths coming from a simple decision diamond. The written-out description contradicts the diagram showing a redundant path leading to the Product Owner. Otherwise, this is a solid description of the workflow.

[dracic]

Project Has UI?: Determine if your project involves a user interface.

• Yes: Engage the Design Architect (DA) for UI/UX and frontend architecture. Their tasks include "Create Frontend Architecture", "Create Ai Frontend Prompt", and "Create UX/UI Spec".
• No: Proceed directly to the Architect.

Perhaps an AI fix in MermaidChart made that. Gemini almost always messes up Mermaid charts. I didn't invest too much time in this, as my intention wasn't to create documentation. I just wanted to point out that this system is self-explanatory, and we don't need extensive documentation

[dracic]

Nice tool to make Marmaid diagrams even nicer, and even has AI Fix for Gemini f...k ups:

https://www.mermaidchart.com/

[bmadcode]

Thank you! This is great showing the ability to ask the llm :) one of the ideas of the bmad agent and it also having the kb was to help people. Once it's set up, the agent mode especially in gemini is super helpful 😀

…

On Tue, May 27, 2025, 12:25 PM Davor Racic ***@***.***> wrote: *Project Has UI?*: Determine if your project involves a user interface. - *Yes*: Engage the *Design Architect (DA)* for UI/UX and frontend architecture. Their tasks include "Create Frontend Architecture", "Create Ai Frontend Prompt", and "Create UX/UI Spec". - *No*: Proceed directly to the Architect. Perhaps an AI fix in MermaidChart made that. Gemini almost always messes up Mermaid charts. I didn't invest too much time in this, as my intention wasn't to create documentation. I just wanted to point out that this system is self-explanatory, and we don't need extensive documentation — Reply to this email directly, view it on GitHub <#102 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BOTVGQOPFUESXRUKLVPZT533ASNZBAVCNFSM6AAAAAB57MZNT6VHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTGMRYGY3TMOI> . You are receiving this because you are subscribed to this thread.Message ID: ***@***.*** com>

[bmadcode]

@Geserit2 I do get what you mean - there are a lot of options, overlap and customizations by design, and I think what is needed is a few prebuilt setups for the web agent instead of the single folder. I had not considered that many might want to copy and just use the sample as is. For example, I did not imagine people would not add their own names, personas etc... but to be fair, I also have not clearly laid out the idea clearly in the videos yet around the idea that this is also meant to be customized (but does not HAVE to be).

So all that to say - I am going to make a few sample build folders - and within them, not have any overlap. The overlap of agents doing the same tasks was meant to showcase how you can any agent do anything, and their different personalities could even have different outcomes - but I think for most its overkill and could get by with a small subset of personas or more personas but single focused.

Really though then that has me then questioning well what is the most useful for most and I dont know - some might want just 1 agent, BMad that can just do any task - some might want different personalities to help, and then some just want the simple prd and a list of tasks and subtasks, which I also envision this system can do but have not really added into it yet.

[opprfloris]

thanks for the explanation, but looking at the responses i think there is this general feeling that while the method is very very elaborate and covers all fields, still there seems to be an explanation missing on how to approach this and get it up and running quickly using for instance the combination of Gemini Gems + Windsurf/ Cursor.

What ive done now:

1. gone through ideation process
2. Created a project brief
3. Created a PRD
4. Created a Architecture
5. Created UI/UX Specification
6. Created AI Front-End Promp to test out some UI in lovable

From what i read, we need to add PRD.md and Architecuture.md to the Docs folder. (feedback from the BMAD creator and i saw this in the movie.) But the instruction doc also says you need these folders:

checklists/
data/
personas/
tasks/
templates/

However, you also need to shard the prd.md into epics for better readability (i did that with a really nice prompt provided (#111)

Now you create seperate outputs in gemini which you can paste as epic-1.md/ epic-2.md etc into the docs folder.

But then again, you can also do with internally with agents..

Im just lost here, there seems to be interchangeably being referenced between what you should do on the web and what you can do within the IDE.

What i really need to understand better: What should you do in Gemini, and what should you do in the IDE?

Would be nice to have a template folder as a basis for starting a new project, but this repo is stuffed with other stuff that for me (im a beginner) is quite confusing

[bmadcode]

Responded below message before I saw this one - so Ill just add the following folders, just copy in the whole bmad-agent folder to your project and they will be default in the right location.

A project template folder - thats a good idea, I can add that soon. Also considering adding a script that can run, and copy for you the files needed for a project (but again its literally just copy the bmad-agent folder)

checklists/
data/
personas/
tasks/
templates/

[CenterSites]

Same here
"What i really need to understand better: What should you do in Gemini, and what should you do in the IDE?"

[3stepwin]

I'm confused as well I just copy gitrep and pasted link into roocode and tell it to add it to project

[bmadcode]

I see - I recommend do AS MUCH AS POSSIBLE in Gemini - it depends on your needs honestly. If you are not sure, I would start with everything up through generating the full brief, PRD, architecture, design architecture, PO checklist analysis. Then still in gemini potentially if the context has not run out (or start a new chat if it seems to be forgetting how to function) - work with the PO to ensure any corrections from the architect or the PO checklist run are reincorporated as needed into the epics and stories.

Once you do that, then you can ask the PM to give you the Full PRD with no redacted sections.
Then get the full architecture docs with no redacted sections.

put these large /docs in your docs folder in your project.

Now - you will want to use the doc sharding task against the PRD and the architecture - I realize now I did not cover this well int he last video - but the goal is to create the smaller files the scrum master will use.

There is a great issue/suggestions to build a python or node script to do this instead of relying on the LLM, so I am going to work on a simple update - so once done you will just be able to run a command to 'shard' the documents.

The purpose of sharing (in theory) is to have smaller documents the dev agent can eventually refer to as needed, without having to read full large documents and bloating its context. Similar for the SM when the agent is drafting the very detailed task list stories for the dev agent.

[dracic]

That's an excellent and very practical question! Understanding where to leverage the strengths of a powerful, conversational AI like Gemini (often via its web UI or a similar broad-context interface) versus an AI agent integrated into your IDE (like Windsurf or Cursor) is key to an efficient BMAD workflow.

Here’s a breakdown based on the BMAD method's design principles:

Typically, you'd use a direct interface with a powerful LLM like Gemini (or a "Web Agent Orchestrator" as described in BMAD) for:

• Conceptual and Planning Phases: [cite: 401]
  • Analyst (TA) Work:
    • Brainstorming initial ideas. [cite: 402]
    • Conducting broad market or concept research.
    • Drafting the initial Project Brief. [cite: 402]
    • Why Gemini/Web UI? These tasks benefit from the model's extensive knowledge base, ability to synthesize diverse information, and engage in open-ended creative dialogue. The larger context windows often available in web UIs are also helpful for these broader explorations.
  • Product Manager (PM) Work (Initial Stages):
    • Developing the first full draft of the Product Requirements Document (PRD), especially defining the vision, goals, user personas, and high-level epics and stories. [cite: 403]
    • Why Gemini/Web UI? Similar to the Analyst, drafting a comprehensive PRD from a brief or initial ideas often involves a lot of strategic thinking, iteration, and pulling together various pieces of information, which a powerful conversational AI excels at.

You'd typically switch to your IDE (Windsurf, Cursor) with integrated AI agents for:

• Technical Design, Detailed Documentation Management & Implementation Phases: [cite: 405]
  • Architect (ARCH) & Design Architect (DA) Work:
    • Creating detailed Technical Architecture Documents (architecture.md, front-end-architecture.md). [cite: 406] While high-level outlines could start in a web UI, the specifics, diagrams, and alignment with eventual code benefit from the IDE's context.
    • Defining precise API contracts, data models, and system component interactions.
    • Why IDE? These tasks require precision and often involve referencing project structure, code patterns, and generating specific technical diagrams (like Mermaid diagrams) that are best managed within the project's file system.
  • Product Owner (PO) & Scrum Master (SM) Work (Detailed Stages):
    • Detailed Story Generation: Taking the high-level epics/stories from the PRD and creating detailed, actionable story files (e.g., docs/stories/epic1.story1.md) using templates like story-tmpl.md. This involves the create-next-story-task.md. [cite: 407]
    • Document Management: Running tasks like "Doc Sharding" (doc-sharding-task.md) to break down large PRD/Architecture documents into smaller, linked files, or "Library Indexing" (library-indexing-task.md) to maintain docs/index.md. [cite: 407, 293]
    • Checklist Execution: Running detailed checklists (e.g., po-master-checklist.md, story-draft-checklist.md) against project documents.
    • Why IDE? These agents need to read multiple project files (PRD, Arch docs, templates, existing stories), understand their interconnections, and write new files directly into your project structure. An IDE provides direct file system access and context.
  • Developer Agents (DEV):
    • Code Implementation: Writing, testing, and debugging code for user stories. [cite: 408]
    • Why IDE? This is almost exclusively an IDE-based activity. Developer agents need to interact with the codebase directly, use linters, compilers/interpreters, and testing frameworks within the project environment. [cite: 409]

Why this Distinction?

• Web UI (e.g., Gemini's interface):
  • Strengths: Broad knowledge, powerful content generation (drafting large documents), creative ideation, summarizing research, large context handling. [cite: 332]
  • Use for: Initial brainstorming, research, drafting strategic documents like Project Briefs and initial PRDs.
• IDE (Windsurf, Cursor with AI):
  • Strengths: Proximity to code and project files, precise file manipulation, execution of focused tasks (often defined in task.md files), iterative refinement of technical details. [cite: 409, 419]
  • Use for: Detailed technical design, breaking down plans into executable stories, code generation, ongoing documentation management within the project.

Your Current Situation:

You have your PRD, architecture, UI/UX spec, and frontend architecture documents. The next logical steps according to BMAD—such as the PO validating these documents, the PO/SM creating detailed, technically-grounded story files from your PRD, and then Developer Agents implementing those stories—lean heavily towards using an AI agent within your IDE.

The IDE agent, configured with the BMAD Orchestrator prompt and given access to the necessary persona and task files (derived from the .txt files you uploaded), can:

1. Load your prd.md and architecture.md from your docs/ folder.
2. Help you (as the PO or SM persona) to create the first detailed story file, enriching it with technical context from your architecture documents.
3. Then, as a Developer persona, take that story file and start generating the code.

Think of it as moving from broad strokes (Web UI/Gemini) to fine, detailed execution (IDE).

[3stepwin]

I am new I find the instructions confusing so I copied the gitrep and pasted it into roocode and added it to my project did I do it right it seems to be working

[bmadcode]

You only need to copy the bmad-agent folder to your project / keep it at the root @3stepwin