Self Improving Agent
Turn Claude Code auto-memory notes into enforced CLAUDE.md rules and reusable skills so project learnings survive across sessions.
Overview
Self-Improving Agent is a journey-wide agent skill that curates Claude Code auto-memory into CLAUDE.md rules and reusable skills—usable whenever a solo builder needs durable agent knowledge before committing to more impl
Install
npx skills add https://github.com/alirezarezvani/claude-skills --skill self-improving-agentWhat is this skill?
- Five commands: /si:review, /si:promote, /si:extract, /si:status, /si:remember
- Analyzes MEMORY.md for promotion candidates, stale entries, and consolidation
- Graduates proven patterns into CLAUDE.md or .claude/rules/ for enforced behavior
- Extracts recurring debugging or workflow solutions into standalone skills
- Memory health dashboard with line counts, topic files, and capacity guidance
- Documents five slash commands: review, promote, extract, status, remember
- Targets Claude Code auto-memory from v2.1.32 onward
Adoption & trust: 782 installs on skills.sh; 17.5k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
Claude keeps rediscovering the same repo quirks in MEMORY.md while nothing graduates into rules your agent reliably follows.
Who is it for?
Daily Claude Code users on long-lived repos who already have auto-memory enabled and want governance over what becomes enforced guidance.
Skip if: Greenfield repos with empty memory, teams on editors without Claude auto-memory, or one-off scripts where persistent agent rules add no value.
When should I use this skill?
Reviewing what Claude learned, graduating MEMORY.md to CLAUDE.md or rules, turning debugging into a skill, or checking memory health and capacity.
What do I get? / Deliverables
Proven patterns land in CLAUDE.md or .claude/rules/, recurring solutions become skills, and MEMORY.md stays auditable via /si:status and review passes.
- Promotion diff into CLAUDE.md or .claude/rules/
- Extracted SKILL.md package from a proven pattern
- /si:status report with line counts and consolidation recommendations
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
After competitor scraping sessions, you /si:remember findings then /si:promote stable sourcing rules into .claude/rules/.
A recurring ORM migration fix in MEMORY.md gets /si:extract into a skill the agent invokes on future schema changes.
Post code review you promote lint and test conventions from memory into CLAUDE.md so the next PR pass is consistent.
After an outage retrospective you consolidate duplicate incident notes and extract a runbook skill.
Spike code taught API quirks—you status-check memory before archiving the prototype branch.
How it compares
Meta curation layer for Claude’s memory stack—not a code reviewer, test runner, or generic note-taking skill.
Common Questions / FAQ
Who is self-improving-agent for?
Indie developers and small teams shipping with Claude Code who treat the agent as a long-term collaborator and need MEMORY.md promoted into durable project policy.
When should I use self-improving-agent?
In Idea when research patterns should persist; in Build after debugging wins; in Ship when review findings should become rules; in Operate when incident playbooks should extract to skills; anytime /si:status shows bloated or stale memory topics.
Is self-improving-agent safe to install?
It guides edits to memory and rule files in your repo—review the Security Audits panel on this page and inspect diffs before promoting entries that touch secrets, shell, or deployment commands.
Workflow Chain
Then invoke: skill creator
SKILL.md
READMESKILL.md - Self Improving Agent
# Self-Improving Agent > Auto-memory captures. This plugin curates. Claude Code's auto-memory (v2.1.32+) automatically records project patterns, debugging insights, and your preferences in `MEMORY.md`. This plugin adds the intelligence layer: it analyzes what Claude has learned, promotes proven patterns into project rules, and extracts recurring solutions into reusable skills. ## Quick Reference | Command | What it does | |---------|-------------| | `/si:review` | Analyze MEMORY.md — find promotion candidates, stale entries, consolidation opportunities | | `/si:promote` | Graduate a pattern from MEMORY.md → CLAUDE.md or `.claude/rules/` | | `/si:extract` | Turn a proven pattern into a standalone skill | | `/si:status` | Memory health dashboard — line counts, topic files, recommendations | | `/si:remember` | Explicitly save important knowledge to auto-memory | ## How It Fits Together ``` ┌─────────────────────────────────────────────────────────┐ │ Claude Code Memory Stack │ ├─────────────┬──────────────────┬────────────────────────┤ │ CLAUDE.md │ Auto Memory │ Session Memory │ │ (you write)│ (Claude writes)│ (Claude writes) │ │ Rules & │ MEMORY.md │ Conversation logs │ │ standards │ + topic files │ + continuity │ │ Full load │ First 200 lines│ Contextual load │ ├─────────────┴──────────────────┴────────────────────────┤ │ ↑ /si:promote ↑ /si:review │ │ Self-Improving Agent (this plugin) │ │ ↓ /si:extract ↓ /si:remember │ ├─────────────────────────────────────────────────────────┤ │ .claude/rules/ │ New Skills │ Error Logs │ │ (scoped rules) │ (extracted) │ (auto-captured)│ └─────────────────────────────────────────────────────────┘ ``` ## Installation ### Claude Code (Plugin) ``` /plugin marketplace add alirezarezvani/claude-skills /plugin install self-improving-agent@claude-code-skills ``` ### OpenClaw ```bash clawhub install self-improving-agent ``` ### Codex CLI ```bash ./scripts/codex-install.sh --skill self-improving-agent ``` ## Memory Architecture ### Where things live | File | Who writes | Scope | Loaded | |------|-----------|-------|--------| | `./CLAUDE.md` | You (+ `/si:promote`) | Project rules | Full file, every session | | `~/.claude/CLAUDE.md` | You | Global preferences | Full file, every session | | `~/.claude/projects/<path>/memory/MEMORY.md` | Claude (auto) | Project learnings | First 200 lines | | `~/.claude/projects/<path>/memory/*.md` | Claude (overflow) | Topic-specific notes | On demand | | `.claude/rules/*.md` | You (+ `/si:promote`) | Scoped rules | When matching files open | ### The promotion lifecycle ``` 1. Claude discovers pattern → auto-memory (MEMORY.md) 2. Pattern recurs 2-3x → /si:review flags it as promotion candidate 3. You approve → /si:promote graduates it to CLAUDE.md or rules/ 4. Pattern becomes an enforced rule, not just a note 5. MEMORY.md entry removed → frees space for new learnings ``` ## Core Concepts ### Auto-memory is capture, not curation Auto-memory is excellent at recording what Claude learns. But it has no judgment about: - Which learnings are temporary vs. permanent - Which patterns should become enforced rules - When the 200-line limit is wasting space on stale entries - Which solutions are good enough to become reusable skills That's what this plugin does. ### Promotion = graduation When you p