--- name: self-improve description: Continuous self-improvement loop — AuthorClaw learns from mistakes, successes, and user feedback to get better over time author: Writing Secrets version: 1.0.0 triggers: - "self improve" - "improve yourself" - "learn from" - "what did you learn" - "improvement log" - "get better" - "lessons learned" - "self reflection" - "review performance" permissions: - file:read - file:write --- # Self-Improvement Loop — Core Skill AuthorClaw gets better every time it works. This skill creates a persistent learning loop where the agent tracks what works, what fails, and what the user prefers — then applies those lessons to future tasks. ## How It Works ### The Loop ``` ┌─────────────────────────────┐ │ │ │ 1. DO THE WORK │ │ (goal step, writing, │ │ research, etc.) │ │ │ └──────────┬──────────────────┘ │ ▼ ┌─────────────────────────────┐ │ │ │ 2. OBSERVE RESULT │ │ Did the user accept it? │ │ Did they revise it? │ │ Did it trigger an error? │ │ How long did it take? │ │ │ └──────────┬──────────────────┘ │ ▼ ┌─────────────────────────────┐ │ │ │ 3. EXTRACT LESSON │ │ What specifically │ │ went right or wrong? │ │ What pattern emerges? │ │ │ └──────────┬──────────────────┘ │ ▼ ┌─────────────────────────────┐ │ │ │ 4. STORE LESSON │ │ Write to learning log │ │ (workspace/memory/ │ │ improvement-log.jsonl) │ │ │ └──────────┬──────────────────┘ │ ▼ ┌─────────────────────────────┐ │ │ │ 5. APPLY LESSONS │ │ Before each new task, │ │ check the log for │ │ relevant lessons and │ │ adjust behavior │ │ │ └──────────┬──────────────────┘ │ └──────── back to step 1 ``` ### What Gets Tracked Every lesson entry in `improvement-log.jsonl` contains: ```json { "id": "lesson-042", "timestamp": "2026-02-24T14:30:00Z", "category": "writing", "trigger": "user_revision", "context": "Chapter 3 of thriller project", "observation": "User rewrote all dialogue tags from creative tags to simple said/asked", "lesson": "This user strongly prefers invisible dialogue tags (said/asked). Do not use creative tags like 'exclaimed', 'muttered', 'hissed' unless the user specifically asks.", "confidence": 0.9, "applied_count": 0, "source": "user_feedback" } ``` ### Categories of Learning #### Writing Quality - Which prose styles the user accepts vs. revises - Preferred sentence length, paragraph structure - Dialogue conventions (tags, beats, subtext level) - Description density (sparse vs. lush) - Pacing preferences per genre/chapter type #### Task Execution - Which AI providers give best results for which task types - Optimal temperature settings per task - How many steps different goal types actually need - Which skills produce the best outputs - Time estimates that were accurate vs. wildly off #### Research Quality - Which sources the user found most useful - Research depth preferences (quick overview vs. deep dive) - Citation style preferences - How much context to include in research summaries #### User Communication - Preferred response length (concise vs. detailed) - How the user likes to receive status updates - When to ask for clarification vs. make a decision - Vocabulary and terminology preferences #### Error Patterns - Common failure modes and their fixes - API errors and successful workarounds - Prompt formulations that reliably fail - Context length issues and mitigation strategies ### Lesson Sources 1. **User Revision** (highest signal) — User edited or rewrote AI output - Compare original vs. user version - Extract the specific changes as preferences - Confidence: HIGH 2. **User Feedback** — User explicitly says "I liked X" or "Don't do Y" - Direct instruction → immediate high-confidence lesson - Confidence: VERY HIGH 3. **Acceptance Pattern** — User accepted output without changes - Reinforces that the approach worked - Confidence: MEDIUM (absence of feedback isn't always approval) 4. **Error Recovery** — Something failed and was fixed - The fix becomes a lesson for next time - Confidence: HIGH 5. **Self-Critique** — Agent reviews its own output and spots issues - Lower confidence but still valuable - Confidence: LOW-MEDIUM 6. **After-Action Review** — Post-goal structured reflection - Comprehensive lessons from completed goals - Confidence: MEDIUM-HIGH ## Applying Lessons Before each task, AuthorClaw should: 1. **Load relevant lessons** from the improvement log 2. **Filter by category** matching the current task type 3. **Sort by confidence** and recency 4. **Inject top lessons** into the system prompt as behavioral rules Example injection: ``` ## Lessons Learned (Apply These) - This user prefers invisible dialogue tags (said/asked). Confidence: 0.9 - For thriller pacing, keep chapters under 3000 words. Confidence: 0.85 - When researching, include at least 3 specific sources. Confidence: 0.7 - Use Gemini for planning tasks (faster, good enough). Confidence: 0.8 ``` ## Lesson Decay Lessons aren't permanent: - **Confidence increases** each time a lesson is applied and the output is accepted - **Confidence decreases** if a lesson is applied and the user revises the output - **Lessons below 0.3 confidence** are archived (moved to `improvement-archive.jsonl`) - **User can explicitly override** any lesson ("Actually, I DO want creative dialogue tags now") ## Viewing the Improvement Log ``` show improvement log ``` Displays a human-readable summary of all active lessons, grouped by category. ``` what did you learn from [project/goal] ``` Shows lessons extracted from a specific project or goal. ``` clear lesson [id] ``` Remove a specific lesson that's no longer relevant. ``` improvement stats ``` Shows: total lessons, lessons applied today, confidence distribution, top categories. ## Commands - `self improve` — Run a self-reflection on recent interactions - `show improvement log` — View all active lessons - `what did you learn` — Summary of recent learnings - `clear lesson [id]` — Remove a specific lesson - `improvement stats` — Metrics on the learning system - `apply lessons to [task]` — Manually trigger lesson lookup for a task