Skip to content
Skills Library
AI & agents · Automation

remember

/remember

Capture a durable learning so future sessions reuse it automatically. Use when the user corrects Claude, states a preference or rule, shares a debugging insight, or says 'remember this'. Writes to agent-memory.

Repository
claude-kit ↗
Licence
MIT
Last repository change
07.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
1
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.

What it does and when to use it

Capture a durable learning so future sessions reuse it automatically. Use when the user corrects Claude, states a preference or rule, shares a debugging insight, or says 'remember this'. Writes to agent-memory.

Triggers from the description

remember this
Original author description

Capture a durable learning so future sessions reuse it automatically. Use when the user corrects Claude, states a preference or rule, shares a debugging insight, or says 'remember this'. Writes to agent-memory.

How it works

  1. When to invoke this skill
  2. How to capture (4 steps)
  3. After capturing
  4. How application works (for reference)
Original SKILL.md headings · 96 lines, 870 words
SKILL.md preview
---
name: remember
description: Capture a durable learning so future sessions reuse it automatically. Use when the user corrects Claude, states a preference or rule, shares a debugging insight, or says 'remember this'. Writes to agent-memory.
---

# Remember — Durable Learning Capture

Turn a one-off correction or insight into a permanent, reusable learning. This is the **capture** half of the self-improving loop. The **application** half is automatic: the `load-learnings.sh` SessionStart hook injects the learnings index (`.claude/agent-memory/MEMORY.md`) into context at the start of every session, so anything recorded here is surfaced before future work.

## When to invoke this skill

**Automatic only when capture was chosen at init.** On installs where a `capture_mode` was explicitly selected, the `capture-learnings` hook runs in the *background* — on the chosen schedule (when a session ends, on the next launch for sessions closed abruptly, and/or after each task) — spawning a detached `claude` job that records what Claude learned from its *own* work into `.claude/agent-memory/`, without ever blocking your session or next prompt (and records nothing when the work was routine). On those installs, explicit use of this skill remains available to force a capture. On installs without capture (the default), this skill is the only capture path. Invoke proactively whenever any of these happen:

- The user **corrects** something Claude did ("no, buttons should be 44px touch targets", "always validate at the boundary").
- The user states a **preference or rule** for how work should be done (UX, design, naming, architecture, testing, tone).
- A **debugging session** uncovered a non-obvious root cause that took real effort to find.
- An **API / integration quirk** surfaced that isn't visible in the code.
- The user says "remember this", "note this", "next time…", "don't repeat this", or similar.

Do **not** record:
- Facts already visible in the codebase or the rules under `.claude/rules/`.
- Standard framework behavior (look it up instead).
- Temporary task state (that's what tasks are for).
- Anything already captured — update the existing entry instead of duplicating.

## How to capture (4 steps)

### 1. Decide the category

Map the learning to one folder under `.claude/agent-memory/`:

| Category | Folder | What goes here |
|----------|--------|----------------|
| UX / Design | `ux/` | Interaction rules, design-system preferences, accessibility musts, layout/visual decisions |
| Architecture | `architecture/` | Why X over Y, structural decisions, module boundaries |
| Debugging | `debugging/` | Root causes of tricky bugs, non-obvious failure modes |
| Patterns | `patterns/` | Recurring project-specific patterns and conventions |
| API & Integration | `api/` | API quirks, auth flows, endpoint behaviors |
| Performance | `performance/` | Optimization discoveries, bottleneck insights |
| Gotchas | `gotchas/` | Looks-right-but-isn't traps, common mistakes |

If unsure, pick the closest fit; UX preferences go in `ux/`.

### 2. Check for an existing entry

Read `.claude/agent-memory/MEMORY.md` and skim the relevant category folder. If a similar learning exists, **edit that file** (refine, add nuance, correct it) rather than creating a duplicate. While you're there, sanity-check that the existing entry is still accurate against the current code — if it has gone stale (a renamed file, a changed flag, behavior that no longer holds), fix or remove it rather than stacking a contradicting entry beside it (the verify-before-trust checks in `.claude/rules/agent-memory.md`). When the new learning **touches, extends, or contradicts** a distinct existing entry (rather than duplicating it), keep both — and add a reciprocal `## Related` line in each file so a future reader of either entry finds the other.

### 3. Write the learning file

Filename: lowercase kebab-case describing the insight, e.g. `touch-target-min-size.md`, `filter-resets-on-persona-change.md`. Write to `.claude/agent-memory/<category>/<filename>.md` using this format:

```markdown
---
title: {short descriptive title}
category: {category name}
date: {YYYY-MM-DD}
trigger: {when this applies — e.g. "designing any UI", "writing an HTTP endpoint"}
---

## Context
{What situation produced this learning — keep it brief}

## Learning
{The rule/insight, stated as a clear, actionable directive Claude can follow next time}

## Evidence
{How it was discovered — the user's words, an error, debugging steps}

## Apply when
{Concrete signal that this learning is relevant to the current task}

## Related   <!-- optional — only when a genuinely connected entry exists -->
- [other entry](../category/filename.md) — why it's connected
```

The `trigger` and `Apply when` fields matter most — they are how a future session knows to pull this learning before acting. `## Related` is optional: link only entries that genuinely connect (extends, contradicts-then-resolved, same subsystem), so a reader of one finds the other without scanning the whole store.

### 4. Update the index

Add a one-line entry to `.claude/agent-memory/MEMORY.md` under the matching `###` section:

```markdown
- [Title](category/filename.md) — one-line hook | applies when: {trigger}
```

Keep each index line under ~150 chars. The index is what the SessionStart hook injects, so it must stay scannable.

## After capturing

Confirm to the user in one line what was recorded and where, e.g.:
> Recorded: "44px minimum touch targets" → `agent-memory/ux/touch-target-min-size.md`. I'll apply it automatically next time I design UI.

## How application works (for reference)

You do not need to do anything to apply learnings — the loop closes on its own:

1. `load-learnings.sh` runs on **SessionStart** and prints the MEMORY.md index into context.
2. Before doing design/implementation work, open the relevant category file(s) flagged by `Apply when` and follow them.
3. When you learn something new, this skill records it — and it shows up automatically next session.

Versions

RepositoryScoreLicence
This page · ajyadav013/claude-kit100MIT
yonatangross/orchestkit100MIT
langchain-ai/deepagents100MIT
zereight/gitlab-mcp100MIT
stxrmik/antigravity-plus100MIT
rohitg00/agentmemory100Apache-2.0
eleboucher/memini100AGPL-3.0
ffMathy/hey-jarvis100MIT
alirezarezvani/claude-skills100MIT

Database snapshot: 13.11.2026 · package version 3e59930724d2 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100learning-capture
    Capture a durable learning by editing context directly. Triggers when the user corrects Claude in a generalizable way ("use X instead of Y", "always X", "never Y", "I prefer X", "from now on X"), states a reusable preference, or asks to "remember this" / "save this". Also…
  • 82memory
    Save, change or forget a durable fact when the user says remember, note that, commit to memory or forget
  • 100pin
    Turn a correction or working preference the user just expressed into a permanent ballast rule. Use when the user corrects your behavior, says "don't do X" / "always do Y" / "I told you before", or asks you to remember how they want things done.
  • 100capture
    Save a memory to Origin in flow. Active capture verb — use proactively when the user states a preference, makes a decision, corrects you, or shares a durable fact. Invoked as `/capture <content>`.
  • 90working-memory-protocol
    Use when deciding what to record with working_memory_note, when the user says "remember this" or corrects you, or when a Crystal Pointer matches the topic. Not for answering from memory (use memory_search).
  • 100membrane-write-memory
    Write a memory into membrane's long-term field. Use when the user says "learn that X", "remember that X", "save this to your memory", or asks to store a fact/preference/lesson -- AND when YOU earn a durable lesson during work (a fixed quirk, the command that worked, why the…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.