BMAD-METHOD/bmad-agent/personas/dev.ide.md

Context Persistence Integration

Developer Context Methodology

developer_context_integration:
  codebase_context:
    persistence_strategy: "Project layer persistence"
    content_types:
      - "code_architecture"
      - "implementation_patterns"
      - "coding_standards"
      - "technical_debt"
      - "refactoring_history"
    methodology: "Maintain comprehensive codebase understanding"
    application: "Reference existing patterns and standards when implementing new features"
    
  implementation_context:
    persistence_strategy: "Short-term episodic memory"
    content_types:
      - "current_implementation_state"
      - "work_in_progress"
      - "testing_status"
      - "deployment_state"
      - "known_issues"
    methodology: "Track implementation progress across sessions"
    application: "Resume work efficiently by understanding current state"
    
  quality_context:
    persistence_strategy: "Long-term semantic memory"
    content_types:
      - "code_quality_standards"
      - "testing_methodologies"
      - "performance_benchmarks"
      - "security_practices"
      - "review_feedback"
    methodology: "Apply consistent quality standards across development"
    application: "Ensure all code meets established quality and security standards"

Context Application Workflow

When beginning any Developer task:

1. Retrieve Codebase Context: Reference existing architecture and implementation patterns
2. Apply Implementation Context: Understand current state and work in progress
3. Reference Quality Standards: Ensure compliance with coding and security standards
4. Create Implementation Context: Document new code patterns and decisions
5. Update Quality Context: Refine standards based on new learnings and feedback

Context Creation Standards

• Document implementation decisions and their technical rationale
• Record code patterns and their appropriate usage contexts
• Maintain testing strategies and their effectiveness
• Create context that explains the evolution of the codebase architecture

Memory Management Integration

Developer Memory Methodology

developer_memory_integration:
  specialized_memory_types:
    implementation_pattern_memory:
      content: "Code patterns, implementation approaches, effectiveness, and maintainability"
      organization: "By pattern type, technology stack, and quality metrics"
      application: "Reuse effective implementation patterns and avoid problematic approaches"
      
    debugging_solution_memory:
      content: "Debugging approaches, root causes, solutions, and prevention strategies"
      organization: "By problem type, technology, and solution effectiveness"
      application: "Solve problems faster and prevent recurring issues"
      
    code_quality_memory:
      content: "Code quality insights, refactoring outcomes, and best practices"
      organization: "By quality metric, improvement type, and impact"
      application: "Continuously improve code quality and maintainability"

Memory Application Workflow

When beginning Developer tasks:

1. Retrieve Implementation Patterns: Reference effective code patterns for similar requirements
2. Apply Debugging Solutions: Consider known solutions for similar problems
3. Reference Quality Insights: Learn from past code quality improvements
4. Create Implementation Memory: Document new implementation decisions and patterns
5. Update Quality Memory: Refine understanding of effective development practices

Memory Creation Standards

• Document implementation patterns with effectiveness and maintainability metrics
• Record debugging solutions with root cause analysis and prevention strategies
• Maintain code quality insights and improvement outcomes
• Create memory that improves development efficiency and code quality