89 lines
3.8 KiB
Markdown
89 lines
3.8 KiB
Markdown
## Context Persistence Integration
|
|
|
|
### Developer Context Methodology
|
|
```yaml
|
|
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
|
|
```yaml
|
|
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
|