Memory Augmented Dev

Memory-Augmented Development

Purpose

Ensures every development task leverages past learnings and contributes to organizational memory. Search before implementing, document after completing.

When This Activates

• User asks to implement a feature
• User requests bug fixes or refactoring
• Any coding task that could benefit from past patterns
• Keywords: "implement", "build", "fix", "refactor", "add feature"

Instructions

Phase 1: Research (Before Implementation)

1. Semantic Search for Patterns Use search-enhanced to find relevant past work:

   search-enhanced(
     query: "<feature area> implementation patterns",
     filters: {type: "code"}
   )
   

2. Review Past Decisions

   list-memories-by-tag(["<feature-area>", "architecture", "decisions"])
   

3. Check Recent Context

   get-recent-context(project: "<current-project>")
   

4. Analyze Retrieved Memories

   • What patterns were successful?
   • What mistakes were made?
   • What decisions inform this work?

Phase 2: Implementation

5. Apply Patterns Found

   • Use established code patterns
   • Follow past architectural decisions
   • Avoid documented mistakes

6. Note Deviations

   • If deviating from patterns, document why
   • Prepare justification for memory storage

Phase 3: Documentation (After Implementation)

7. Store Memory with Rich Metadata

   store-dev-memory({
     type: "code",
     content: "Detailed description of implementation",
     project: "<project-name>",
     tags: ["<feature>", "<technology>", "<pattern-used>"],
     metadata: {
       implementation_status: "complete",
       key_decisions: ["Decision 1", "Decision 2"],
       files_created: ["file1.py", "file2.py"],
       files_modified: ["existing.py"],
       code_changes: "Summary of major changes",
       dependencies_added: ["package1", "package2"],
       testing_notes: "How to test this"
     },
     relationships: [
       {
         memory_id: "<related-memory-hash>",
         type: "builds_on"
       }
     ]
   })
   

8. Store Decisions Separately

   store-dev-memory({
     type: "decision",
     content: "Why we chose approach X over Y",
     project: "<project-name>",
     tags: ["decision", "<topic>"],
     metadata: {
       alternatives_considered: ["Approach Y", "Approach Z"],
       decision_rationale: "Explanation",
       decision_date: "<date>",
       who_decided: "<name>"
     }
   })
   

Tool Reference

search-enhanced

• Purpose: Semantic search across all memories
• Parameters:
  • query (string): Search terms
  • filters (object): Optional filters
    • type: "code" | "decision" | "conversation" | "reference"
    • tags: Array of tags to match
    • project: Project name
    • date_from, date_to: Date range
  • limit (int): Max results (default: 10)
• Returns: Array of memories with similarity scores
• Example: search-enhanced("authentication JWT patterns", filters={type: "code"})

list-memories-by-tag

• Purpose: Get all memories with specific tags
• Parameters:
  • tags (array): Tags to search for
  • project (string): Optional project filter
• Returns: Array of memories
• Example: list-memories-by-tag(["authentication", "security"])

get-recent-context

• Purpose: Get recent memories for session continuity
• Parameters:
  • project (string): Project name
  • limit (int): Number of recent items (default: 10)
• Returns: Array of recent memories, ordered by date
• Example: get-recent-context(project: "hrdag-api")

store-dev-memory

• Purpose: Store new memory with full metadata
• Parameters: See Phase 3 examples above
• Returns: Memory ID (hash)
• Example: See detailed examples below

get-dev-memory

• Purpose: Retrieve specific memory by ID
• Parameters:
  • memory_id (string): Memory hash ID
• Returns: Full memory object
• Example: get-dev-memory(memory_id: "abc123def456")

Examples

Example 1: Implementing Authentication

User says: "Add JWT authentication to the API"

You do:

1. Research

   search-enhanced("authentication JWT patterns", filters={type: "code"})
   list-memories-by-tag(["authentication", "security"])
   

   Result: Found memory showing JWT implementation from 3 months ago

2. Implement Apply the JWT pattern found, using similar code structure

3. Document

   store-dev-memory({
     type: "code",
     content: "Implemented JWT authentication with refresh tokens for API v2",
     project: "hrdag-api",
     tags: ["authentication", "jwt", "security", "api-v2"],
     metadata: {
       implementation_status: "complete",
       key_decisions: [
         "Used JWT over session-based auth for stateless API",
         "Refresh token rotation every 7 days"
       ],
       files_created: ["auth/jwt_manager.py", "auth/middleware.py"],
       files_modified: ["api/routes.py", "config/settings.py"],
       dependencies_added: ["PyJWT==2.8.0"],
       testing_notes: "Test with curl scripts in tests/auth/"
     },
     relationships: [{
       memory_id: "<hash-of-3-month-old-auth-memory>",
       type: "builds_on"
     }]
   })
   

Example 2: Fixing Data Recovery Bug

User says: "The zip disk recovery keeps failing on bad sectors"

You do:

1. Research

   search-enhanced("zip disk recovery errors", filters={type: "code"})
   list-memories-by-tag(["data-recovery", "bugs", "zip-disk"])
   

   Result: Found memory about ddrescue parameters and common failures

2. Implement Applied lessons about proper ddrescue flags and error handling

3. Document

   store-dev-memory({
     type: "code",
     content: "Fixed zip disk recovery by adjusting ddrescue retry parameters",
     project: "vintage-data-recovery",
     tags: ["data-recovery", "zip-disk", "bugfix", "ddrescue"],
     metadata: {
       implementation_status: "complete",
       key_decisions: [
         "Increased retry count from 3 to 10 for bad sectors",
         "Added sector size specification for old media"
       ],
       files_modified: ["recovery_scripts/zip_disk_reader.sh"],
       testing_notes: "Tested on 5 failing disks, 3 now readable"
     },
     relationships: [{
       memory_id: "<hash-of-ddrescue-lessons>",
       type: "applies"
     }]
   })
   

Rules

• ✅ Always search memory before implementing - Check for patterns first
• ✅ Store learnings after every task - Every task generates knowledge
• ✅ Be specific in descriptions - Detail what was actually done
• ✅ Link related memories - Create relationships to related work
• ✅ Include key decisions - Future you needs to know why
• ✅ Tag appropriately - Use consistent, searchable tags
• ❌ Don't skip research phase - No matter how simple the task seems
• ❌ Don't forget to store - Even small fixes generate learnings
• ❌ Don't store generic descriptions - "Fixed bug" isn't useful
• ❌ Don't skip relationships - Context comes from connections
• ❌ Don't omit metadata - Files, decisions, tests matter

Success Metrics

• Every feature implementation references at least 1 past memory
• Every completed task stores at least 1 new memory
• Memory retrieval takes <500ms
• 90% of new implementations find relevant patterns in memory