self-learning-skills: a meta-skill that saves an agent's hard-won route so the next session starts knowing it

Stopping an agent from re-learning the same thing every session

self-learning-skills targets a specific waste: every session an agent rediscovers the same operational facts, how to reach the production database, where the credentials live, what the deploy command is, and that knowledge evaporates when the session ends. The next session starts from zero. The README's fix is a meta-skill that teaches the agent to recognize when it has just earned a reusable golden path and persist it where the tool will auto-load it next time.

The user is anyone running an agent on a real codebase with operational friction, a place where the same debugging or the same non-obvious command recurs across sessions. It works with Claude Code, Cursor and any agent that reads an AGENTS.md or standing-instructions file, and it is MIT licensed.

What makes it distinct is that it does not do the work; it captures how the work got done. The README stresses this includes the failures, since skipping a known dead end next session is often worth more than the win. Capturing what did not work is the part most memory tools omit, and it is arguably the more valuable half.

Recognize, capture, reuse, without a prompt

The loop is the same everywhere: recognize the moment, capture it, reuse it. The README describes recognition triggers as a task that only worked after several tries, a non-obvious command, a project fact you did not know up front, a recurring operational workflow, or simply you saying remember this.

Capture happens without a prompt. The README says it acts on the cue immediately, picks the scope and name itself, tells you afterward, and captures the procedure rather than a one-off answer, plus a note on what did not work. Reuse is automatic on the next session, either because a skill or rule description matches or because the instructions file is always read.

The part that differs per tool is only where knowledge is persisted and how it auto-loads. For Claude Code, Codex and Agent Skills clients it writes a new `skills/<name>/SKILL.md` loaded by description matching. For Cursor it writes a `.cursor/rules/learned/<name>.mdc` loaded by rule description or globs. For Zed, Aider, Gemini CLI and similar it appends to `AGENTS.md`, which is always read. The mechanism is adapted to each tool's native auto-load path rather than inventing a new store.

Installing across many agents at once

The recommended install uses the community `skills` CLI, which detects and installs into whatever agents are present:

npx skills add kulaxyz/self-learning-skills
npx skills add kulaxyz/self-learning-skills -g
npx skills add kulaxyz/self-learning-skills -a claude-code

The bare command installs into the current project and auto-detects agents, `-g` installs globally across all your projects, and `-a claude-code` targets a specific agent. The README says this path works with 70-plus agents through the same CLI.

Claude Code users can instead use the plugin marketplace:

/plugin marketplace add kulaxyz/self-learning-skills
/plugin install self-learning@self-learning-skills

There is also a manual path in the README for copying the files into place per tool, cloning the repository and copying the skill into `~/.claude/skills/`, the Cursor rule into `.cursor/rules/`, or appending `AGENTS.md`. Because installation is just placing files where the agent already looks, uninstalling is deleting them, which keeps the footprint honest.

Triage keeps it from bloating your config

A real risk with any auto-capture tool is that it fills your configuration with one-line trivia. The README says self-learning routes each lesson rather than dumping everything: a multi-step reusable procedure or workflow becomes a new skill, while smaller facts go to memory or are skipped. That triage, skill, memory, or skip, is what stops a memory system from becoming noise.

The honest limitation is that the quality of what gets captured depends on the agent's judgement about what counts as a golden path, and on the model doing the capturing. A weak recognition step will either miss reusable routes or save clutter, and a captured procedure that is subtly wrong will mislead the next session with the confidence of a saved fact. Because capture happens without a prompt, a user has to review what accumulates rather than assume it is all correct.

There is also a trust dimension: a skill that writes new skills and standing instructions is modifying what the agent will silently load later. That is the point, but it means the persisted entries are a surface worth reading periodically, especially operational ones about credentials and deploys.

Against plain project notes or a static AGENTS.md

The alternative is doing this by hand: keeping a NOTES file or curating AGENTS.md yourself with the commands and gotchas you want the agent to remember. That is fully under your control and has no capture logic to trust.

The difference self-learning offers is that the capture happens at the moment the knowledge is earned, automatically, including the dead ends, rather than depending on you remembering to write it down after a hard session, which is exactly when you are least likely to. Manual notes are accurate but chronically incomplete because the discipline fails under pressure. self-learning trades some of that accuracy control for capture that actually happens, and routes each lesson to the right store so it auto-loads. Choose hand-curated notes if you are disciplined and want total control over what the agent reads. Choose self-learning when the recurring-rediscovery tax is real and you would rather have imperfect automatic capture than perfect notes you never write, provided you periodically review what it saved.

MIT, file-based, and where to start

self-learning-skills is MIT licensed and file-based, so it can be forked, trimmed to the tools you use, or shared across a team by committing the harvested skills into a project's `.claude/skills/`. Because everything it produces is plain files in the agent's native locations, there is no runtime to maintain and no lock-in: the captured knowledge outlives the meta-skill itself.

Upgrade cost is minimal for the same reason. The meta-skill is a small set of instructions; the valuable artifacts are the golden paths it writes, which are yours regardless of whether you update the tool. Keeping current is re-running the `skills` CLI.

The concrete first step is to install it where your agent already looks, then deliberately trigger a capture on your next hard-won result, solve a non-obvious deploy or DB-access step, say remember this, and confirm it wrote a `SKILL.md`, `.mdc` rule or `AGENTS.md` entry with both the procedure and the what-did-not-work note. Then open that entry and check it is accurate, because the whole value rests on the next session loading something correct.

Editorial conclusion

Use self-learning-skills if your agent keeps rediscovering the same operational routes across sessions and you want them captured automatically, including the dead ends, where Claude Code, Cursor or an AGENTS.md agent will auto-load them: the failure notes and the per-tool routing are what make it more than a memory dump. It is the wrong fit if you are already disciplined about hand-curating notes and want full control over what loads, or if you will not review what it captures, since an auto-saved wrong procedure misleads with a saved fact's confidence. Start by installing with npx skills add, trigger a capture on your next hard-won result, and open the written SKILL.md, .mdc or AGENTS.md entry to confirm the procedure and its what-did-not-work note are correct.

Frequently asked questions

Official sources

1. Issues
2. Kulaxyz/self-learning-skills on GitHub
3. License: MIT
4. README