github.com/kat-titter/claude-code-learnsupdated Oct 2026

Let Claude Code keep what you teach it

You correct the agent once and it keeps the lesson. Feedback in any chat becomes a short guideline in a Skill, the library organizes itself, and a weekly check looks for new skills that fill a gap. It is built only on what Claude Code already has: Skills, hooks, memory and scheduled tasks.

Learns fast

A correction becomes guidance in the same turn, written for the whole family of problems. A lesson that fits an existing skill is folded into it.

Notices its own mistakes

Hooks flag feedback, and the agent treats its own surprise and debugging as signals. It asks whether each lesson applies beyond the task, and audits the library weekly.

Stays light

Every session carries only skill descriptions, each short with its use case first, and one memory index. Bodies and notes load when a task calls for them, and scripts do the reading.

00the loop

noticea correction, a preference, surprise at a result, or the agent's own bug
generalizewhich family of problems is this? write for the siblings
routea general skill, your style skill, project memory, or CLAUDE.md
writethe gist in one line: what to do, the example, the date
validateit parses, triggers on realistic prompts and handles a second case
organizeone home per guideline; merge, split and compress on signals
watchweekly: new skills upstream, gaps, health and footprint

01notice

Hooks are tiny scripts Claude Code runs at set moments. When your message reads like feedback, one adds a line of context: does this apply beyond the task? if so, route it. When a request shares rare words with a skill's description, another names that skill, because skills often go unused even when they fit. After each reply, a third jots any feedback into a lessons inbox, a quick notebook. The agent also counts its own surprise ("17 s a frame seems like a lot") and its own debugging as signals. Most messages trigger none of this.

02route

the lesson is about	it goes to	example
how anyone does this work well	a general skill	name each control by what was in the well
your taste and way of working	your `<name>-style` skill	separate items with space, not dots
one project's facts	that project's memory	this lab ran the drug at 0.625 µM
true in every project	`CLAUDE.md`	feedback becomes guidance, in the same turn

General skills stay usable by anyone; your taste lives in one place they point to.

03write the gist

---
name: macos-long-render
description: Keep long Mac jobs awake (renders, training, batch) so they don't stall
  overnight. Use when a job runs over an hour or ran far slower than its estimate.
---
- Wrap the job in caffeinate: `caffeinate -dimsu python3 job.py`.
  A steady rate that drops off a cliff overnight is sleep, not heat.
  (2026-06-28: "17s/frame seems like a lot")

The description is the trigger, so it opens with the use case and ends with the words people say. Each guideline says what to do, with the example and the reason: guidance the agent can weigh, not rules, and only what the agent does not already know. A second case folds into the same line.

04validate

The frontmatter parses in a YAML parser (claude plugin validate can pass with nothing checked); one that doesn't loads with no description.
Three realistic prompts load it and two near-misses don't (trigger-evals.py, old description against new, three runs each).
It loads in real sessions: trigger-misses.py shows, per skill, how often a request that matched it actually loaded it. In one library the answer was about 1 time in 5.
It handles a sibling case; a bundled checker proves it on a second input.
It traces to a real moment. Anything that doesn't stays in the inbox.

05organize and refactor

Every guideline has one obvious home, so the next lesson knows where to go. Before writing, find the section that already answers the question and extend its line. When the signs show, refactor in one pass:

two descriptions fire on the same prompt: merge
one skill answers several questions or passes ~200 lines: split by task
the same guideline sits in two skills: keep it in its owner, link from the other
personal taste in a general skill: move it to your style skill
a line no task has needed in months: archive it

audit-skills.py reports each sign, including the same advice in two skills, in well under a second.

06watch, weekly

A scheduled task runs skills-watch.py, which remembers what it saw and reports only what changed. The agent then reads just the new skills' descriptions and leaves at most five proposals. Installing and editing wait for your yes.

# Skills watch, 2026-11-02
New or updated upstream    skills added to anthropics/skills or a plugin marketplace
Gaps in the library        feedback no skill covers, and the words that recur in it
Library health             audit flags; a flag two weeks running becomes a proposal
Footprint                  what loads every session against what waits on disk
Proposed                   at most five changes, most useful first

07stays light

What a session carries against what waits until it is needed, in one real library (2026-10-26, 22 skills):

carried every sessionloaded when a task needs it

skill descriptions17.2 KB skill bodies213 KB memory index11.0 KB memory notes226 KB

Memory keeps one fact per note and one line per note in its index. Scripts read every file; the agent reads their short reports and only the files they name.

08why it works

It borrows the brain's split between a fast learner and a slow one¹, a split also proposed for intelligent agents².

the brain	this setup
errors are monitored as they happen³	the feedback hook, and the agent's own surprise and debugging
a fast store grabs what just happened¹	the lessons inbox
only tagged, salient or repeated moments last⁴	promote what recurs or matters
what fits a schema consolidates within two days⁵	fold a lesson into the section that owns it
offline replay consolidates⁶	the weekly watch and tidy pass
downscaling keeps the system efficient⁷	compress, merge, archive

09install

git clone https://github.com/kat-titter/claude-code-learns
cd claude-code-learns && ./install.sh --name yourname --dry-run
./install.sh --name yourname

It adds capture-lesson, prompt-practice, a yourname-style skill, a CLAUDE.md that routes feedback, an inbox and an index, and merges five small hooks into settings.json after a backup. Re-running is safe, and ./install.sh --uninstall undoes it. For the weekly watch, paste weekly-watch.md into a weekly scheduled task.

10references

McClelland, J. L., McNaughton, B. L., & O'Reilly, R. C. (1995). Why there are complementary learning systems in the hippocampus and neocortex. Psychological Review, 102(3), 419–457. doi:10.1037/0033-295X.102.3.419
Kumaran, D., Hassabis, D., & McClelland, J. L. (2016). What learning systems do intelligent agents need? Complementary learning systems theory updated. Trends in Cognitive Sciences, 20(7), 512–534. doi:10.1016/j.tics.2016.05.004
Yeung, N., & Summerfield, C. (2012). Metacognition in human decision-making: confidence and error monitoring. Philosophical Transactions of the Royal Society B, 367(1594), 1310–1321. doi:10.1098/rstb.2011.0416
Frey, U., & Morris, R. G. M. (1997). Synaptic tagging and long-term potentiation. Nature, 385(6616), 533–536. doi:10.1038/385533a0
Tse, D., Langston, R. F., Kakeyama, M., et al. (2007). Schemas and memory consolidation. Science, 316(5821), 76–82. doi:10.1126/science.1135935
Wilson, M. A., & McNaughton, B. L. (1994). Reactivation of hippocampal ensemble memories during sleep. Science, 265(5172), 676–679. doi:10.1126/science.8036517
Tononi, G., & Cirelli, C. (2014). Sleep and the price of plasticity: from synaptic and cellular homeostasis to memory consolidation and integration. Neuron, 81(1), 12–34. doi:10.1016/j.neuron.2013.12.025