518 lines
16 KiB
Markdown
518 lines
16 KiB
Markdown
# BMAD Method Transient Memory Implementation
|
|
|
|
## Overview
|
|
|
|
This guide provides a lightweight, immediately usable memory enhancement for the BMAD Method that works through simple commands and automatic triggers within any AI environment. No extensions or complex setup required - just conversation-based memory management integrated with BMAD methodology.
|
|
|
|
## Core Concept: BMAD Conversation-Driven Memory
|
|
|
|
The transient memory implementation enhances BMAD Method through:
|
|
- **Simple text commands** integrated with BMAD workflows
|
|
- **Automatic pattern recognition** to create BMAD methodology memories
|
|
- **Lightweight file storage** for BMAD methodology persistence
|
|
- **Conversation context** for immediate BMAD memory access
|
|
|
|
## Quick Start (5 minutes)
|
|
|
|
### Step 1: Initialize BMAD Memory Enhancement
|
|
|
|
Use this prompt to activate memory enhancement in any BMAD Method conversation:
|
|
|
|
```
|
|
ACTIVATE BMAD METHOD MEMORY ENHANCEMENT
|
|
|
|
You now have access to the BMAD Method with transient memory enhancement. Follow these rules:
|
|
|
|
BMAD MEMORY COMMANDS:
|
|
- `/bmad-remember [content]` - Create BMAD methodology memory
|
|
- `/bmad-recall [query]` - Search BMAD methodology memories
|
|
- `/bmad-memories` - List all BMAD methodology memories
|
|
- `/bmad-forget [id]` - Delete a BMAD methodology memory
|
|
- `/bmad-status` - Show BMAD memory statistics
|
|
|
|
BMAD AUTOMATIC MEMORY TRIGGERS:
|
|
- When I say "Remember this BMAD approach:" - Create semantic memory
|
|
- When I make BMAD decisions - Create decision memory
|
|
- When we solve BMAD methodology problems - Create solution memory
|
|
- When I learn BMAD patterns - Create learning memory
|
|
|
|
BMAD MEMORY STORAGE:
|
|
- Store BMAD memories in conversation context
|
|
- Use simple text format for easy access
|
|
- Maintain BMAD memory index for quick retrieval
|
|
- Auto-expire working memories after session
|
|
|
|
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
|
|
|
|
Initialize with empty BMAD memory state and confirm activation.
|
|
```
|
|
|
|
### Step 2: Test Basic BMAD Memory Operations
|
|
|
|
```
|
|
# Test BMAD memory creation
|
|
/bmad-remember "BMAD Method recommends component-based architecture for frontend development"
|
|
|
|
# Test BMAD memory recall
|
|
/bmad-recall "component architecture"
|
|
|
|
# Test automatic BMAD memory
|
|
Remember this BMAD approach: We use atomic design methodology for component organization.
|
|
|
|
# Check BMAD memory status
|
|
/bmad-status
|
|
```
|
|
|
|
## BMAD Command Reference
|
|
|
|
### BMAD Memory Creation Commands
|
|
|
|
#### Manual BMAD Memory Creation
|
|
```
|
|
/bmad-remember [content] [type] [importance]
|
|
|
|
Examples:
|
|
/bmad-remember "BMAD architecture uses microservices pattern" DECISION 0.8
|
|
/bmad-remember "BMAD component library completed" SOLUTION 0.7
|
|
/bmad-remember "BMAD performance bottleneck in search function" WORKING 0.6
|
|
```
|
|
|
|
#### Automatic BMAD Memory Triggers
|
|
```
|
|
# These phrases automatically create BMAD memories:
|
|
"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 Retrieval Commands
|
|
|
|
#### Search BMAD Memories
|
|
```
|
|
/bmad-recall [query] [type] [limit]
|
|
|
|
Examples:
|
|
/bmad-recall "architecture" # Search all BMAD memories
|
|
/bmad-recall "component" DECISION # Search BMAD decisions only
|
|
/bmad-recall "performance" SOLUTION 3 # Limit to 3 BMAD results
|
|
```
|
|
|
|
#### List BMAD Memories
|
|
```
|
|
/bmad-memories # List all BMAD memories
|
|
/bmad-memories DECISION # List BMAD decisions only
|
|
/bmad-memories recent 5 # List 5 most recent BMAD memories
|
|
/bmad-memories important # List high-importance BMAD memories
|
|
```
|
|
|
|
### BMAD Memory Management Commands
|
|
|
|
#### Update BMAD Memory
|
|
```
|
|
/bmad-update [id] [new_content]
|
|
|
|
Example:
|
|
/bmad-update bmad_mem_001 "Updated BMAD component architecture to include state management"
|
|
```
|
|
|
|
#### Delete BMAD Memory
|
|
```
|
|
/bmad-forget [id] # Delete specific BMAD memory
|
|
/bmad-forget-working # Clear BMAD working memories
|
|
/bmad-forget-old 30 # Delete BMAD memories older than 30 days
|
|
```
|
|
|
|
#### BMAD Memory Analytics
|
|
```
|
|
/bmad-status # Show BMAD memory statistics
|
|
/bmad-export # Export BMAD memories to file
|
|
/bmad-import [file] # Import BMAD memories from file
|
|
```
|
|
|
|
## Automatic BMAD Memory Creation
|
|
|
|
### Pattern-Based BMAD Triggers
|
|
|
|
The system automatically creates BMAD methodology memories when it detects these patterns:
|
|
|
|
```yaml
|
|
bmad_decision_patterns:
|
|
triggers: ["BMAD decision:", "We'll use this BMAD approach:", "The BMAD choice is:", "I'm going with this BMAD methodology:"]
|
|
memory_type: "DECISION"
|
|
importance: 0.7
|
|
|
|
bmad_solution_patterns:
|
|
triggers: ["The BMAD solution is:", "Here's how to fix with BMAD:", "The BMAD answer is:", "This BMAD approach works:"]
|
|
memory_type: "SOLUTION"
|
|
importance: 0.8
|
|
|
|
bmad_learning_patterns:
|
|
triggers: ["I learned this BMAD pattern:", "Now I understand this BMAD approach:", "The key BMAD insight:", "This BMAD methodology means:"]
|
|
memory_type: "LEARNING"
|
|
importance: 0.6
|
|
|
|
bmad_problem_patterns:
|
|
triggers: ["The BMAD problem is:", "Issue with BMAD approach:", "Bug in BMAD methodology:", "Error when using BMAD:"]
|
|
memory_type: "WORKING"
|
|
importance: 0.5
|
|
```
|
|
|
|
### Context-Aware BMAD Memory Creation
|
|
|
|
```
|
|
# When discussing BMAD architecture
|
|
Auto-creates: DECISION memories for BMAD technology choices
|
|
Auto-tags: bmad, architecture, technology, design
|
|
|
|
# When solving BMAD methodology issues
|
|
Auto-creates: SOLUTION memories for BMAD fixes
|
|
Auto-tags: bmad, methodology, fix, solution
|
|
|
|
# When planning BMAD features
|
|
Auto-creates: WORKING memories for BMAD requirements
|
|
Auto-tags: bmad, planning, requirements, features
|
|
```
|
|
|
|
## BMAD Memory Storage Format
|
|
|
|
### Simple Text Format
|
|
|
|
```
|
|
MEMORY_ID: bmad_mem_20240115_001
|
|
TYPE: DECISION
|
|
CREATED: 2024-01-15T10:30:00Z
|
|
IMPORTANCE: 0.8
|
|
TAGS: bmad, methodology, architecture, component-based
|
|
PROJECT: bmad_frontend_methodology
|
|
---
|
|
CONTENT: BMAD Method recommends component-based architecture for frontend development because of reusability and maintainability benefits.
|
|
CONTEXT: During BMAD architecture planning session, compared monolithic vs. component-based approaches.
|
|
RELATED: bmad_mem_20240115_002 (BMAD state management), bmad_mem_20240114_005 (BMAD component library)
|
|
```
|
|
|
|
### Conversation Context Storage
|
|
|
|
```
|
|
# BMAD Memory Index (maintained in conversation)
|
|
ACTIVE_BMAD_MEMORIES: [bmad_mem_001, bmad_mem_002, bmad_mem_003]
|
|
WORKING_BMAD_MEMORIES: [bmad_mem_001]
|
|
RECENT_BMAD_MEMORIES: [bmad_mem_003, bmad_mem_002, bmad_mem_001]
|
|
IMPORTANT_BMAD_MEMORIES: [bmad_mem_002]
|
|
|
|
# Quick Access BMAD Cache
|
|
LAST_BMAD_DECISION: "Use component-based architecture"
|
|
CURRENT_BMAD_PROBLEM: "Component library organization"
|
|
ACTIVE_BMAD_SOLUTION: "Atomic design methodology"
|
|
```
|
|
|
|
## BMAD Implementation Examples
|
|
|
|
### Claude Code + BMAD Method Implementation
|
|
|
|
```markdown
|
|
# Claude Code + BMAD Method Memory Activation
|
|
|
|
Paste this at the start of your BMAD conversation:
|
|
|
|
---
|
|
BMAD METHOD MEMORY ENHANCEMENT ACTIVATED
|
|
|
|
I now maintain transient memory for BMAD methodology using these mechanisms:
|
|
1. Conversation context for immediate BMAD access
|
|
2. Simple file storage for BMAD methodology persistence
|
|
3. Command-driven BMAD memory operations
|
|
4. Automatic BMAD memory creation from patterns
|
|
|
|
CURRENT BMAD MEMORY STATE:
|
|
- Total BMAD memories: 0
|
|
- BMAD working memories: 0
|
|
- BMAD session started: [timestamp]
|
|
|
|
Ready for BMAD memory commands (/bmad-remember, /bmad-recall, /bmad-memories, etc.)
|
|
---
|
|
|
|
Then use commands like:
|
|
/bmad-remember "BMAD Method recommends React 18 with TypeScript" DECISION 0.8
|
|
```
|
|
|
|
### V0 + BMAD Method Implementation
|
|
|
|
```markdown
|
|
# V0 + BMAD Method Memory Integration
|
|
|
|
For V0, BMAD memories enhance component generation:
|
|
|
|
/bmad-remember "BMAD design system uses Tailwind with custom color palette" PATTERN 0.9
|
|
/bmad-remember "BMAD components should be responsive and accessible" DECISION 0.8
|
|
|
|
When generating components, I'll reference these BMAD memories:
|
|
- Apply BMAD design system patterns
|
|
- Ensure BMAD responsive design methodology
|
|
- Include BMAD accessibility features
|
|
```
|
|
|
|
### Cursor AI + BMAD Method Implementation
|
|
|
|
```markdown
|
|
# Cursor AI + BMAD Method Memory Integration
|
|
|
|
For Cursor AI, BMAD memories enhance code suggestions:
|
|
|
|
/bmad-remember "BMAD Method recommends async/await pattern for API calls" PATTERN 0.7
|
|
/bmad-remember "BMAD error handling uses try/catch with user-friendly messages" SOLUTION 0.8
|
|
|
|
When writing code, I'll reference these BMAD memories:
|
|
- Apply consistent BMAD patterns
|
|
- Include proper BMAD error handling methodology
|
|
- Follow established BMAD conventions
|
|
```
|
|
|
|
## Advanced BMAD Features
|
|
|
|
### BMAD Memory Relationships
|
|
|
|
```
|
|
# Create related BMAD memories
|
|
/bmad-remember "BMAD authentication uses JWT tokens" DECISION 0.8
|
|
/bmad-relate bmad_mem_001 "supports" bmad_mem_002 0.9
|
|
|
|
# Query BMAD relationships
|
|
/bmad-recall-related bmad_mem_001
|
|
/bmad-show-connections "authentication"
|
|
```
|
|
|
|
### BMAD Memory Templates
|
|
|
|
```
|
|
# BMAD decision template
|
|
/bmad-template DECISION "BMAD Technology: [tech], Reason: [reason], Alternatives: [alts], Impact: [impact]"
|
|
|
|
# BMAD solution template
|
|
/bmad-template SOLUTION "BMAD Problem: [problem], Solution: [solution], Steps: [steps], Result: [result]"
|
|
|
|
# Use BMAD template
|
|
/bmad-remember-template DECISION tech="React" reason="Component reusability" alts="Vue,Angular" impact="High"
|
|
```
|
|
|
|
### BMAD Memory Workflows
|
|
|
|
```
|
|
# BMAD problem-solving workflow
|
|
/bmad-start-workflow BMAD_PROBLEM_SOLVING
|
|
Auto-creates BMAD WORKING memory for problem
|
|
Tracks BMAD solution attempts
|
|
Creates BMAD SOLUTION memory when resolved
|
|
|
|
# BMAD feature development workflow
|
|
/bmad-start-workflow BMAD_FEATURE_DEV
|
|
Creates BMAD WORKING memory for requirements
|
|
Tracks BMAD design decisions
|
|
Creates BMAD PATTERN memory for reusable approaches
|
|
```
|
|
|
|
## Practical BMAD Usage Scenarios
|
|
|
|
### Scenario 1: BMAD Architecture Planning
|
|
|
|
```
|
|
User: "Let's plan the architecture using BMAD Method"
|
|
|
|
AI: "Starting BMAD architecture planning session. I'll automatically remember key BMAD decisions.
|
|
|
|
/bmad-start-workflow BMAD_ARCHITECTURE_PLANNING
|
|
|
|
What type of application are we building with BMAD methodology?"
|
|
|
|
User: "It's an e-commerce platform using BMAD component-based approach"
|
|
|
|
AI: "Remember this BMAD approach: Building e-commerce platform with component-based architecture
|
|
|
|
[AUTO-CREATED] bmad_mem_001: WORKING - BMAD project type and architecture
|
|
Tags: bmad, architecture, ecommerce, component-based
|
|
|
|
What are the main BMAD methodology requirements?"
|
|
```
|
|
|
|
### Scenario 2: BMAD Problem Solving
|
|
|
|
```
|
|
User: "I'm having trouble with component organization in BMAD"
|
|
|
|
AI: "I'll help you solve this with BMAD methodology and remember the solution.
|
|
|
|
/bmad-recall "component organization"
|
|
|
|
Found 2 related BMAD memories:
|
|
- bmad_mem_005: BMAD atomic design pattern
|
|
- bmad_mem_012: BMAD component library structure
|
|
|
|
What specific issue are you facing with BMAD components?"
|
|
|
|
User: "Components are becoming too complex and hard to maintain"
|
|
|
|
AI: "The BMAD problem is: Component complexity and maintainability
|
|
|
|
[AUTO-CREATED] bmad_mem_015: WORKING - BMAD component complexity issue
|
|
Tags: bmad, components, complexity, maintainability
|
|
|
|
Let me analyze this based on previous BMAD patterns..."
|
|
```
|
|
|
|
### Scenario 3: BMAD Code Review
|
|
|
|
```
|
|
User: "Please review this component using BMAD methodology"
|
|
|
|
AI: "/bmad-recall 'component patterns'
|
|
|
|
Found relevant BMAD memories:
|
|
- bmad_mem_008: BMAD recommends single responsibility principle
|
|
- bmad_mem_012: BMAD component composition pattern
|
|
- bmad_mem_018: BMAD prop validation methodology
|
|
|
|
Reviewing your component against established BMAD patterns..."
|
|
```
|
|
|
|
## BMAD Memory Persistence Strategies
|
|
|
|
### Session-Based BMAD Persistence
|
|
|
|
```
|
|
# At BMAD session start
|
|
/bmad-load-session-memories
|
|
Loads BMAD memories from previous session
|
|
Creates BMAD working memory for current session
|
|
|
|
# During BMAD session
|
|
Maintains BMAD memories in conversation context
|
|
Auto-saves important BMAD memories
|
|
|
|
# At BMAD session end
|
|
/bmad-save-session-memories
|
|
Persists important BMAD memories
|
|
Clears BMAD working memories
|
|
```
|
|
|
|
### File-Based BMAD Persistence
|
|
|
|
```
|
|
# Simple BMAD file storage
|
|
.bmad-memory/
|
|
bmad-memories.txt # All BMAD memories in simple format
|
|
bmad-index.txt # BMAD memory index for quick lookup
|
|
bmad-session-[date].txt # Session-specific BMAD memories
|
|
|
|
# Export/Import BMAD memories
|
|
/bmad-export Creates downloadable BMAD memory file
|
|
/bmad-import [file] Loads BMAD memories from file
|
|
```
|
|
|
|
### Cloud-Based BMAD Persistence
|
|
|
|
```
|
|
# For environments that support it
|
|
/bmad-sync-memories cloud
|
|
Syncs BMAD memories to cloud storage
|
|
Enables cross-session BMAD persistence
|
|
Allows team BMAD memory sharing
|
|
```
|
|
|
|
## BMAD Best Practices
|
|
|
|
### BMAD Memory Hygiene
|
|
|
|
```
|
|
# Regular BMAD cleanup
|
|
/bmad-forget-old 30 # Remove BMAD memories older than 30 days
|
|
/bmad-forget-unimportant # Remove low-importance BMAD memories
|
|
/bmad-consolidate-similar # Merge similar BMAD memories
|
|
|
|
# BMAD memory optimization
|
|
/bmad-optimize-memories # Compress and organize BMAD memories
|
|
/bmad-rebuild-index # Rebuild BMAD memory index
|
|
/bmad-validate-memories # Check BMAD memory integrity
|
|
```
|
|
|
|
### Effective BMAD Memory Usage
|
|
|
|
```
|
|
# Be specific with BMAD memories
|
|
Good: /bmad-remember "BMAD recommends bcrypt with 12 rounds for password hashing" PATTERN 0.8
|
|
Bad: /bmad-remember "BMAD uses bcrypt" PATTERN 0.5
|
|
|
|
# Use appropriate BMAD importance levels
|
|
Critical BMAD decisions: 0.8-1.0
|
|
Useful BMAD patterns: 0.6-0.8
|
|
Working BMAD notes: 0.3-0.6
|
|
Temporary BMAD info: 0.1-0.3
|
|
|
|
# Tag BMAD memories consistently
|
|
Use standard tags: bmad, architecture, methodology, pattern, decision
|
|
Add project tags: ecommerce, mobile-app, api
|
|
Include tech tags: react, nodejs, postgresql
|
|
```
|
|
|
|
### BMAD Memory Integration Patterns
|
|
|
|
```
|
|
# Start BMAD conversations with memory context
|
|
"Based on what I remember about your BMAD project..."
|
|
"Referencing our previous BMAD decision about..."
|
|
"Building on the BMAD pattern we established..."
|
|
|
|
# End BMAD conversations with memory updates
|
|
"I'm remembering this BMAD solution for future reference"
|
|
"This BMAD decision will guide future architecture choices"
|
|
"Adding this BMAD pattern to our methodology knowledge base"
|
|
```
|
|
|
|
## BMAD Troubleshooting
|
|
|
|
### Common BMAD Issues
|
|
|
|
#### BMAD Memory Not Being Created
|
|
```
|
|
Check: Are you using the correct BMAD command format?
|
|
Fix: /bmad-remember "content" TYPE importance
|
|
|
|
Check: Is the automatic BMAD trigger phrase correct?
|
|
Fix: Use exact phrases like "Remember this BMAD approach:" or "I've decided on this BMAD methodology:"
|
|
```
|
|
|
|
#### BMAD Memory Not Found During Recall
|
|
```
|
|
Check: Are you using the right BMAD search terms?
|
|
Fix: Try broader terms or check BMAD memory tags
|
|
|
|
Check: Has the BMAD memory expired?
|
|
Fix: Check /bmad-status for BMAD memory lifecycle
|
|
```
|
|
|
|
#### BMAD Memory System Not Responding
|
|
```
|
|
Check: Was the BMAD system properly activated?
|
|
Fix: Re-run the BMAD activation prompt
|
|
|
|
Check: Are BMAD commands formatted correctly?
|
|
Fix: Use exact BMAD command syntax with forward slash
|
|
```
|
|
|
|
### BMAD Debug Commands
|
|
|
|
```
|
|
/bmad-debug-memory # Show detailed BMAD memory state
|
|
/bmad-test-memory # Run BMAD memory system tests
|
|
/bmad-reset-memory # Clear all BMAD memories and restart
|
|
/bmad-memory-health # Check BMAD memory system health
|
|
```
|
|
|
|
This transient implementation gives you immediate memory benefits within the BMAD Method without complex setup, while still providing the full power of the BMAD Memory Enhancement!
|
|
```
|