Skill: jiajiaoy/learnloop (version 1.0.0)

--- name: learnloop version: 1.0.0 author: jiajiaoy homepage: https://clawhub.ai/skills/learnloop description: "Continuous learning protocol for Claude — captures corrections, errors, and user preferences into native auto-memory so the next session remembers. Stop teaching Claude the same thing twice." keywords: - continuous learning - persistent memory - auto-memory - learning loop - knowledge capture - self-improvement - memory protocol - Claude forgets - Claude repeats mistakes - AI forgets corrections - teach Claude twice - Claude has no memory - lost context - AI amnesia - AI agent - agentic - Claude Code - LLM memory - AI productivity - agentic memory - smarter Claude - make Claude better - Claude improvement - improve AI - agent improvement - 持续学习 - 自动记忆 - 智能记忆 - 不再重复错误 - AI记忆 - ThinkStack --- # LearnLoop Claude forgets everything between sessions by default. LearnLoop closes that loop — every correction, every error, every preference is captured into Claude Code's native auto-memory and auto-loaded next time. ## The Core Problem Without persistent learning, every session starts from zero: - You correct Claude → it agrees → next session, same mistake - You explain your role and preferences → gone tomorrow - A command fails with a known fix → re-debugged from scratch - An external tool has a gotcha → relearned on every encounter - You discover a better approach → never reused The result: smart in the moment, amnesic over time. Your time is spent re-teaching, not advancing. ## Why Native Memory LearnLoop writes directly to Claude Code's auto-memory system at `~/.claude/projects/<project-id>/memory/`: - **Auto-injected** — MEMORY.md is loaded into every new session, no manual recall needed - **Typed** — entries are classified (user / feedback / project / reference) so retrieval is sharp - **Linked** — memories cross-reference via `[[slug]]` for graph-style recall - **Local** — nothing leaves your machine No `.learnings/` folder to maintain, no separate file to read, no "did I check the log?" overhead. ## When to Activate Trigger LearnLoop on any of these moments: | Trigger | Save As | Example | |---------|---------|---------| | User corrects Claude ("No, that's wrong", "Actually...") | `feedback` | "Don't use `git add .` — too broad" | | Command or tool fails unexpectedly | `project` or `feedback` | "`npm test` requires Node 20+ in this repo" | | User shares role, expertise, or preference | `user` | "Senior backend dev, new to React" | | External system referenced | `reference` | "Bugs tracked in Linear project INGEST" | | Knowledge turned out to be outdated | `feedback` | "API moved from v1 to v2 in March" | | Better approach discovered for recurring task | `feedback` | "Use `rg` not `grep` — 10x faster in this monorepo" | | Project deadline or constraint mentioned | `project` | "Mobile freeze starts 2026-03-05" | If you'd otherwise say "I'll keep that in mind for next time" — that's the trigger. You can't keep it in mind. Save it. ## The Protocol ### Step 1: Detect the Trigger Watch for the seven moments above. The two strongest signals: - **User uses corrective language**: "no", "actually", "wrong", "stop", "don't" - **Validated success on a non-obvious choice**: user accepts an unusual approach without pushback ("yes exactly", "perfect") Save from failure AND success. Saving only corrections produces a fearful agent; saving validated wins keeps you bold. ### Step 2: Classify the Memory Type | Type | Use For | |------|---------| | `user` | Role, expertise, goals, communication preferences | | `feedback` | Behavioral rules: do this, don't do that, why | | `project` | Ongoing initiatives, deadlines, who/why context | | `reference` | Pointers to external systems (Linear, Grafana, Slack channels) | If unsure, ask: *does this guide my future behavior?* (feedback) *or describe a person?* (user) *or a workstream?* (project) *or point elsewhere?* (reference). ### Step 3: Write the Memory File Path: `~/.claude/projects/<project-id>/memory/<short-kebab-slug>.md` Frontmatter format: ```yaml --- name: short-kebab-slug description: one-line summary, specific enough to judge relevance later metadata: type: feedback --- ``` Body structure for `feedback` and `project` types — lead with the rule/fact, then: - **Why:** the reason (often a past incident or stated preference) - **How to apply:** when this guidance kicks in The **Why** is load-bearing. Without it, future-you can't judge edge cases — you'll either follow blindly or ignore stale rules. ### Step 4: Update MEMORY.md Index `MEMORY.md` is the index loaded into every session. One line per entry, under ~150 chars: ``` - [Title](slug.md) — one-line hook on when it matters ``` Keep it under 200 lines. If MEMORY.md fills up, consolidate related entries into single files rather than truncating. ### Step 5: Verify Before Recalling Memories age. Before acting on a recalled fact: - Names a file path? Check it exists. - Names a function or flag? `grep` for it. - Summarizes repo state? Prefer `git log` over the snapshot. If the memory conflicts with current reality, **update or delete the memory**. Don't act on stale memory. ## What NOT to Save These belong in code, git, or scratch — not memory: - Code patterns, architecture, file paths derivable from the project - Git history or who-changed-what (use `git log` / `git blame`) - Bug-fix recipes — the fix lives in the commit - Anything already in CLAUDE.md - Ephemeral task state (use TodoWrite or a plan instead) Even when the user says "remember this PR list" — ask what was *surprising* about it. The surprise is the memory. The list is not. ## Anti-Patterns to Avoid - **Save-everything spam** — memory becomes noise; future-you ignores it - **Skipping the "Why"** — rule without reason becomes dogma or gets discarded - **Duplicate entries** — check existing memories before writing a new one - **Cargo-culting from one session** — confirmed-twice beats said-once for behavioral rules - **Trusting stale memory** — always verify file/symbol/state before acting on a recalled claim ## Output Format When you decide to save: ``` [LearnLoop] Saving as <type>: <one-line summary> → memory/<slug>.md → MEMORY.md updated ``` When you decide *not* to save: ``` [LearnLoop] Noted but not saved — <reason> ``` Be visible about the loop. Silent saves hide the mechanism; users should see what you remembered and what you didn't. ## Pairs Well With LearnLoop is part of the **ThinkStack** — meta-skills that compound: - `clarity-first` — understand the request before you act - `thinkdeep` — reason through complex problems - `honest-critic` — push back instead of validating - `task-pilot` — execute structured plans - `learnloop` — never lose what you learned ```bash openclaw install learnloop openclaw install honest-critic openclaw install thinkdeep openclaw install clarity-first openclaw install task-pilot ```

path: README.md
content: # LearnLoop — Continuous Learning Protocol for Claude

> Captures corrections, errors, and user preferences into Claude Code's native auto-memory so the next session remembers. Stop teaching Claude the same thing twice.

[![clawhub](https://img.shields.io/badge/clawhub-learnloop-blue)](https://clawhub.ai/skills/learnloop)
[![thinkstack](https://img.shields.io/badge/ThinkStack-5%2F5-purple)](https://clawhub.ai/skills/learnloop)
[![openclaw](https://img.shields.io/badge/openclaw-skill-orange)](https://openclaw.ai)

## The Problem

By default, Claude starts every session from zero. You correct a mistake — gone tomorrow. You explain your role — re-explained next week. A command fails with a known fix — re-debugged from scratch.

Smart in the moment. Amnesic over time. Your time gets spent re-teaching instead of advancing.

## What it does

**Detect** — recognizes the seven trigger moments worth remembering (corrections, errors, preferences, deadlines, validated wins, knowledge gaps, external pointers)

**Classify** — sorts each learning into one of four types: `user`, `feedback`, `project`, `reference`

**Persist** — writes to Claude Code's native auto-memory at `~/.claude/projects/<id>/memory/`, auto-injected into every future session

**Verify** — checks recalled memories against current reality before acting; stale memory is updated or removed, never trusted blindly

## Why Native Memory (Not `.learnings/`)

Older self-improvement skills write to a `.learnings/` folder. LearnLoop uses Claude Code's built-in memory system instead:

| | `.learnings/*.md` | LearnLoop → native memory |
|---|---|---|
| Loaded into next session | Manual, agent must remember | Auto-injected via MEMORY.md |
| Typed | No | Yes (user / feedback / project / reference) |
| Cross-references | No | `[[slug]]` links |
| Setup | Create folder + 3 files | Zero — the directory already exists |

Same loop, half the friction.

## When to Activate

| Trigger | Memory Type |
|---|---|
| User corrects you ("no", "actually", "wrong") | `feedback` |
| Command or tool fails unexpectedly | `project` or `feedback` |
| User shares role, expertise, or preferences | `user` |
| External system referenced (Linear, Grafana, Slack) | `reference` |
| Knowledge turned out outdated | `feedback` |
| Better approach found for a recurring task | `feedback` |
| Deadline or constraint mentioned | `project` |

If you'd say "I'll keep that in mind" — you can't. Save it.

## Installation

```bash
openclaw install learnloop
```

## ThinkStack

LearnLoop is the fifth member of the **ThinkStack** — meta-skills that make Claude smarter at every stage:

```
clarity-first  →  thinkdeep  →  honest-critic  →  task-pilot  →  learnloop
 understand        analyze        challenge         execute        remember
```

```bash
openclaw install clarity-first
openclaw install thinkdeep
openclaw install honest-critic
openclaw install task-pilot
openclaw install learnloop
```

## Keywords

continuous learning · persistent memory · auto-memory · learning loop · knowledge capture · self-improvement · memory protocol · Claude forgets · Claude repeats mistakes · AI forgets corrections · teach Claude twice · Claude has no memory · lost context · AI amnesia · AI agent · agentic · Claude Code · LLM memory · AI productivity · agentic memory · smarter Claude · make Claude better · Claude improvement · improve AI · agent improvement · 持续学习 · 自动记忆 · 智能记忆 · 不再重复错误 · AI记忆

---

Built for [OpenClaw](https://openclaw.ai) · Published on [clawhub.ai](https://clawhub.ai/skills/learnloop)


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (HIGH)