undefined

undefined

REFLECT    - Notice what happened (correction, preference, pattern)
ABSTRACT   - Extract the generalizable principle
GENERALIZE - Determine scope (global, domain, project, session)
STORE      - Persist to appropriate memory file

User: "No, don't use snake_case for that. Use camelCase for JavaScript."
Trigger: Explicit correction of Claude's behavior
Action: Capture coding style preference

User: "I prefer shorter commit messages, just one line."
Trigger: Statement of preference (I prefer, I like, I want, always, never)
Action: Capture workflow preference

User: "Remember that this project uses tabs, not spaces."
Trigger: Direct request to remember (remember, don't forget, always do)
Action: Store as project-level preference

User: "Perfect! That's exactly how I want error messages formatted."
Trigger: Positive feedback on specific behavior
Action: Reinforce and capture the pattern

User asks for the same type of change 3+ times in a session
Trigger: Repetition detection
Action: Extract pattern for automation

Claude makes mistake -> User corrects -> Claude succeeds
Trigger: Correction followed by success
Action: Capture the correction as a learning

undefined

undefined

                    +------------------+
                    |    DETECTION     |
                    | (correction,     |
                    |  preference,     |
                    |  pattern)        |
                    +--------+---------+
                             |
                             v
+------------------+    +---------+    +------------------+
|     REFLECT      |<---|  Event  |--->|     ABSTRACT     |
| What happened?   |    +---------+    | What's the       |
| What was wrong?  |                   | underlying       |
| What was right?  |                   | principle?       |
+--------+---------+                   +--------+---------+
         |                                      |
         v                                      v
+------------------+                   +------------------+
|   GENERALIZE     |                   |      STORE       |
| What scope?      |                   | Where to save?   |
| Global/Domain/   |                   | What format?     |
| Project/Session  |                   | How to retrieve? |
+--------+---------+                   +------------------+
         |                                      ^
         +--------------------------------------+

undefined

undefined

undefined

undefined

undefined

context_clues = principle.get("context_clues", [])

# Session-only: temporary, experimental
if any(word in context_clues for word in ["just this time", "for now", "temporarily"]):
    return "session"

# Project-specific: mentions project name or "this project"
if "this project" in context_clues or detect_project_name(context_clues):
    return "project"

# Domain-specific: mentions technology or domain
if detect_domain(context_clues):  # javascript, python, marine, etc.
    return "domain"

# Global: general preference, no specific context
return "global"

undefined

undefined

learning_entry = {
    "timestamp": datetime.now().isoformat(),
    "category": principle["category"],
    "rule": principle["rule"],
    "anti_pattern": principle.get("anti_pattern"),
    "correct_pattern": principle["correct_pattern"],
    "confidence": principle.get("confidence", 0.8),
    "source": "user_correction",
    "times_applied": 0
}

# Route to appropriate storage
storage_paths = {
    "global": "~/.claude/memory/global_learnings.yaml",
    "domain": f"~/.claude/memory/domains/{domain}/learnings.yaml",
    "project": ".claude/memory/project_learnings.yaml",
    "session": "session_context"  # Not persisted
}

append_to_yaml(storage_paths[scope], learning_entry)

undefined

+----------------------------------------------------------+
|  GLOBAL (~/.claude/memory/global_learnings.yaml)         |
|  - User-wide preferences                                  |
|  - Universal coding style                                 |
|  - Communication preferences                              |
|  +-----------------------------------------------------+ |
|  |  DOMAIN (~/.claude/memory/domains/<domain>/)        | |
|  |  - Technology-specific preferences                   | |
|  |  - Domain knowledge (marine, finance, etc.)         | |
|  |  +------------------------------------------------+ | |
|  |  |  PROJECT (.claude/memory/project_learnings.yaml)| | |
|  |  |  - Project conventions                          | | |
|  |  |  - Team standards                               | | |
|  |  |  +-------------------------------------------+ | | |
|  |  |  |  SESSION (in-memory only)                 | | | |
|  |  |  |  - Temporary adjustments                  | | | |
|  |  |  |  - Experimental preferences               | | | |
|  |  |  +-------------------------------------------+ | | |
|  |  +------------------------------------------------+ | |
|  +-----------------------------------------------------+ |
+----------------------------------------------------------+

~/.claude/
├── memory/
│   ├── global_learnings.yaml       # User-wide learnings
│   ├── preferences.yaml            # User preferences
│   ├── patterns.yaml               # Workflow patterns
│   ├── corrections.yaml            # Correction history
│   └── domains/
│       ├── python/
│       │   ├── learnings.yaml
│       │   └── patterns.yaml
│       ├── javascript/
│       │   ├── learnings.yaml
│       │   └── patterns.yaml
│       └── marine-engineering/
│           ├── learnings.yaml
│           └── domain_knowledge.yaml
└── reflection/
    ├── session_log.yaml            # Current session learnings
    └── pending_confirmations.yaml  # Learnings awaiting validation

<project>/.claude/
├── memory/
│   ├── project_learnings.yaml      # Project-specific learnings
│   ├── team_preferences.yaml       # Team conventions
│   └── automation_candidates.yaml  # Patterns to automate
└── reflection/
    └── history.yaml                # Reflection history

undefined

**Example 1: Coding Style Correction**

```yaml

**Example 2: Error Handling Correction**

```python

undefined

undefined

**Example 3: Communication Preference**

```yaml

**Example 4: Formatting Preference**

```yaml

undefined

def detect_workflow_pattern(session_history: list) -> Optional[dict]:
    """Detect repeated workflow patterns worth automating."""

    # Look for repeated sequences
    sequences = extract_sequences(session_history)

    for sequence in sequences:
        if sequence.occurrences >= 3:
            pattern = {
                "steps": sequence.steps,
                "occurrences": sequence.occurrences,
                "trigger": identify_trigger(sequence),
                "automation_potential": calculate_automation_score(sequence)
            }

            if pattern["automation_potential"] > 0.7:
                return pattern

    return None

undefined

**Example 6: Data Analysis Pattern**

```yaml

undefined

undefined

**Persistence Operations:**

```python
def persist_learning(learning: dict, scope: str) -> str:
    """Persist a learning to the appropriate memory file."""

    # Determine storage path
    if scope == "global":
        path = Path.home() / ".claude/memory/global_learnings.yaml"
    elif scope == "domain":
        domain = learning.get("domain", "general")
        path = Path.home() / f".claude/memory/domains/{domain}/learnings.yaml"
    elif scope == "project":
        path = Path.cwd() / ".claude/memory/project_learnings.yaml"
    else:
        return "session_only"  # Don't persist

    # Ensure directory exists
    path.parent.mkdir(parents=True, exist_ok=True)

    # Load existing learnings
    if path.exists():
        with open(path) as f:
            data = yaml.safe_load(f) or {"learnings": []}
    else:
        data = {
            "version": "1.0",
            "last_updated": None,
            "total_learnings": 0,
            "learnings": []
        }

    # Add new learning
    learning["id"] = f"learn-{len(data['learnings']) + 1:04d}"
    data["learnings"].append(learning)
    data["last_updated"] = datetime.now().isoformat()
    data["total_learnings"] = len(data["learnings"])

    # Write back
    with open(path, "w") as f:
        yaml.dump(data, f, default_flow_style=False)

    return learning["id"]

def load_applicable_learnings(project_path: Optional[Path] = None) -> dict:
    """Load all learnings applicable to current context."""

    learnings = {
        "global": [],
        "domain": [],
        "project": []
    }

    # 1. Load global learnings
    global_path = Path.home() / ".claude/memory/global_learnings.yaml"
    if global_path.exists():
        with open(global_path) as f:
            data = yaml.safe_load(f)
            learnings["global"] = data.get("learnings", [])

    # 2. Load domain learnings (detect from project)
    domains = detect_project_domains(project_path)
    for domain in domains:
        domain_path = Path.home() / f".claude/memory/domains/{domain}/learnings.yaml"
        if domain_path.exists():
            with open(domain_path) as f:
                data = yaml.safe_load(f)
                learnings["domain"].extend(data.get("learnings", []))

    # 3. Load project learnings
    if project_path:
        project_mem = project_path / ".claude/memory/project_learnings.yaml"
        if project_mem.exists():
            with open(project_mem) as f:
                data = yaml.safe_load(f)
                learnings["project"] = data.get("learnings", [])

    return learnings

def apply_learnings_to_context(learnings: dict) -> str:
    """Generate context prompt from loaded learnings."""

    context_parts = []

    # High-priority learnings (high confidence, frequently applied)
    priority_learnings = []
    for scope in ["global", "domain", "project"]:
        for learning in learnings[scope]:
            if learning.get("confidence", 0) > 0.8 and learning.get("times_applied", 0) > 3:
                priority_learnings.append(learning)

    if priority_learnings:
        context_parts.append("## Learned Preferences\n")
        for learning in priority_learnings[:10]:  # Top 10
            context_parts.append(f"- {learning['rule']}")

    return "\n".join(context_parts)

undefined

undefined

#!/bin/bash

undefined

undefined

- type: preference
  rule: "Prefer functional approach over OOP"
  scope: project
  confidence: 0.85

- type: pattern
  name: "Test-then-implement workflow"
  occurrences: 3
  automation_potential: 0.7

undefined

undefined

undefined

undefined

undefined

undefined

undefined

undefined

# Check for explicit scope indicators
if "this project" in learning.get("context", "").lower():
    return "project"

if "always" in learning.get("context", "").lower():
    return "global"

# Check for domain indicators
domain_keywords = {
    "javascript": "javascript",
    "python": "python",
    "marine": "marine-engineering",
    "offshore": "marine-engineering",
    "react": "javascript"
}

for keyword, domain in domain_keywords.items():
    if keyword in learning.get("rule", "").lower():
        learning["domain"] = domain
        return "domain"

# Default to project if uncertain
return "project"

undefined

undefined

learning_2:
  rule: "Use 2-space indentation"
  timestamp: "2026-01-17"
  confidence: 0.95

resolution:
  action: "supersede"
  winner: learning_2
  reason: "Newer with higher confidence"

undefined

undefined

undefined

undefined

undefined

undefined

**Solution:**
- Manually validate the learning
- Increase confidence by repeating the preference
- Check for conflicting learnings

undefined

**Solution:**
- Review and remove outdated learnings
- Set appropriate scopes
- Explicitly confirm the correct preference

undefined

**Solution:**
```bash

undefined

undefined

undefined