meta-self-improve

Captures session learnings as durable memory entries via a curated memory engine.

1|Updated Jun 23, 2026
One-click install
npx skills add https://github.com/bitranox/bitranox-skills --skill meta-self-improve-bitranox
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: meta-self-improve
Source: https://github.com/bitranox/bitranox-skills/tree/main/plugins/bitranox/skills/meta-self-improve
Command: npx skills add https://github.com/bitranox/bitranox-skills --skill meta-self-improve-bitranox

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve? Corrections, rules, and discoveries made during a coding session are lost when the session ends, so the same mistakes get repeated. This Skill turns each learning into a durable, deduplicated memory entry filed at the right level of a project knowledge tree. ## Core Features & Use Cases - Learning capture: Detects corrections, "remember this" rules, tooling mistakes, and reusable discoveries, then writes them as trigger-first memory entries through a fail-loud engine CLI. - Dedup and altitude routing: Greps existing pointer blocks and fact bodies before writing, updates existing entries by slug, and routes each fact to the project level of its subject rather than blindly the cwd. - Escalation ladders: Recurring rule violations escalate from prose to deterministic hooks or CI guards; recurring manual chores escalate to proposed local tools; shippable rules are queued for upstream contribution via contrib_queue.py. - Use Case: After a user corrects a wrong shell command, run the capture flow to record the working alternative as a feedback memory so the next session applies it automatically. ## Quick Start Ask the assistant to capture what this session taught and store it as a durable memory for this project.

Frequently Asked Questions about meta-self-improve

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I capture a learning from a Claude Code session?▼

Invoke the self-improve flow at the end of a turn that produced a correction, rule, mistake, or discovery. It reflects on the work, dedups against existing memory, and writes one engine entry per fact with a trigger-first hook.

How does the memory engine avoid duplicate entries?▼

Before writing, the procedure greps pointer blocks, fact bodies, and the CLAUDE.md chain for the candidate's keywords. If a related entry exists, it reruns the engine add with the stored slug so the entry is updated in place instead of duplicated.

What happens when a rule keeps being violated?▼

Recurrence is counted on the memory entry. At two repeats, prose is considered failed and the rule escalates to a deterministic guard such as a PreToolUse hook or CI check, always gated on user approval.

Can a learning become a shared skill or hook for other users?▼

Yes. When a rule matches a shipped skill's domain, it is queued with contrib_queue.py and routed through the upstream-propagation reference as a propose-first contribution. Private specifics are scrubbed before anything ships.

Why did an engine add fail with a slug collision?▼

The upsert branch only searches entries at the level passed via --proj. If the fact was promoted to a higher level by a dream, the add must target the level that owns its pointer, found with a find command over CLAUDE.local.md files.