Your First Project

You've installed BMAD Board and you have a project with a _bmad/ folder. Now for the moment it was built for: leading your hybrid team — you and your AI agents — through one real story, from an empty spec all the way to Done.

Think of yourself as the agile lead for a small, tireless team. You don't write every line; you decide what moves next, and each click hands the work to an agent while you keep your eyes on the board. Let's take a single story to the finish line.

1. Open your project

Launch BMAD Board and choose Open Project. In the folder picker, select your project's root — the folder that contains _bmad/.

The moment you confirm, BMAD Board scans that _bmad/ directory. It reads your BMAD config and discovers every epic and every story you've planned. Within a second or two, the Epics and Stories views fill in. This is your cockpit booting up.

Note: If the board reports that the folder isn't a BMAD project, it means there's no _bmad/ directory there yet. See the installation troubleshooting list.

2. Read the board

Take a beat to orient. Two views carry the heart of your work:

• Epics — the big buckets of value. Each epic groups a set of related stories. This is the altitude at which you think about what the release delivers.
• Stories — the individual units of work inside those epics. Each story is a card that shows where it is in its lifecycle.

Every story lives in one phase of its lifecycle at a time:

Backlog → Ready → In Progress → Review → Done

That's the spine of everything you'll do here. A story starts as an idea in Backlog and ends as finished, reviewed work in Done. You'll learn the full anatomy of these views in epics and stories; for now, just find one story you'd like to build.

Tip: Pick something small for your first run — a story you understand well. The point is to feel the rhythm of the loop, not to ship your hardest feature.

3. Pick a story and advance it

Here's the core interaction, and it's a satisfying one: clicking a story's phase launches the matching BMAD command in the embedded terminal, running with your chosen LLM. You advance the work; the agent does the work; you watch it happen in the same window.

Each phase maps to a specific BMAD slash command:

Let's walk your chosen story through them.

Backlog → create the spec (/bmad-create-story)

Click the Backlog phase. BMAD Board opens a terminal tab and launches /bmad-create-story with your LLM. The agent interviews the context of your project and writes a dedicated story spec file — the brief that carries everything the developer agent will need later: the requirement, the acceptance criteria, the relevant architecture. You're the editor here: answer the agent's questions, steer the shape of the story.

When the spec looks right, the story is ready to build.

Ready → start developing (/bmad-dev-story)

Click Ready. The board launches /bmad-dev-story. Now your Senior Software Engineer agent (Amelia, 💻) reads that story spec and starts implementing — writing code, following your project's existing patterns and conventions. You watch the terminal, answer any questions, and let it work.

In Progress → keep going (/bmad-dev-story)

Development rarely finishes in one breath. Click In Progress to continue — this starts a fresh development pass rather than resuming the old session, so the agent picks the work up cleanly. Loop here as many times as the story needs until the implementation is complete.

Review → run code review (/bmad-code-review)

Click Review. The board launches /bmad-code-review, which reviews the change adversarially — hunting for bugs, edge cases, and unmet acceptance criteria.

This is the important loop to understand: In Progress and Review are two halves of the same cycle. If the review turns up problems, you go back to In Progress, let the dev agent fix them, then return to Review. Dev and review can loop as many times as it takes until the story is genuinely right. That back-and-forth is a feature, not a detour — it's how quality gets built in.

Done → the finish line (●)

When the review comes back clean, the story reaches Done. There's no command to launch — Done is terminal. Your first story is finished, reviewed, and recorded. That's the whole rhythm of the BMAD story cycle, and you just ran it.

4. Two things that make the loop feel effortless

The Command Palette (Cmd+K)

You don't have to hunt through views for everything. Press Cmd+K to open the Command Palette — a quick launcher for BMAD commands and navigation. It's the fastest way to jump to a story, fire a command, or move between views without lifting your hands from the keyboard.

Session history and resume

Every LLM session the board launches for a story is recorded in Session History. That means a conversation with an agent isn't gone when you close a tab — you can revisit what happened, and resume a past session to pick a thread back up. When you step away mid-story and come back tomorrow, your context is waiting for you.

Tip: Because sessions are recorded per story, History doubles as a paper trail: what was asked, what the agent did, and when. It's the memory your hybrid team shares.

What just happened

You led a full slice of the BMAD method without leaving one window: you created a story spec, developed it, reviewed it, looped until it was right, and reached Done — each phase a single click that put an AI agent to work while you stayed in the pilot's seat. Do it a few more times and the loop becomes second nature.

Next steps

Now that you've felt the method, it's worth understanding the whole shape of it and going deeper on the board's views.

• The BMAD method: overview — the four phases and the big picture behind what you just did.
• Epics and stories in the board — the full anatomy of the views and the story lifecycle.