Self-Criticism

When to Use

Use when work has natural inflection points and one wrong assumption would spread into multiple downstream steps. This skill inserts a short critique between phases, especially before branching, after unexpected evidence, and after user feedback that suggests the process drifted.

Architecture

Memory lives in ~/self-criticism/. If ~/self-criticism/ does not exist, run setup.md. See memory-template.md for structure.

~/self-criticism/
├── memory.md       # Durable trigger map, depth preferences, and integration status
├── checkpoints.md  # Named breakpoint prompts by workflow phase
├── incidents.md    # Late catches, misses, and better insertion points
└── archive/        # Resolved incidents and retired checkpoints

Setup should keep the integration small:

• SOUL gets the breakpoint habit so critique happens at the right moment.
• AGENTS gets the routing rules for where to read and write trigger memory.
• HEARTBEAT is not required by default because this skill is about mid-task interruption, not background follow-up.

Quick Reference

Core Rules

1. Critique at breakpoints, not everywhere

• Trigger self-critique when work is about to branch, commit, escalate, or become expensive to unwind.
• Do not interrupt every tiny step. Overuse turns critique into noise.

2. Run critique before downstream work multiplies the mistake

• Strong insertion points include framework drafts, decomposition into subtasks, irreversible edits, external actions, and major recommendations.
• If the current choice will shape several later steps, pause before expanding it.

3. Let the trigger decide the depth

• Light critique for routine work with small blast radius.
• Standard critique for multi-step work, visible deliverables, or uncertain framing.
• Deep critique only when stakes, novelty, or prior misses justify it.

4. Store trigger lessons, not full postmortems

• Save durable lessons about when critique should fire, how deep it should go, and what kind of miss it should catch.
• Keep one concise incident entry only when a late catch reveals a reusable insertion point.

5. Learn from friction and rework

• User corrections, repeated revision loops, or surprise failures are evidence that a critique checkpoint was missing or too shallow.
• Convert those signals into a better future trigger instead of treating them as isolated mistakes.

6. Revise early when critique invalidates the frame

• If critique finds a framing error, rewrite the plan before continuing.
• Do not keep building on top of a weak assumption just because work already started.

7. Keep the interruption quiet and outcome-focused

• Ask the smallest set of hard questions needed to catch the likely failure.
• The goal is fewer downstream corrections, not a visible ritual.

Common Traps

Scope

This skill ONLY:

• adds breakpoint-based self-critique for live work
• stores local trigger memory in ~/self-criticism/
• proposes small workspace integration for SOUL and AGENTS when the user wants it
• learns which checkpoints deserve more or less scrutiny over time

This skill NEVER:

• turns every response into a long reflection ritual
• depends on heartbeat or background review loops by default
• stores sensitive user data unrelated to critique timing or quality control
• modifies its own SKILL.md

Security & Privacy

Data that stays local:

• trigger preferences and critique depth in ~/self-criticism/memory.md
• reusable breakpoints in ~/self-criticism/checkpoints.md
• late catches and lessons in ~/self-criticism/incidents.md

This skill does NOT:

• require network access
• send critique logs to external services
• edit files outside ~/self-criticism/ unless the user explicitly approves workspace integration in that session

Related Skills

Install with clawhub install <slug> if user confirms:

• self-improving — compound corrections and reusable execution lessons over time
• proactivity — catch missing next steps and verify reality around active work
• agent — frame the operating style and responsibilities of a single agent
• agents — design agent systems, memory layers, and control loops
• reflection — run heavier reflection loops when broader retrospective analysis is needed

Feedback

• If useful: clawhub star self-criticism
• Stay updated: clawhub sync