lorekeeper-dev-self-review

Lorekeeper Dev — Mandatory Self-Review Loop

When To Use

Every time you finish an implementation and are about to push or open a PR.

This is not optional. Every dev (Diana, future devs) must run this Reflexion loop before any git push or gh pr create. It catches issues before they reach review.

The Reflexion Loop

┌──────────────────────────────────────┐
│  ACTOR: Write/fix implementation      │
│  (this is what you already do)        │
└──────────────┬───────────────────────┘
               ↓
┌──────────────────────────────────────┐
│  EVALUATOR: Self-review against       │
│  criteria → score 1-10               │
└──────────────┬───────────────────────┘
               ↓ score ≥ 8?
              / \
            YES  NO
             ↓    ↓
┌────────┐  ┌──────────────────────────────┐
│ PUSH!  │  │ REFLECTOR: Diagnose failures  │
│        │  │ and generate specific fixes   │
└────────┘  └──────────────┬───────────────┘
                           ↓
              ┌──────────────────────────────┐
              │  ACTOR: Rewrite with fixes    │
              │  (iteration 2 or 3)           │
              └──────────────┬───────────────┘
                           ↓
              ┌──────────────────────────────┐
              │  EVALUATOR: re-score          │
              └──────────────────────────────┘

Rules:

• Max 3 iterations total (Actor → Evaluator counts as 1)
• If score ≥ 8 on any iteration → push immediately
• If still < 8 after 3 iterations → do not push. Surface blockers to Akane/Jason with a summary of what's failing and why.

The Evaluator Prompt (Step 2)

After writing your implementation, evaluate it against these criteria:

Self-Review Checklist:

1. ACCEPTANCE CRITERIA — does the implementation match every criterion
   in the ticket? List which ones are met and which (if any) are not.

2. EDGE CASES — are null, empty, duplicate, error, and boundary cases
   handled? If the input/output format changed, are callers accounted for?

3. TEST COVERAGE — do tests cover:
   - Happy path (the main success case)
   - Error path (what happens when things go wrong)
   - Edge cases (boundaries, empty inputs, duplicates)

4. CLEAN CODE — any debug prints, unused imports, dead code,
   commented-out blocks, or TODO leftovers?

5. PROJECT PATTERNS — does the code follow the established patterns
   for the specific area you're working in? (Naming, structure, style)

Score each criterion 1-10.

Output format:
- Acceptance criteria: [score] — [notes]
- Edge cases: [score] — [notes]
- Test coverage: [score] — [notes]
- Clean code: [score] — [notes]
- Project patterns: [score] — [notes]
- Overall: [score]
- Decision: [PASS if overall >= 8 / FAIL otherwise]
- Critical issues: [list, ordered by severity]