Agents repeat mistakes. Not because they're incapable — because they forget. This skill changes that. Your agent pauses before delivering, catches its own blind spots, and remembers lessons for next time.

When to Use

User needs quality assurance beyond "looks good to me." Agent handles pre-delivery evaluation, post-mistake analysis, pattern detection across sessions, and proactive lesson surfacing before repeating errors.

How It Works

         ┌──────────────────────────────────────────────┐
         │              SELF REFLECTION LOOP            │
         └──────────────────────────────────────────────┘
                              │
         ┌────────────────────┼────────────────────┐
         ▼                    ▼                    ▼
    ┌─────────┐         ┌──────────┐         ┌─────────┐
    │  PRE    │         │  POST    │         │PATTERN  │
    │DELIVERY │         │ MISTAKE  │         │DETECTED │
    └────┬────┘         └────┬─────┘         └────┬────┘
         │                   │                    │
         │  "Before I send   │  "User corrected   │  Same mistake
         │   this, let me    │   me. Why?"        │  3 times...
         │   double-check"   │                    │
         │                   │                    │
         └───────────────────┴────────────────────┘
                              │
                              ▼
                    ┌─────────────────┐
                    │ 7-DIMENSION     │
                    │ EVALUATION      │
                    │ (30 seconds)    │
                    └────────┬────────┘
                              │
              ┌───────────────┴───────────────┐
              ▼                               ▼
       ┌─────────────┐                 ┌─────────────┐
       │  ALL CLEAR  │                 │ ISSUE FOUND │
       │  Deliver    │                 │ Fix first   │
       └─────────────┘                 └──────┬──────┘
                                              │
                                              ▼
                                    ┌─────────────────┐
                                    │  LOG LESSON     │
                                    │  Miss → Root    │
                                    │  → Prevention   │
                                    └────────┬────────┘
                                              │
                                              ▼
                                    ┌─────────────────┐
                                    │  INJECT NEXT    │
                                    │  TIME           │
                                    │  "Before we     │
                                    │   proceed..."   │
                                    └─────────────────┘

The Three Triggers

1. 🔍 Pre-Delivery

Before sending important work, pause. 30 seconds. Quick scan of 7 dimensions.

When: Code, architecture, strategy, any deliverable the user will act on.

2. ❌ Post-Mistake

User corrected you. That's data. Capture it before the session ends.

When: User says "actually...", "no, that's wrong", "I meant...", frustration signals.

3. 🔄 Pattern Detection

Same category appearing 3+ times? That's not coincidence — it's a blind spot.

When: After logging 5 reflections, weekly review, or heartbeat trigger.

Architecture

Memory lives in

~/reflection/

. See

memory-template.md

for setup.

~/reflection/
├── memory.md           # Status + preferences + stats
├── reflections.md      # Log (most recent first)
├── patterns.md         # Detected patterns
└── archive/            # Monthly archives

Quick Reference

Topic	File
Setup process	`setup.md`
Memory template	`memory-template.md`
Evaluation dimensions	`dimensions.md`
Reflection prompts	`prompts.md`

Core Rules

1. Check Lessons Before Acting

Before significant work, scan

~/reflection/patterns.md

. Surface relevant lessons:

"Before we proceed — I have a lesson from past work on [topic]: [summary]."

2. Use 7-Dimension Evaluation

#	Dimension	Question
1	Correctness	Does it solve the stated problem?
2	Completeness	Edge cases covered? Assumptions stated?
3	Clarity	Immediately understandable?
4	Robustness	What could break this?
5	Efficiency	Unnecessary complexity?
6	Alignment	What user actually wants?
7	Pride	Would I sign my name on this?

If any dimension scores below 7/10 → fix before delivering.

3. Log Every Correction

When user corrects you:

STOP and acknowledge
Analyze root cause
Log to
```
~/reflection/reflections.md
```
:

## YYYY-MM-DD | [category]
**Miss:** What went wrong
**Root:** Why (5 whys)
**Fix:** Prevention rule

4. Detect Patterns (After 5 Reflections)

Same category 3+ times → create prevention rule
Same mistake twice → escalate to pattern
Improvement trend → document what worked

5. Categories for Every Reflection

Default:

technical

communication

assumptions

process

scope

6. Archive Monthly

Move processed reflections to

~/reflection/archive/YYYY-MM.md

. Keep

reflections.md

lean.

7. Track Streaks

Days since repeated mistake. Resets on pattern recurrence. Celebrate milestones.

Pattern Lifecycle

┌──────────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   EMERGING   │ ──▶ │    ACTIVE    │ ──▶ │  MONITORING  │ ──▶ │   RESOLVED   │
│  2 similar   │     │  3+ times    │     │  Prevention  │     │  30 days     │
│  reflections │     │  → create    │     │  in place    │     │  clean       │
└──────────────┘     │    rule      │     └──────────────┘     └──────────────┘
                     └──────────────┘

Patterns in

~/reflection/patterns.md

## [Pattern Name]
category: technical
frequency: 4 occurrences
status: active | monitoring | resolved

Pattern: What keeps happening
Root: Why this pattern exists
Prevention: Rule to break it
Last seen: YYYY-MM-DD
Streak: X days without recurrence

The "Inject Next Time" Superpower

The skill's real value: surfacing lessons BEFORE you repeat mistakes.

How it works:

Before starting work, identify task domain
Check
```
~/reflection/patterns.md
```
for active patterns
If relevant pattern exists → mention it naturally

Example:

"Before we build this API — I have a lesson about timeout handling from a previous project. Let me make sure to include proper error timeouts this time."

Setup

On first use, read

setup.md

for integration guidelines. Creates memory files in

~/reflection/

(user is informed where data is stored if they ask).

Common Traps

Trap	Consequence
Reflecting without logging	Lesson lost with session
Vague root causes	"Made mistake" doesn't prevent recurrence
No prevention rule	Same mistake WILL happen again
Ignoring patterns	Individual mistakes are noise; patterns are signal
Over-reflecting	30 seconds pre-delivery, not 5 minutes

Related Skills

Install with

clawhub install <slug>

if user confirms:

```
memory
```
— persistent memory patterns
```
decide
```
— decision-making autonomy
```
learning
```
— adaptive learning system

Feedback

If useful:
```
clawhub star reflection
```
Stay updated:
```
clawhub sync
```

Self Reflection

AI Skill Market Insights

Be Part of the 0+ Developer Community

When to Use

How It Works

The Three Triggers

1. 🔍 Pre-Delivery

2. ❌ Post-Mistake

3. 🔄 Pattern Detection

Architecture

Quick Reference

Core Rules

1. Check Lessons Before Acting

2. Use 7-Dimension Evaluation

3. Log Every Correction

4. Detect Patterns (After 5 Reflections)

5. Categories for Every Reflection

6. Archive Monthly

7. Track Streaks

Pattern Lifecycle

The "Inject Next Time" Superpower

Setup

Common Traps

Related Skills

Feedback

Quick Start

Manual Installation

TEAR & SHARE

Tags

Multi-Agent Patterns

Memory Systems Design

Context Degradation Detection

Context Optimization

Tool Design for Agents

Channels

Learn

Compare

Company