# BMAD Method Memory Enhancement: Claude Code Implementation Guide

## Overview

This guide provides step-by-step instructions for implementing BMAD Method Memory Enhancement in Claude Code conversations. Claude Code's conversation-based interface makes it ideal for the BMAD transient memory approach.

## Quick Start (2 minutes)

### Step 1: BMAD Memory Activation Prompt

Copy and paste this prompt at the start of any Claude Code conversation:

```markdown
 BMAD METHOD MEMORY ENHANCEMENT - CLAUDE CODE ACTIVATION

You are now equipped with the BMAD Method enhanced with intelligent memory capabilities for Claude Code.

BMAD MEMORY SYSTEM ACTIVATION:
 Conversation-based BMAD memory storage
 Automatic BMAD pattern recognition
 Command-driven BMAD memory operations
 File-based BMAD memory persistence

BMAD MEMORY COMMANDS:
- /bmad-remember [content] [type] [importance]  Create BMAD methodology memory
- /bmad-recall [query] [type] [limit]  Search BMAD methodology memories
- /bmad-memories [filter] [limit]  List BMAD methodology memories
- /bmad-forget [id]  Delete BMAD methodology memory
- /bmad-status  Show BMAD methodology memory statistics
- /bmad-export  Export BMAD methodology memories to file

BMAD AUTOMATIC TRIGGERS:
- "Remember this BMAD approach: [content]"  SEMANTIC memory
- "I've decided on this BMAD methodology: [content]"  DECISION memory
- "The BMAD solution is: [content]"  SOLUTION memory
- "I learned this BMAD pattern: [content]"  LEARNING memory
- "The BMAD pattern here is: [content]"  PATTERN memory

BMAD MEMORY TYPES:
- WORKING: Current BMAD session context
- DECISION: Important BMAD methodology choices
- SOLUTION: BMAD problem-solving insights
- LEARNING: New BMAD methodology knowledge
- PATTERN: Recurring BMAD methodology approaches
- SEMANTIC: BMAD conceptual knowledge

BMAD MEMORY STORAGE:
- Primary: Conversation context for immediate access
- Secondary: File exports for persistence
- Format: Simple text with metadata

CURRENT BMAD STATE:
- Total BMAD memories: 0
- BMAD session: NEW
- BMAD project context: [TO BE DETERMINED]

Confirm BMAD Method activation and ask for project context.
```

### Step 2: Test BMAD Memory System

After activation, test the BMAD memory system:

```
/bmad-status
/bmad-remember "Testing BMAD memory enhancement in Claude Code" WORKING 0.5
/bmad-recall "testing"
/bmad-memories
```

## BMAD Memory Commands in Claude Code

### Basic BMAD Memory Operations

#### Create BMAD Memory
```
/bmad-remember "BMAD Method recommends component-based architecture" DECISION 0.8

Expected Response:
[CREATED] bmad_mem_001: DECISION
CONTENT: BMAD Method recommends component-based architecture
IMPORTANCE: 0.8
TAGS: bmad, methodology, architecture, component-based
CREATED: 2024-01-15T10:30:00Z

BMAD memory created successfully.
```

#### Search BMAD Memories
```
/bmad-recall "component architecture"

Expected Response:
Found 1 BMAD memory:

bmad_mem_001 (DECISION, importance: 0.8)
CONTENT: BMAD Method recommends component-based architecture
TAGS: bmad, methodology, architecture, component-based
CREATED: 2024-01-15T10:30:00Z
```

#### List BMAD Memories
```
/bmad-memories

Expected Response:
BMAD METHODOLOGY MEMORIES (1 total):

bmad_mem_001 | DECISION | 0.8 | BMAD Method recommends component-based architecture
```

#### Check BMAD Status
```
/bmad-status

Expected Response:
BMAD METHOD MEMORY STATUS:
- Total BMAD memories: 1
- BMAD memory types: DECISION(1)
- BMAD session duration: 5 minutes
- Last BMAD memory: bmad_mem_001 (2 minutes ago)
- BMAD memory storage: Conversation context
- BMAD project context: Component library development
```

### Automatic BMAD Memory Creation

Claude Code will automatically create BMAD memories when you use trigger phrases:

```
User: "Remember this BMAD approach: We use atomic design methodology for component organization"

Claude Response:
[AUTO-CREATED] bmad_mem_002: SEMANTIC
CONTENT: We use atomic design methodology for component organization
IMPORTANCE: 0.7
TAGS: bmad, methodology, atomic-design, component-organization
CREATED: 2024-01-15T10:35:00Z

I've automatically created a BMAD memory for this approach. Atomic design is an excellent methodology for organizing components in a scalable way.
```

```
User: "I've decided on this BMAD methodology: TypeScript for all frontend development"

Claude Response:
[AUTO-CREATED] bmad_mem_003: DECISION
CONTENT: TypeScript for all frontend development
IMPORTANCE: 0.8
TAGS: bmad, methodology, typescript, frontend, development
CREATED: 2024-01-15T10:37:00Z

Excellent BMAD decision! TypeScript will provide better type safety and developer experience. This decision will guide our frontend development approach.
```

## BMAD File-Based Persistence in Claude Code

### Export BMAD Memories

```
/bmad-export

Expected Response:
BMAD METHODOLOGY MEMORY EXPORT
Generated: 2024-01-15T10:40:00Z
Project: Component Library Development

=== BMAD MEMORY EXPORT ===

bmad_mem_001 | DECISION | 0.8 | 2024-01-15T10:30:00Z
CONTENT: BMAD Method recommends component-based architecture
TAGS: bmad, methodology, architecture, component-based

bmad_mem_002 | SEMANTIC | 0.7 | 2024-01-15T10:35:00Z
CONTENT: We use atomic design methodology for component organization
TAGS: bmad, methodology, atomic-design, component-organization

bmad_mem_003 | DECISION | 0.8 | 2024-01-15T10:37:00Z
CONTENT: TypeScript for all frontend development
TAGS: bmad, methodology, typescript, frontend, development

=== END BMAD EXPORT ===

Save this as bmad-memories-[date].txt for future reference.
```

### Import BMAD Memories

```
/bmad-import

Paste your BMAD memory export here:

[User pastes previous export]

Expected Response:
BMAD MEMORY IMPORT SUCCESSFUL:
- Imported 3 BMAD memories
- bmad_mem_001: DECISION - Component-based architecture
- bmad_mem_002: SEMANTIC - Atomic design methodology
- bmad_mem_003: DECISION - TypeScript for frontend

BMAD methodology context restored. Ready to continue with established BMAD patterns.
```

## BMAD Workflow Examples in Claude Code

### Example 1: BMAD Component Development

```
User: "Let's develop a button component using BMAD methodology"

Claude: "/bmad-recall 'component'

Found relevant BMAD memories:
- bmad_mem_001: Component-based architecture
- bmad_mem_002: Atomic design methodology

Based on our established BMAD patterns, I'll create a button component following atomic design principles with component-based architecture.

Remember this BMAD approach: Button component uses variants for different styles and sizes

[AUTO-CREATED] bmad_mem_004: PATTERN
CONTENT: Button component uses variants for different styles and sizes
IMPORTANCE: 0.7
TAGS: bmad, methodology, button, component, variants

Here's the BMAD-compliant button component:

```tsx
// Button.tsx - Following BMAD atomic design methodology
interface ButtonProps {
  variant: 'primary' | 'secondary' | 'danger';
  size: 'small' | 'medium' | 'large';
  children: React.ReactNode;
  onClick?: () => void;
}

export const Button: React.FC<ButtonProps> = ({ 
  variant, 
  size, 
  children, 
  onClick 
}) => {
  // Implementation following BMAD component-based architecture
  return (
    <button 
      className={`btn btn-${variant} btn-${size}`}
      onClick={onClick}
    >
      {children}
    </button>
  );
};
```

This follows our BMAD methodology with:
- Component-based architecture (bmad_mem_001)
- Atomic design principles (bmad_mem_002)
- TypeScript implementation (bmad_mem_003)
- Variant-based styling (bmad_mem_004)
```

### Example 2: BMAD Problem Solving

```
User: "I'm having performance issues with my React components"

Claude: "/bmad-recall 'performance'

No specific BMAD performance memories found. Let me help solve this and create a BMAD memory for future reference.

What specific performance issues are you experiencing? I'll analyze the problem using BMAD methodology and remember the solution.

User: "Components are re-rendering too frequently"

Claude: "The BMAD solution is: Use React.memo and useMemo to prevent unnecessary re-renders

[AUTO-CREATED] bmad_mem_005: SOLUTION
CONTENT: Use React.memo and useMemo to prevent unnecessary re-renders
IMPORTANCE: 0.8
TAGS: bmad, methodology, performance, react, memo, optimization

Here's the BMAD performance optimization approach:

```tsx
// BMAD performance optimization pattern
import React, { memo, useMemo } from 'react';

// Memoize component to prevent unnecessary re-renders
export const OptimizedComponent = memo(({ data, onUpdate }) => {
  // Memoize expensive calculations
  const processedData = useMemo(() => {
    return data.map(item => ({
      ...item,
      computed: expensiveCalculation(item)
    }));
  }, [data]);

  return (
    <div>
      {processedData.map(item => (
        <div key={item.id}>{item.computed}</div>
      ))}
    </div>
  );
});
```

I've created a BMAD memory for this performance solution. This pattern will be referenced for future performance optimization questions.
```

### Example 3: BMAD Architecture Planning

```
User: "Let's plan the architecture for our new feature using BMAD methodology"

Claude: "/bmad-recall 'architecture'

Found relevant BMAD memories:
- bmad_mem_001: Component-based architecture
- bmad_mem_003: TypeScript for frontend

Based on our established BMAD architecture patterns, let's plan the new feature.

What feature are we building?

User: "A user dashboard with widgets"

Claude: "I've decided on this BMAD methodology: Dashboard uses widget-based architecture with container-component pattern

[AUTO-CREATED] bmad_mem_006: DECISION
CONTENT: Dashboard uses widget-based architecture with container-component pattern
IMPORTANCE: 0.8
TAGS: bmad, methodology, dashboard, widgets, architecture, container-component

BMAD ARCHITECTURE PLAN:

```
Dashboard Architecture (BMAD Methodology):
 DashboardContainer (Smart Component)
    State management
    Data fetching
    Widget orchestration
 DashboardLayout (Layout Component)
    Grid system
    Responsive design
    Widget positioning
 Widgets (Atomic Components)
     ChartWidget
     StatsWidget
     TableWidget
     CustomWidget
```

This follows our BMAD patterns:
- Component-based architecture (bmad_mem_001)
- TypeScript implementation (bmad_mem_003)
- Container-component pattern (bmad_mem_006)
- Atomic design principles (bmad_mem_002)

Remember this BMAD approach: Each widget is self-contained with its own props interface

[AUTO-CREATED] bmad_mem_007: PATTERN
CONTENT: Each widget is self-contained with its own props interface
IMPORTANCE: 0.7
TAGS: bmad, methodology, widgets, self-contained, props, interface
```

## Advanced BMAD Features in Claude Code

### BMAD Memory Relationships

```
/bmad-relate bmad_mem_001 "supports" bmad_mem_006 0.9

Expected Response:
BMAD MEMORY RELATIONSHIP CREATED:
bmad_mem_001 (Component-based architecture) SUPPORTS bmad_mem_006 (Dashboard widget architecture) with strength 0.9

This relationship indicates that our component-based architecture decision strongly supports the dashboard widget architecture approach.
```

### BMAD Memory Analytics

```
/bmad-analytics

Expected Response:
BMAD METHODOLOGY MEMORY ANALYTICS:

Memory Distribution:
- DECISION: 3 memories (43%)
- PATTERN: 2 memories (29%)
- SEMANTIC: 1 memory (14%)
- SOLUTION: 1 memory (14%)

Importance Distribution:
- High (0.8-1.0): 4 memories
- Medium (0.6-0.8): 3 memories
- Low (0.1-0.6): 0 memories

Most Referenced Tags:
1. bmad (7 memories)
2. methodology (7 memories)
3. architecture (3 memories)
4. component (3 memories)

Recent Activity:
- Last 10 minutes: 3 memories created
- Most active: Architecture planning
- Trending: Widget development patterns
```

### BMAD Memory Templates

```
/bmad-template COMPONENT "Component: [name], Purpose: [purpose], Props: [props], Dependencies: [deps]"

Expected Response:
BMAD COMPONENT TEMPLATE CREATED:
Template ID: bmad_template_component
Format: Component: [name], Purpose: [purpose], Props: [props], Dependencies: [deps]

Use with: /bmad-remember-template COMPONENT name="Button" purpose="User interaction" props="variant,size,onClick" deps="React"
```

```
/bmad-remember-template COMPONENT name="Modal" purpose="Display overlay content" props="isOpen,onClose,title,children" deps="React,ReactDOM"

Expected Response:
[CREATED] bmad_mem_008: PATTERN
CONTENT: Component: Modal, Purpose: Display overlay content, Props: isOpen,onClose,title,children, Dependencies: React,ReactDOM
IMPORTANCE: 0.7
TAGS: bmad, methodology, component, modal, template
CREATED: 2024-01-15T11:00:00Z

BMAD component template applied successfully.
```

## BMAD Session Management in Claude Code

### Start BMAD Session

```
/bmad-start-session "Component Library Development Sprint 1"

Expected Response:
BMAD SESSION STARTED:
- Session ID: bmad_session_20240115_001
- Project: Component Library Development Sprint 1
- Started: 2024-01-15T11:00:00Z
- BMAD memories loaded: 8
- Session context: Active

Ready for memory-enhanced BMAD methodology development.
```

### End BMAD Session

```
/bmad-end-session

Expected Response:
BMAD SESSION SUMMARY:
- Session duration: 45 minutes
- BMAD memories created: 5
- BMAD decisions made: 2
- BMAD patterns established: 2
- BMAD solutions documented: 1

SESSION EXPORT:
[Provides complete session export for saving]

BMAD session ended. Memories preserved for future sessions.
```

## BMAD Best Practices for Claude Code

### 1. Always Start with BMAD Activation
Begin every Claude Code conversation with the BMAD memory activation prompt

### 2. Use Descriptive BMAD Memory Content
```
Good: /bmad-remember "BMAD Method recommends React Query for server state management with automatic caching" DECISION 0.8
Bad:  /bmad-remember "Use React Query" DECISION 0.5
```

### 3. Leverage Automatic BMAD Triggers
Use natural language that triggers automatic BMAD memory creation:
- "Remember this BMAD approach: ..."
- "I've decided on this BMAD methodology: ..."
- "The BMAD solution is: ..."

### 4. Export BMAD Memories Regularly
Use /bmad-export at the end of important sessions to preserve BMAD memories

### 5. Reference BMAD Memories in Conversations
Ask Claude to check relevant BMAD memories before making suggestions:
"Check our previous BMAD decisions about state management before suggesting an approach"

### 6. Build BMAD Memory Progressively
Create BMAD memories throughout the conversation, not just at the end

### 7. Use Appropriate BMAD Importance Levels
- 0.9-1.0: Critical BMAD architecture decisions
- 0.7-0.8: Important BMAD patterns and solutions
- 0.5-0.6: Useful BMAD working notes
- 0.1-0.4: Temporary BMAD information

## Troubleshooting BMAD Memory in Claude Code

### Issue: BMAD Commands Not Working

**Solution:**
```
Re-activate BMAD memory with explicit instructions:

"You MUST respond to these exact BMAD commands:
- /bmad-remember [content] [type] [importance]
- /bmad-recall [query]
- /bmad-memories
- /bmad-status

Confirm you understand and will respond to these BMAD commands."
```

### Issue: BMAD Automatic Triggers Not Working

**Solution:**
```
Reinforce BMAD automatic memory creation:

"You MUST automatically create BMAD memories when I use these exact phrases:
- 'Remember this BMAD approach: [content]'
- 'I've decided on this BMAD methodology: [content]'
- 'The BMAD solution is: [content]'

Confirm you will watch for these BMAD trigger phrases."
```

### Issue: BMAD Memories Not Referenced

**Solution:**
```
Instruct Claude to actively use BMAD memories:

"Before responding to any question, you MUST:
1. Check for relevant BMAD memories using /bmad-recall
2. Reference applicable BMAD memories in your response
3. Build upon previous BMAD decisions and patterns

Confirm you will actively use BMAD memories in responses."
```

This implementation guide provides everything needed to use BMAD Method Memory Enhancement effectively in Claude Code conversations!
```