How I structure mobile app development with the BMAD method - Builder Créatif

BMAD method — mobile app development workflow with AI agents

I’ve spent 7 years building mobile apps. And for a long time, the biggest problem wasn’t the code — it was everything that comes before it.

Defining the product. Structuring the architecture. Writing stories. Prioritizing. And above all, keeping consistency between what you plan and what you code.

Since I started using the BMAD method with Claude Code, that structuring phase went from several weeks to a few days. And the code that comes out of it is better.

What is BMAD exactly?

BMAD stands for Breakthrough Method for Agile AI-Driven Development (also known as “Build More Architect Dreams”). It’s an open source framework that structures collaboration between you and AI by simulating a real agile team.

Instead of a single catch-all prompt, BMAD defines specialized agents:

Agent	Role
Analyst	Frames the problem, produces the product brief
PM	Writes the PRD (Product Requirements Document)
Architect	Designs the technical architecture
UX Designer	Structures user flows
Dev	Implements story by story
Scrum Master	Prioritizes, plans sprints
QA / Test Architect	Defines the testing strategy

Each agent has its own context, instructions, and deliverables. They hand off to each other like a real team.

It’s free, open source, and installs in one command:

npx bmad-method install

Why this changes everything for mobile

Building a mobile app isn’t just writing Flutter or React Native. It’s managing complexity that explodes fast:

Multi-platform: iOS, Android, sometimes web — each platform has its constraints
State management: app state must stay consistent everywhere
Backend + API: Firebase, Supabase, or custom — the choice impacts the entire architecture
Mobile-specific UX: navigation, gestures, offline, push notifications
Store compliance: App Store and Play Store each have their own rules

Without structure, AI will generate code that works in isolation but collapses when you assemble the pieces.

BMAD enforces a process: you plan before you code. And when you code, you have a spec to follow — not a vague prompt.

My actual workflow: from idea to sprint

Here’s how I kick off a new mobile app project with BMAD.

Phase 1: product brief (Analyst)

I run the /create-product-brief workflow and discuss with the Analyst agent.

I give it my raw idea: “A habit tracking app with a personalized AI coach.”

The agent asks precise questions:

Who’s your target user?
What problem are you solving that competitors don’t?
What’s your revenue model?
What are your technical constraints?

In 20 minutes, I have a structured product brief. Not a 40-page doc — a one-to-two-page document that frames the essentials.

Phase 2: the PRD (PM)

The PM takes the brief and transforms it into a PRD: prioritized features, user personas, success metrics, constraints.

This is where features go from “that would be cool” to “here’s what we’re building in v1.”

For a mobile app, this phase is critical. It prevents the classic scope creep: “Oh, what if we also add a social system, a marketplace, and AR mode?”

No. The PRD says: here are the 5 MVP features. Everything else is v2.

Phase 3: architecture (Architect)

The Architect produces the architecture document based on the PRD.

For my Flutter + Firebase apps, the classic decisions:

State management: Riverpod or Bloc
Backend: Firebase (Auth, Firestore, Cloud Functions) or Supabase
Navigation: GoRouter
Structure: feature-first or layer-first
Offline: cache-first strategy with sync

The Architect agent doesn’t pick randomly. It considers the PRD constraints and justifies its choices.

The deliverable: an architecture document that serves as the reference for all development that follows.

Phase 4: stories and sprints (Scrum Master + PM)

The /create-epics-and-stories workflow breaks down the PRD into epics and user stories with acceptance criteria.

Example for a habits app:

Epic: Onboarding

Story: As a user, I create an account with email/Google
Story: As a user, I select my first 3 habits
Story: As a user, I configure my reminders

Each story has acceptance criteria, dependencies, and estimates.

The Scrum Master organizes this into sprints. Sprint 1: auth + onboarding. Sprint 2: habit tracking. Sprint 3: AI coach.

Phase 5: dev story by story (Dev)

This is where I code. The /dev-story workflow takes a story, checks context (architecture, PRD, previous stories), and implements.

The Dev agent doesn’t code in a vacuum. It has:

The architecture document as reference
Previous stories as context
Acceptance criteria as the objective

Result: code that respects the decided architecture, not freestyle code going in every direction.

What BMAD does well for mobile

Consistency. When you’re developing 30+ screens with complex navigation, shared state, and API calls, consistency is everything. BMAD maintains context from end to end.

Scope control. The PRD + stories prevent drift. You know exactly what you’re building each sprint.

Living documentation. Each phase produces a document. At the end of the project, you have a PRD, architecture, stories — not just code without context.

Adaptability. BMAD adapts to project size. A bug fix doesn’t need a 10-page PRD. The framework automatically adjusts planning depth.

What BMAD doesn’t do

Let’s be clear.

BMAD doesn’t code your app for you. It’s a structuring framework. You remain the decision-maker. You validate each phase. You drive the vision.

BMAD doesn’t replace mobile expertise. If you don’t know that setState in Flutter will create performance issues on long lists, BMAD won’t spontaneously tell you. Technical expertise is what you bring to the table.

BMAD doesn’t handle visual design. It structures UX flows, but pixel-perfect design, animations, branding — that’s your job (or your designer’s).

Comparison: with and without BMAD

	Without BMAD	With BMAD
Start	”Claude, code me a habits app”	Brief → PRD → Architecture → Stories → Dev
Consistency	Each prompt starts from scratch	Context maintained between phases
Scope	Constant feature creep	PRD locks down v1 scope
Architecture	Ad hoc decisions, constant refactoring	Architecture decided before the first file
Tests	”We’ll figure it out later”	Test strategy from the architecture phase
Documentation	None	PRD + Architecture + Stories = complete docs

How to get started

Install BMAD in your project:

npx bmad-method install

Run /bmad-help — the assistant guides you to the right workflow based on where you are
Start with the product brief — even if you think you know what you want, the brief will sharpen your vision
Resist the urge to code right away. The 2-3 hours spent on brief + PRD + architecture will save you days of refactoring.
Iterate. BMAD isn’t waterfall. You can adjust the PRD, revisit the architecture, reprioritize stories along the way.

My setup for mobile dev with BMAD

Tool	Usage
Claude Code (CLI)	Main IDE + BMAD agents
Flutter + Dart	Mobile framework
Firebase	Backend (Auth, Firestore, Functions)
BMAD v6	Project structure
Riverpod	State management
GoRouter	Navigation

Installing BMAD adds agents and workflows directly to your project. When you open Claude Code, agents are available immediately.

The real advantage

What makes BMAD powerful isn’t the technology. It’s the discipline it enforces.

When you build alone — and most indie devs and freelancers are alone — you have nobody to challenge your PRD, review your architecture, or tell you your story is too big.

BMAD simulates that team. Not perfectly. But enough to avoid the classic mistakes: starting without a plan, coding without architecture, shipping without tests.

And for mobile, where every architecture decision costs dearly in refactoring, that discipline makes all the difference.

Going further: BMAD explained on video

If you want a visual intro to the BMAD method before jumping in, this video (in French) walks through the concept and workflow:

Resources

BMAD Method — official GitHub repo
Full BMAD documentation
Getting Started Tutorial
BMAD Discord community
My Flutter + Firebase stack for mobile — the article where I detail my stack choices
How I built a product video with Claude Code + Remotion — another AI-assisted development example

Want to structure your next mobile project? The BMAD method is free and open source on GitHub. One command to install, one /bmad-help to get started.