Your Coding Agent Forgets Everything You Tell It. Here’s the 30-Second Fix.

Give Claude Code, Cursor, Codex, or Aider a real memory. No migration, no new tool to learn, one curl-bash command.

You explained it on Tuesday. Your team uses pnpm, not npm. Commits follow Conventional Commits. Nobody force-pushes to main. The agent nodded, fixed the bug, shipped clean.

Wednesday morning, fresh session. It runs npm install, writes a commit that says "fixed stuff", and reaches for git push --force the second a rebase gets hairy.

So you explain it again. And again Thursday. Every coding agent on the market ships with the same flaw: total amnesia between sessions. You are paying for a senior engineer who arrives every morning with no memory of yesterday.

There is a fix, and it installs in about thirty seconds, on macOS, Linux, or Windows.

macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/Prajwalabraham/make-any-coding-assistant-self-learning/main/install.sh | bash

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/Prajwalabraham/make-any-coding-assistant-self-learning/main/install.ps1 | iex

The two options everyone hates

Today you have two ways to deal with the amnesia, and both are bad.

Option one: review every diff forever. You become the agent’s permanent memory. It never gets better, and your attention is the bottleneck.

Option two: the 4,000-line config file. You stuff every preference you have ever had into CLAUDE.md (or AGENTS.md, or .cursorrules). The model then half-ignores it, because nothing alive reads 4,000 lines carefully on every single turn. The file rots, contradicts itself, and quietly stops mattering.

There is a third option nobody set up for you, because it takes real wiring. Make the agent learn instead of read.

What “self-learning” actually means

This is not fine-tuning. There is no vector database, no embeddings graph, no training run. It is three flat layers of plain markdown plus one trigger that makes the model consider saving on every turn.

• Persona. How the agent talks and works. Updated when you correct its style.
• Memory. One file per fact, plus a tiny always-loaded index. Written when you state a preference or a fact.
• Skills. One file per repeatable workflow, loaded on demand. Created when a process repeats three times.

The same architecture powers the best from-scratch agent frameworks out there. The problem is that they ask you to abandon the agent you already use to get it.

The catch with every “self-learning agent” so far

Frameworks like Hermes, OpenClaw, and OpenCode already nailed this architecture. If you are starting fresh, they are excellent and you should use one.

But almost nobody is starting fresh.

If you have spent six months building muscle memory in Claude Code or Cursor, switching is a tax you will not pay. You would give up the IDE integration you actually use, relearn a new keybinding set and a new failure-mode catalogue, and stand up a fresh environment by hand before any of it pays off.

So most developers just don’t migrate. They stay put, keep re-typing the same instructions every morning, and the whole self-learning idea stays a thing they read about once.

This project is the wedge. It takes the proven architecture (persona, memory, skills, scheduled cleanup) and ports it as a drop-in scaffold into the agent you are already in. No migration. No new interface. You keep your setup and your habits, and your agent starts remembering.

It is not “markdown is portable, good luck”

Here is the part most multi-tool claims quietly skip. The four major agents do not share a config shape. Hook event names differ. Memory locations differ. The mechanism that injects a rule into context differs. Slash-command syntax differs.

This ships a real, working scaffold for each one, built on that tool’s actual API:

AgentAuto-load mechanismHow it remembersClaude CodeSessionStart + UserPromptSubmit hooksreal shell hooksCursoralwaysApply: true rulesalways-on rule injectionCodex CLIauto-read AGENTS.mdmodel self-promptAiderread: list in .aider.conf.ymlmodel self-prompt

Open the Cursor template and you get actual .mdc rule files with the right frontmatter, not Claude Code files renamed. That honesty is the whole point.

What changes, week by week

Week one. Fresh install, works like a stock session. You correct it twice. Both corrections become memory files. The index grows by two lines.

Week two. New session, different file. The protocol fires, the agent sees the rule, applies it silently, and never makes that mistake again.

Week four. You have explained your release process three times. The scaffold notices, drafts a cut-release skill, and shows it to you. You tweak one line and save. Every future "cut a release" now runs the recipe without re-instruction.

Week eight. A weekly cron fires the memory-keeper. It archives eleven facts that went stale when you switched auth services, and trims the index back to high-signal entries. Think git gc for your agent's brain.

By now the agent is genuinely better in your repo than any fresh install could be. Not because the model got smarter, but because the scaffolding finally captured the months of context you used to re-explain every morning.

The best part: you never hear about it

The single most important rule in the design is that the agent never announces what it learned. No “I’ll remember that you prefer X!” popups. No chatty confirmations training you to ignore its output.

The win condition is invisible. Three weeks in, you simply notice it stopped writing commits like “fixed stuff”. Silence is the feature.

Install it now

macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/Prajwalabraham/make-any-coding-assistant-self-learning/main/install.sh | bash

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/Prajwalabraham/make-any-coding-assistant-self-learning/main/install.ps1 | iex

It drops a sla command on your PATH and runs an interactive prompt: pick your agent, pick your scope (this project or your global config), confirm. It refuses to overwrite anything without an explicit yes, and if you already have a settings file it offers to merge rather than clobber. Not sure it took? Run sla doctor and it tells you exactly which link in the chain is live and which is broken.

That is the whole commitment. One command, one prompt, and your agent stops forgetting.

The point

Every hour you spend re-explaining the same thing to your coding agent is an hour it could have spent being useful in your codebase specifically. The gap between a stock agent and one that knows your project like a six-month engineer is not a smarter model. It is a hundred small markdown files capturing what you already told it.

Install the scaffolding once. Let the agent maintain it. Stop teaching the same lesson twice.

Repo: https://github.com/Prajwalabraham/make-any-coding-assistant-self-learning

If your agent has ever run npm install in your pnpm repo for the tenth time, give this a star and try it on your next session.