Can a new workflow really cut weeks from a project and make coding feel effortless?
We invite you to join our growing community and discover how the bmad method with claude can change the way we build software.
Over the last few months we refined a clear workflow that pairs Claude Code with simple commands to start your first project.
Our guide shows step-by-step commands, practical code examples, and the tools we use to speed up planning and coding.
Join our Discord to get help, share ideas, and tap into a group that has spent months documenting this approach.
We also publish updates on YouTube. If this project helps you, please give it a star to help others find it.
Key Takeaways
- Learn a proven workflow that speeds up project setup and coding.
- Use Claude Code and focused commands to launch your first project.
- Access community support on Discord for real-time help.
- Follow our documented steps developed over several months.
- Subscribe to our channel for ongoing updates and best practices.
Understanding the Bmad Method with Claude
Clear context turns AI agents into reliable partners across planning, coding, and documentation.
The philosophy of Agentic Agile frames development as a team of specialized agents that share duties across design, implementation, and QA.
We treat every user input as a key piece of data. That input feeds agents so they produce consistent files, specs, and code that match product goals.
Our research over several months shows teams hit flow faster and deliver higher quality. GitHub studies back this: structured tools can speed task completion by about 55%.
The Philosophy of Agentic Agile
Agentic Agile splits work into focused roles so developers and agents each handle tasks they do best. This keeps architecture and requirements clear.
Why Context Matters
Context gives agents the signals they need to write accurate documentation and practical implementation notes.
- Well-scoped context reduces rework.
- Clear specs guide system design and coding.
- Documented inputs keep project files consistent.
Core Innovations in Agentic Development
We focused on small, testable outputs so teams can move faster without losing clarity.
Our approach was validated over many months. We split large requirements into clear tasks handled by specialized agents. This reduces rework and keeps architecture steady.
Agents produce linked code and documents from the same context. That makes PRDs and specifications actionable. By feeding detailed input, the resulting files match the project vision.
Research into multi-agent frameworks supports this idea. Popular projects like MetaGPT show strong community adoption and practical value. Our framework builds on that work to save teams months on routine planning and implementation.
| Innovation | Benefit | Tested (months) | Outcome |
|---|---|---|---|
| Specialized agents | Break complex requirements into tasks | 6 | Consistent code and documents |
| Context-driven outputs | Reduce ambiguity across design and PRDs | 4 | Fewer integration errors |
| Framework updates | Support varied projects and architecture | 8 | Faster delivery for teams |
Preparing Your Environment for Success
Start by verifying your runtime and core tools so installs complete without errors.
System Prerequisites
We require Node.js v20+ to run our framework and related tools. Installing the correct runtime is the most important step for a stable development setup.
What we recommend:
- Install Node.js v20+ and confirm the version with node -v.
- Use our updated installation scripts — we refined them over several months to reduce edge-case failures.
- Verify configuration in the web interface to ensure all tools are active and available for your project.
We show how to configure claude code to work with the framework, saving you months of manual tuning. If you run into issues, our community is ready to help during setup and implementation.
For quick installs and a clear checklist, follow our step-by-step guide or consult the Node.js installation guide to confirm your environment before moving on.
The Role of Specialized AI Personas
We assign focused personas to keep planning, development, and QA aligned.
Our planning personas act like a Scrum Master and product planner. They capture requirements, create PRD outlines, and draft story files that match acceptance criteria.
Planning Personas
These agents break work into clear tasks. They produce documents and files that guide system design and set the scope for developers.
Development Personas
Development agents generate code snippets, implementation notes, and linked specs. Each agent follows strict requirements so the output fits the architecture.
Quality Assurance Roles
QA personas run checks against the acceptance criteria. They validate stories, test results, and ensure documents remain consistent across the project.
- Refined over months: personas were trained to reduce rework.
- Consistent output: PRD, story, and files align with product goals.
- Clear handoffs: agents pass context and inputs to each other.
Navigating the Planning Phase
Good planning turns vague ideas into clear, testable tasks that teams can act on.
We refined this planning phase over many months to make projects start clean and stay on track. Our agents gather requirements, capture user input, and draft a focused PRD that becomes the team’s blueprint.
Every input feeds documents and stories so developers know exactly what to build. That reduces back-and-forth and speeds implementation.
- Collect requirements and acceptance criteria.
- Generate a PRD and split work into story-sized tasks.
- Assign agents to produce files, specs, and initial code notes.
We provide a web interface for collaboration and tracking. If you need help, our community and docs are ready to assist.
| Activity | Owner | Output | Expected time (months) |
|---|---|---|---|
| Requirement capture | Planning agent / scrum master | PRD, story list | 1 |
| Task breakdown | Development personas | Story files, task estimates | 0.5 |
| Initial implementation notes | Implementation agent | Code snippets, architecture notes | 0.5 |
| Documentation sync | Documentation agent | Updated files and acceptance criteria | 0.25 |
For quick scheduling and planning tips, check our short guide on scheduling and tools. Our process helps teams align before any code is written and saves developers months in total effort.
Mastering Context Engineered Development
Context engineering turns scattered requirements into a single reliable source for agents to act on.
We built this approach over many months to help developers give agents the inputs they need. By feeding full project context, every piece of implementation and design stays aligned with requirements.
What this gives you: fewer clarifying cycles, consistent documents, and code that follows system design notes. Our guides show how to structure PRD and story files so agents output usable files and specs.
- Provide complete inputs for each task and story.
- Keep architecture notes and acceptance criteria linked to stories.
- Update the central context store before issuing commands or code requests.
| Focus | Benefit | Impact (months) |
|---|---|---|
| Full context per story | Accurate code and docs | 2 |
| Linked PRD and files | Faster reviews | 1.5 |
| Clear architecture notes | Fewer integration errors | 3 |
| Refined commands | Repeatable outputs | 2 |
For practical tips and best practices, see our best practices and the support integration guide. Mastering context saves teams months and keeps implementation predictable.
Bridging Phases Through Epic Sharding
Epic sharding tightly links planning and execution so deliveries stay predictable across long projects.
We break large PRD items into compact epic files that preserve full context for each story. This keeps every requirement tied to a concrete implementation path.
The Importance of Traceability
Traceability ensures a clear audit trail from requirements to code and back again. Each epic file records its source PRD, related architecture notes, and acceptance criteria.
That means the Scrum Master and agents can find the exact inputs they need for a task. It also helps when projects run for several months and teams change.
- Split PRD into smaller epics to retain context per story.
- Link each story to acceptance criteria and implementation notes.
- Automate sharding so files remain consistent as the project grows.
We document every step so the audit trail is searchable and reviewable. For an example of tools that help track revisions and client feedback during planning, see our guide on client revision tracking.
Utilizing the Codebase Flattener Tool
Our flattener condenses an entire repository into a single, searchable XML bundle for fast agent analysis.
We used the tool to process 156 files and produced a 2.1 MB XML file. That bundle contains 15,847 lines of code and an estimated 542,891 tokens.
Why this helps development: a single XML gives agents the full project context so they can generate accurate code and spot architecture issues faster.
We spent months refining the flattener to respect .gitignore rules and to skip binaries. Each run ends with a clear completion summary listing files processed and total tokens.
- Aggregate entire codebases into one XML for AI analysis.
- Specify input directories and custom output locations.
- Optimize for projects over 15,000 lines of code — tested over many months.
| Metric | Value | Benefit |
|---|---|---|
| Files processed | 156 | Complete snapshot for agents |
| XML size | 2.1 MB | Portable single file |
| Lines / tokens | 15,847 / 542,891 | Rich context for analysis |
Mastering this tool can save months by cutting manual debugging and reducing code review cycles. For the flattener source and setup, see our flattener source and the tooling guide for integration tips.
Integrating with Modern IDEs
Using Cursor and Windsurf lets us keep context close to our work.
We focused on editor integrations to make agent-driven development feel natural. Our goal is to surface relevant context, commands, and snippets right where developers edit code.
Working with Cursor and Windsurf
Cursor and Windsurf each offer fast hooks for running agent tasks from the editor. We document setup steps that connect the IDE to our framework and claude code adapters.
This keeps story files, PRD notes, and architecture links within reach. Developers run commands, review outputs, and accept changes without leaving the editor.
Custom Command Workarounds
Some environments block direct shell calls. We share tested workarounds that proxy commands through the IDE API or a lightweight local service.
- Fallback runner: use a local relay to execute agent commands.
- Context sync: auto-push story context before each request.
- Retry logic: handle transient failures over months of usage.
| IDE | Feature | Benefit |
|---|---|---|
| Cursor | Inline agent prompts | Faster code edits |
| Windsurf | Task palette commands | Easy workflow triggers |
| Local relay | Command proxying | Stable execution |
Expanding the Framework Beyond Software
Our framework now reaches beyond code, helping teams run creative and business initiatives the same way we run software sprints.
Over the past few months we adapted the core approach so it fits non-technical work. We designed expansion packs that tailor agents to creative writing, business strategy, education, and wellness projects.
Each pack includes templates, example files, and quick setup scripts. Teams install an expansion and get domain-specific prompts, planning files, and a clear workflow in minutes.
We documented real cases where users applied the system to write novels, plan campaigns, and manage infrastructure. These examples show how context and short iterations speed results outside engineering.
- Easy installable packs tuned for different domains.
- Sample PRD-style files adapted to non-software projects.
- Community-shared examples and step-by-step guides.
| Domain | Pack contents | Typical setup time |
|---|---|---|
| Creative writing | Outline templates, chapter stories, review checks | 10–20 minutes |
| Business strategy | Roadmaps, OKR files, stakeholder notes | 15–30 minutes |
| Education | Lesson plans, assessment stories, feedback templates | 10–25 minutes |
We continue to support expansion and grow the community. Over the coming months we will publish more packs and real-world examples to help you adapt the system to your next project.
Scaling Your Development Workflow for the Future
A. Scaling a development workflow takes intentional structure and tools that grow with your team.
Over months of enterprise use we tracked measurable gains: teams saw 12.92%–21.83% more pull requests per week after adopting a structured, spec-driven approach.
Our approach ties planning, story files, and QA so context travels with each task. That keeps code and documentation aligned as projects expand.
We continue to evolve tools, training, and community resources so teams can handle complex requirements and ship faster.
Learn more about enterprise scaling and tooling in our scaling project management guide.
