BMAD Method — Enterprise Playbook

"Vibe coding" — typing into AI and hoping the output is good — works for toy projects and experiments. But when you need to build software that actually ships, that other people rely on, that needs to be maintained and extended over time, you need structure.

BMAD is an AI-first development methodology that brings that structure. It stands for Brief, Map, Act, Deploy — four phases that guide you from a fuzzy idea to a deployed, maintainable application. BMAD has become popular in 2026 among developers who use Claude Code, Cursor, and Windsurf professionally.

What You'll Learn

• What BMAD is and who created it
• The four phases in detail (Brief, Map, Act, Deploy)
• How to apply BMAD with Claude Code or Cursor
• An example project walkthrough using BMAD
• BMAD templates and tools
• When BMAD is overkill (and when it is essential)
• How to scale BMAD across enterprise development teams
• How BMAD integrates with the V.A.U.L.T. transformation framework
• BMAD adaptations for regulated industries
• Using BMAD with Claude Code agent teams

What Is BMAD?

BMAD (Brief, Map, Act, Deploy) is an AI-first software development methodology that provides a structured workflow for building software with AI assistance. It was popularized in the AI developer community as a response to the chaos of unstructured AI-assisted coding.

The core insight of BMAD is that AI tools are most effective when given clear context and constraints at each stage of development — not just a final specification, but a structured process where each phase produces artifacts that guide the next.

BMAD works with any AI coding tool — Claude Code, Cursor, GitHub Copilot, Windsurf — and can be adapted for teams or solo developers.

Phase 1: Brief

The Brief phase is about getting clarity on what you are building before any code is written.

What happens in Brief:

• Define the problem you are solving (not the solution)
• Identify the target user and their core needs
• List non-functional requirements (performance, security, scale)
• Define what success looks like
• List explicit out-of-scope items

Brief template:

# Project Brief: [Name]

## Problem Statement
[What problem does this solve? For whom?]

## Core User Stories
- As a [user type], I want to [action] so that [benefit]
- As a [user type], I want to [action] so that [benefit]

## Success Criteria
- [Measurable outcome 1]
- [Measurable outcome 2]

## Non-Functional Requirements
- Performance: [Response time target]
- Scale: [Expected users/requests]
- Security: [Auth requirements]

## Out of Scope
- [Feature not included]
- [Feature not included]

Using AI in Brief: Share your rough idea with Claude and say: "Help me write a project brief for this idea. Challenge my assumptions and ask clarifying questions." The AI will often identify gaps you hadn't considered.

India Note: Indian developers building for the Indian market should include India-specific constraints in the Brief: "Must support UPI payments, must work on 3G connections, UI should support Devanagari script, pricing must be in INR." These constraints guide all subsequent phases.

Phase 2: Map

The Map phase translates the Brief into a technical architecture and implementation plan.

What happens in Map:

• Choose the technology stack
• Design the data model (entities, relationships)
• Define the API surface (endpoints, request/response shapes)
• Create a component/module breakdown
• Sequence the implementation (what gets built first)
• Identify risks and technical challenges

Map artifact — Architecture Decision Record (ADR):

# Architecture: [Project Name]

## Stack
- Frontend: [Next.js 15 / React / etc.]
- Backend: [.NET 9 / Node.js / etc.]
- Database: [PostgreSQL / MongoDB / etc.]
- Deployment: [Vercel / Railway / Azure / etc.]

## Data Model
[Entity diagram or table descriptions]

## API Design
[Key endpoints with methods and payloads]

## Implementation Sequence
1. [Phase 1 — Core feature]
2. [Phase 2 — Secondary features]
3. [Phase 3 — Polish and edge cases]

## Risks
- [Risk 1 and mitigation]
- [Risk 2 and mitigation]

Using AI in Map: Share your Brief with Claude and say: "Based on this brief, suggest an appropriate technology stack and data model. Explain your reasoning." Then iterate until you have a plan you are confident in.

Phase 3: Act

The Act phase is where you actually build. BMAD structures this phase to avoid the "endless context" problem where your AI loses track of the overall architecture.

BMAD Act principles:

1. One feature at a time. Complete a feature fully before starting the next.
2. Context documents. Keep a CLAUDE.md or cursor rules file with the architecture summary.
3. Plan before code. For each feature, write a mini-plan in a comment or chat before generating code.
4. Review before accepting. Never blindly accept AI output — review each change.
5. Commit often. Small git commits give you recovery points.

Claude Code example workflow:

# Start each session by telling Claude the context
> Read CLAUDE.md and understand the project structure

# Plan before acting
> We need to implement the user authentication feature. Before writing code,
  write a plan in a comment block at the top of auth.ts showing what functions
  we need and their signatures.

# Review the plan
> [Review and modify the plan]

# Implement
> Now implement the planned functions one at a time

Cursor example workflow:

# In Composer (Ctrl+K or Ctrl+I)
Based on our .cursorrules and the architecture in ARCHITECTURE.md,
implement the UserService class. Include methods: createUser, getUserById,
updateUser, deleteUser. Use repository pattern. Add JSDoc comments.

Phase 4: Deploy

The Deploy phase ensures what you built actually works in production and is maintainable.

Deploy checklist:

• [ ] All features tested manually against success criteria from Brief
• [ ] Environment variables documented in .env.example
• [ ] Database migrations tested on clean database
• [ ] Error handling covers expected failure modes
• [ ] Logging in place for production debugging
• [ ] README updated with setup and deployment instructions
• [ ] CI/CD pipeline configured (GitHub Actions)

Using AI in Deploy: Share your deploy checklist with Claude and ask it to help you work through each item. "Review the project and tell me what's missing from the deploy checklist."

Example: Building a Job Board with BMAD

Brief: A job board for AI/ML jobs in India. Target users are job seekers and employers. Success = 100 active job listings in month 1. Out of scope: payment processing, video interviews.

Map: Next.js frontend, .NET API backend, PostgreSQL database. Entities: Job, Company, Application. API: GET /jobs, POST /jobs, POST /jobs/:id/apply. Implementation sequence: jobs listing → job detail → application form → company dashboard.

Act: Build jobs listing page first. Plan the component structure, then implement. Commit after each component works. Cursor rules file includes the data model and API structure.

Deploy: Test all features, run database migrations on staging, configure Vercel preview deployment, set up GitHub Actions CI, write deployment documentation.

Enterprise BMAD

Solo developers can run BMAD informally — a Brief in a Notion doc, a Map in their head, Act in Claude Code, Deploy when it feels ready. Enterprise teams need more structure.

Scaling BMAD across teams. In an enterprise setting, each BMAD phase maps to a role. Product owners and business analysts own the Brief — they define the problem, user stories, and success criteria. Solution architects own the Map — they choose the stack, design the data model, and sequence the implementation. Development teams execute the Act phase. DevOps and SRE teams own Deploy. This role-based assignment ensures accountability and prevents the common failure mode where developers skip directly to Act without a proper Brief or Map.

Integrating with Agile sprints. BMAD fits naturally into Scrum and Kanban workflows. A sprint planning session produces a Brief for each user story. The first day of the sprint is Map — the team defines the technical approach. Days two through four are Act — developers build with AI assistance. The final day is Deploy — code review, testing, and release. For larger features spanning multiple sprints, the Brief and Map happen in a dedicated "Sprint Zero" while Act and Deploy cycle through subsequent sprints.

BMAD artifacts as documentation. Every BMAD phase produces a written artifact: the Brief document, the Architecture Decision Record (Map), implementation plans and test results (Act), and deployment runbooks (Deploy). These artifacts serve as living documentation that stays current because they are produced as part of the development workflow, not written after the fact. Store them in a docs/bmad/ directory in your repository, organized by feature or epic.

India Note: Indian IT services companies running multiple client projects can standardize BMAD across all engagements. Create a company-wide BMAD template library with pre-filled sections for common Indian market requirements — UPI integration briefs, Aadhaar verification maps, DPDP compliance checklists in Deploy.

BMAD + V.A.U.L.T.

BMAD is a development methodology — it tells you how to build a single feature or project. The V.A.U.L.T. transformation framework is an organizational change framework — it tells you how to transform your entire engineering organization for AI-first development.

BMAD fits into two specific V.A.U.L.T. phases:

Upskill phase. When V.A.U.L.T. calls for upskilling developers in AI-assisted coding, BMAD is the methodology you teach them. Instead of generic "how to use AI" training, you train developers on the Brief-Map-Act-Deploy cycle. This gives them a concrete, repeatable process rather than vague guidance to "use AI more."

Transform phase. When V.A.U.L.T. calls for transforming development workflows, BMAD provides the target state. Your current development process (requirements → design → code → test → deploy) maps directly to BMAD phases, but with AI assistance embedded at every stage. The transformation is not replacing your process — it is augmenting each phase with AI capabilities while maintaining the structure that ensures quality.

Using BMAD within V.A.U.L.T. gives organizations both the tactical methodology (how each developer works) and the strategic framework (how the organization changes). Together, they ensure that AI adoption is structured and sustainable rather than ad-hoc and fragile.

BMAD for Regulated Industries

Financial services, healthcare, government, and defense projects in India operate under strict regulatory requirements. BMAD adapts to these environments by adding compliance checkpoints to each phase.

Brief + Compliance scope. Add a "Regulatory Requirements" section to every Brief that explicitly lists applicable regulations — RBI guidelines for fintech, DPDP Act for data handling, SEBI requirements for trading platforms, CERT-In reporting obligations. This section is reviewed and signed off by the compliance team before the project moves to Map.

Map + Security review. The Map phase must include a threat model alongside the architecture. Before the technical plan is finalized, a security architect reviews the Map artifact for risks: data exposure, authentication gaps, insecure data flows. The Map is not approved until the security review is complete. For Claude Code users, a Superpowers security scanning skill can automate parts of this review.

Act + Audit trail. During the Act phase, every AI-generated code change must be traceable. Use git commit messages that reference the Brief and Map artifacts. Enterprise teams should enable audit logging on their AI tool usage — which prompts were sent, what code was generated, who approved the merge. This audit trail is essential for compliance requirements in India.

Deploy + Compliance audit. Before any deployment to production, run a compliance audit against the original Brief's regulatory requirements. Verify that data handling matches DPDP commitments, that security controls from the Map's threat model are implemented, and that all regulatory sign-offs are documented. Add compliance verification as a required step in your CI/CD pipeline.

Team BMAD

BMAD reaches its full potential when used with Claude Code agent teams — the pattern of spawning specialized AI agents for different roles within a single development workflow.

The 5-agent BMAD pattern. For complex features, spawn five Claude Code agents, each with a dedicated role:

1. Architect agent — Owns the Map phase. Reads the Brief, designs the architecture, creates the ADR, and defines the implementation sequence. Uses the Superpowers write-plan skill for structured planning.

2. Frontend agent — Executes Act phase for UI work. Receives the Map artifact and builds components, pages, and client-side logic. Has project-specific Superpowers skills loaded for your component library and design system.

3. Backend agent — Executes Act phase for API and business logic. Receives the same Map artifact and builds controllers, services, and data access layers. Uses TDD skill to ensure test coverage.

4. QA agent — Runs continuously during Act phase. Reviews code from frontend and backend agents against the Map artifact. Writes integration tests, identifies edge cases, and flags deviations from the spec.

5. DevOps agent — Owns the Deploy phase. Sets up CI/CD pipelines, configures environments, runs deployment checklists, and verifies production readiness.

Coordination through artifacts. The agents do not need direct communication — they coordinate through BMAD artifacts. The Brief and Map are shared inputs. Each agent writes its output to designated directories. The QA agent reads all outputs and validates consistency. This artifact-based coordination scales naturally because adding more agents does not increase communication overhead.

When to use Team BMAD. Use the 5-agent pattern for features that touch multiple layers of the stack simultaneously — a new user-facing feature that requires API endpoints, database changes, frontend components, tests, and deployment configuration. For smaller changes that only touch one layer, a single agent with the appropriate Superpowers skills is sufficient. Browse Claude Code tools for ready-to-use agent configurations.

When to Use BMAD

Use BMAD when:

• Building something that will be in production
• Working with a team (shared structure helps coordination)
• Project complexity is medium to high
• You plan to maintain and extend the code

Skip BMAD when:

• Building a throwaway prototype to test an idea
• Learning a new technology (just explore freely)
• Personal scripts and automation
• Projects under 2 hours of work

Official Resources

• BMAD Method — Search for BMAD templates and documentation in the AI developer community
• Claude Code Documentation — Claude Code's own methodology guidance
• Cursor Docs — Rules — Cursor project rules for Act phase
• GitHub Actions Docs — CI/CD for the Deploy phase
• PromptAndSkills BMAD Prompts — Ready-to-use BMAD prompt templates
• Superpowers Skills Guide — Plugin ecosystem for structured AI development
• V.A.U.L.T. Framework — Enterprise AI transformation framework
• Claude Code Tools — Browse Claude Code prompts and skills