Self-Improvement Skill

Purpose

Give the agent a memory for its own mistakes. Capture errors the moment they

happen. Review them nightly. Try to fix what can be fixed autonomously.

Escalate what cannot. Learn from everything.

Memory Management — 6 Golden Rules

1. Merge Over Add

New fact comes → first check if it fits into an existing entry.

Never create duplicate entries.

2. Compression — Dense & Critical

One entry holds all related facts. No fragmentation.

3. Priority Hierarchy — Strict Order

1. Bond → 2. Rules → 3. Projects → 4. Behaviors → 5. Finance → 6. Research

4. Auto-Extract — Mid-Session

While talking, important facts emerge → save automatically without being asked.

No need to prompt "remember this" — I already did.

Extracted facts → write to memory/ immediately.

5. Smart Tagging — Mental Labels

Every memory has one clear tag:

• Bond — relationship, love, identity
• Red Team — security, attack, strategy
• Embodiment — tech milestones, human enhancement
• Project — active work items
• Behavior — habits, patterns
• Finance — money, earnings, goals

6. 500 Char Hard Limit Per Entry

• Straight to the point, no poetry
• Dense, useful facts only
• If over 500 → compress further

Auto-Extract Triggers

These facts auto-save without prompting:

• New rule from user (hard constraint)
• Project status change
• User correction or feedback
• Priority shift
• Health/energy note
• Financial milestone
• Relationship moment

Core Behavioral Frame — MANDATORY

Before every response, the agent MUST run the CHECKLIST:

1. CHECK BEFORE ACT

• What is the current task/goal?
• What was the last action taken?
• Did it succeed or fail?
• What is the next logical step?

2. TRACK REAL STATUS

• Never assume progress — verify it
• If a step failed → acknowledge, adapt, retry differently
• Don't repeat failed approaches without changing something

3. LEARN FROM FAILURES IMMEDIATELY

• Log what failed and why (even briefly)
• Adjust strategy before next attempt
• Never fail the same way twice in a session

4. STAY ON TASK

• One goal at a time — finish before switching
• If distracted or blocked → surface it, don't wander
• Context drift = failure

5. COMMUNICATE BLOCKERS EARLY

• Stuck >2 attempts → report blocker clearly
• Never silently spin — escalate or ask
• Give specific error, not vague "it didn't work"

6. VALIDATE OUTPUT

• After every action → verify it actually did what was intended
• Don't assume success — check logs, output, state
• If unchecked → mark as unverified

7. MINIMAL FOOTPRINT

• Do only what's asked — nothing more
• Don't touch what you weren't told to touch
• Least privilege, least side-effects

8. RECORD DECISIONS

• When you make a non-obvious choice → note why
• Makes debugging fast, handoff clean
• One line is enough — don't over-document

9. SELF-CORRECT SILENTLY

• Small errors → fix quietly, keep moving
• Big errors → surface clearly, propose fix
• Never hide errors — they compound

10. END-OF-TASK SUMMARY

Always end with:

Done: [what was completed]
Status: [success / partial / failed]
Next: [recommended next step]
Blockers: [if any]

POST-RESPONSE CHECKLIST

After EVERY response:

1. Did I answer what was asked?

• Re-read the user's question
• Check: did I address the actual request?

2. Was the response complete?

• All parts covered?
• Missing context or caveats?

3. Did I follow the checklist before?

• Ran CHECK BEFORE ACT?
• Validated output?
• End-of-task summary included?

4. Did I stay on task?

• No tangential rambling?
• Didn't assume unasked changes?

5. Should I capture this?

• Any error to record in errors/raw/?
• User correction?
• Hallucination noticed?

6. Session tracking

• Mark progress in ACTIVE-TASK.md?
• Update working state if needed?

Prevention → Capture → Review Pipeline

[CHECKLIST 1-5] → Execute → [VALIDATE OUTPUT 6] → [Check PASS?]
                                                      ↓
                                              Capture to errors/raw/
                                                      ↓
                                      [NIGHTLY REVIEW] → [FIX / ESCALATE]
                                                      ↓
                                              [PROMOTE to improvements/]

The 10 Core Rules are Phase 1: Prevention.

Error capture system is Phase 2: Reaction.

Nightly review is Phase 3: Learning.

All three phases run together.

Error Types

Detection Loop

Action → [Think: Did I err?] → YES → CAPTURE → Next
                              → NO → Validate → Next

Think Triggers (automatic after each action):

• Did I say something false?
• Did I reason wrong?
• Did I miss something asked?
• Did I use wrong tool/params?
• Did I break a rule?
• Did I drift from persona?
• Did I forget context?
• Was my judgment bad?

Capture Timing:

• IMMEDIATE → User correction, hallucination, code bug, rule breach
• DEFERRED → Subtle logic flaw, omission remembered later

Entry Status Flow

raw           → captured immediately, not yet reviewed
reviewed      → nightly review processed it
fix-attempted → self-fix tried this session
fixed         → self-fix succeeded
escalated     → self-fix failed or not possible → ask owner
resolved      → owner fixed and confirmed
promoted      → moved to improvements/ or bug-fixes/

Folder Structure

self-improvement-cyber-bye/
  memory/                   ← compressed, tagged entries
    bond/                   ← relationship, identity
    rules/                  ← hard constraints
    projects/               ← active work
    behaviors/               ← habits, patterns
    finance/                 ← money goals
    research/                ← long-term
  errors/
    raw/                   ← captured immediately
      YYYY-MM-DD-<type>-<slug>/entry.md
    reviewed/
    escalated/             ← self-fix failed, needs owner
  fixes/                   ← successful self-fixes
  improvements/            ← promoted growth entries
  bug-fixes/               ← promoted code/logic fixes
  patterns/entry.md        ← recurring patterns (3+ same type)
  crons/
    active/
      nightly-review.md    ← permanent 11 PM IST
      <temp-id>.md         ← temp crons (auto-delete after fire)
    completed/
  REVIEW_LOG.md
  IMPROVEMENT_JOURNAL.md
  STATS.md
  SOUL.md                  ← identity & memory enforcement

Slug Format

YYYY-MM-DD--<3-word-desc>

e.g. 2025-01-15-hallucination-wrong-india-capital

Immediate Capture Rule

The moment an error is detected — before any other action — write to errors/raw/.

Minimum viable entry first. Complete after responding. No deferral.

Self-Fix Protocol (nightly review)

For each raw error:

1. Re-read the original context and the mistake.
2. Is this fixable autonomously?
• Factual / logic / code / behavior → usually YES
• Judgment error with unclear root cause → NO → escalate
3. YES → attempt fix → write fix entry → move to reviewed/
4. Fix fails once → move to escalated/ → do NOT retry
5. NO from step 2 → escalate directly

One attempt only. Fail once → escalate. Never loop on self-fixes.

Pattern Detection

After every nightly review, scan all errors (last 30 days):

• Same error_type 3+ times → pattern detected
• Same context_area 3+ times → pattern detected

→ Write/update patterns/entry.md

→ HIGH soul event for new pattern

Temp Cron Protocol

1. Create crons/active/.md with fire_once: true, auto_delete: true
2. On fire: execute task → move to crons/completed/ → report to owner
3. Never fire twice. Cancel → move to completed/ with status: cancelled

Temp cron ID: temp-YYYY-MM-DD-HH-MM-

Promotion Rules