> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/bmad-code-org/BMAD-METHOD/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick Start Guide

> Get BMad Method running in your project in 5-10 minutes with this step-by-step guide

# Quick Start Guide

Get BMad Method installed and running in your project in just a few minutes. This guide will walk you through installation, first commands, and basic usage.

<Note>
  **Prerequisites:** You need [Node.js](https://nodejs.org) v20 or higher installed on your system.
</Note>

## Installation

<Steps>
  <Step title="Run the installer">
    Open your terminal and navigate to your project directory, then run:

    ```bash theme={null}
    npx bmad-method install
    ```

    <Tip>
      If you're getting a stale beta version, use: `npx bmad-method@6.0.1 install`
    </Tip>
  </Step>

  <Step title="Answer configuration prompts">
    The installer will ask you a few questions to configure BMad for your project:

    **Core Configuration:**

    * What should agents call you? (Your name or team name)
    * What language should agents use when chatting?
    * Preferred document output language?
    * Where should output files be saved? (default: `_bmad-output`)

    **BMad Method Configuration:**

    * Project name (defaults to your directory name)
    * Your development experience level (beginner/intermediate/expert)
    * Where to store planning artifacts (default: `_bmad-output/planning-artifacts`)
    * Where to store implementation artifacts (default: `_bmad-output/implementation-artifacts`)
    * Where to store project knowledge (default: `docs`)

    <CodeGroup>
      ```bash Example: Solo Developer theme={null}
      What should agents call you? Alex
      What language should agents use? English  
      Project name: my-saas-app
      Experience level: Intermediate
      ```

      ```bash Example: Team theme={null}
      What should agents call you? Engineering Team
      What language should agents use? English
      Project name: enterprise-platform
      Experience level: Expert
      ```
    </CodeGroup>
  </Step>

  <Step title="Select modules to install">
    Choose which BMad modules you want to install:

    * **BMad Method (BMM)** — Core framework with 34+ workflows (recommended)
    * **BMad Builder (BMB)** — Create custom agents and workflows
    * **Test Architect (TEA)** — Risk-based test strategy and automation
    * **Game Dev Studio (BMGD)** — Game development workflows
    * **Creative Intelligence Suite (CIS)** — Innovation and brainstorming

    <Tip>
      Start with just BMM (the core framework). You can add other modules anytime by running the installer again.
    </Tip>
  </Step>

  <Step title="Select your AI IDE">
    Choose which AI IDE(s) you're using:

    * Claude Code (recommended)
    * Cursor
    * GitHub Copilot
    * Windsurf
    * And more...

    The installer will configure slash commands for your selected IDE(s).
  </Step>

  <Step title="Wait for installation to complete">
    The installer will:

    * Create necessary directories
    * Install selected modules
    * Generate agent files
    * Configure IDE integrations
    * Set up workflow commands

    This usually takes 30-60 seconds.
  </Step>
</Steps>

## Verify Installation

After installation completes, verify everything is working:

<Steps>
  <Step title="Check for the _bmad directory">
    You should see a new `_bmad` directory in your project with this structure:

    ```bash theme={null}
    _bmad/
    ├── core/              # Core BMad functionality
    ├── bmm/               # BMad Method module
    │   ├── agents/        # Agent definitions
    │   └── workflows/     # Workflow files
    └── manifest.yaml      # Installation manifest
    ```
  </Step>

  <Step title="Check for IDE integration">
    Depending on your IDE, you should see:

    **Claude Code:**

    ```bash theme={null}
    .claude/
    └── commands/
        └── bmad/          # BMad slash commands
    ```

    **Cursor:**

    ```bash theme={null}
    .cursor/
    └── commands/
        └── bmad/          # BMad slash commands
    ```
  </Step>

  <Step title="Open your AI IDE">
    Open your AI IDE (Claude Code, Cursor, etc.) in your project directory.
  </Step>
</Steps>

## Your First Commands

Now you're ready to use BMad Method! Here are your first commands:

### Get Help

The most important command is `/bmad-help` — it tells you exactly what to do next:

```bash theme={null}
/bmad-help
```

You can also ask questions:

```bash theme={null}
/bmad-help I just finished the architecture, what do I do next?
```

### Invoke an Agent

Agents are your specialized collaborators. Try invoking the Product Manager:

```bash theme={null}
/pm
```

You'll see a menu with options like:

* **\[CP] Create PRD** — Create a Product Requirements Document
* **\[VP] Validate PRD** — Validate an existing PRD
* **\[EP] Edit PRD** — Update your PRD
* **\[CE] Create Epics and Stories** — Break down requirements

### Run a Workflow

Workflows can also be called directly:

```bash theme={null}
/create-prd
```

This launches the PRD creation workflow with guided facilitation.

### Quick Development Flow

For rapid iteration on small features or bug fixes:

```bash theme={null}
/quick-flow-solo-dev
```

This specialized agent helps you ship quickly while maintaining quality.

## Common First Tasks

Here are typical first tasks based on your project stage:

<Tabs>
  <Tab title="New Project">
    ### Starting from Scratch

    <Steps>
      <Step title="Brainstorm ideas">
        ```bash theme={null}
        /bmad-help brainstorming
        ```
      </Step>

      <Step title="Create a product brief">
        ```bash theme={null}
        /pm
        # Select "Create Product Brief"
        ```
      </Step>

      <Step title="Write a PRD">
        ```bash theme={null}
        /create-prd
        ```
      </Step>

      <Step title="Design UX">
        ```bash theme={null}
        /ux-designer
        # Select "[CU] Create UX Design"
        ```
      </Step>

      <Step title="Create architecture">
        ```bash theme={null}
        /architect
        # Select "[CA] Create Architecture"
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Existing Project">
    ### Adding BMad to an Existing Project

    <Steps>
      <Step title="Document your project">
        ```bash theme={null}
        /generate-project-context
        ```

        This creates a comprehensive project overview.
      </Step>

      <Step title="Plan a new feature">
        ```bash theme={null}
        /create-prd
        ```

        Document requirements for your next feature.
      </Step>

      <Step title="Quick development">
        ```bash theme={null}
        /quick-flow-solo-dev
        ```

        Jump straight into implementing small features.
      </Step>

      <Step title="Set up sprints">
        ```bash theme={null}
        /sm
        # Select "Sprint Planning"
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Bug Fix / Small Feature">
    ### Quick Flow Development

    <Steps>
      <Step title="Start quick-flow">
        ```bash theme={null}
        /quick-flow-solo-dev
        ```
      </Step>

      <Step title="Choose your mode">
        The agent will detect whether you need:

        * Quick spec (plan before implementing)
        * Quick dev (implement with review)
      </Step>

      <Step title="Follow the workflow">
        The agent guides you through:

        1. Understanding requirements
        2. Implementation
        3. Self-check
        4. Adversarial review
        5. Resolving findings
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Understanding the Workflow

BMad Method organizes work into 4 phases:

<CardGroup cols={2}>
  <Card title="Phase 1: Analysis" icon="magnifying-glass">
    **Research and Discovery**

    * Domain research
    * Market research
    * Technical research
    * Competitive analysis
  </Card>

  <Card title="Phase 2: Planning" icon="file-lines">
    **Requirements & Design**

    * Product briefs
    * PRD creation
    * UX design
    * Validation
  </Card>

  <Card title="Phase 3: Solutioning" icon="compass-drafting">
    **Architecture & Breakdown**

    * Architecture documentation
    * Epics and stories
    * Implementation readiness
  </Card>

  <Card title="Phase 4: Implementation" icon="code">
    **Development & Delivery**

    * Sprint planning
    * Story development
    * Code review
    * Retrospectives
  </Card>
</CardGroup>

<Tip>
  You don't need to follow all phases for every project! Small features can jump straight to quick-flow. The framework adapts to your needs.
</Tip>

## Pro Tips

### Use Party Mode

Bring multiple agents into a discussion:

```bash theme={null}
/party-mode
```

Example: Get PM, Architect, and Dev in the same conversation to discuss a complex feature.

### Customize Agent Behavior

You can customize how agents communicate with you by editing:

```bash theme={null}
_bmad/core/config.yaml
```

Change experience level, language, or output preferences.

### Non-Interactive Installation

For CI/CD pipelines or automation:

```bash theme={null}
npx bmad-method install \
  --directory /path/to/project \
  --modules bmm \
  --tools claude-code \
  --yes
```

### Check Installation Status

See what's currently installed:

```bash theme={null}
npx bmad-method status
```

## What's Next?

<CardGroup cols={2}>
  <Card title="Installation Guide" icon="book" href="/installation">
    Learn about all installation options and troubleshooting
  </Card>

  <Card title="Agent Reference" icon="users" href="/reference/agents">
    Meet all the specialized agents and their capabilities
  </Card>

  <Card title="Workflow Guide" icon="diagram-project" href="/workflows/overview">
    Explore all 34+ workflows in detail
  </Card>

  <Card title="Tutorials" icon="graduation-cap" href="/tutorials/getting-started">
    Step-by-step tutorials for common scenarios
  </Card>
</CardGroup>

## Need Help?

<Warning>
  **Stuck or confused?** Remember: `/bmad-help` is your friend! It provides context-aware guidance based on your current project state.
</Warning>

* Ask `/bmad-help` in your IDE for intelligent guidance
* Join our [Discord community](https://discord.gg/gk8jAdXWmj) for help and discussion
* Report issues on [GitHub](https://github.com/bmad-code-org/BMAD-METHOD/issues)
* Check the [documentation site](https://docs.bmad-method.org) for detailed guides

***

Congratulations! You're now ready to use BMad Method to build better software faster. Start with `/bmad-help` and let the agents guide you.