diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4b2c9c0..797b1b3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,72 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [3.20.0] - 2026-01-30
+
+### Added
+
+- **Code Review Automation: Multi-Agent PR Review** — Production-grade review patterns from Pat Cullen & Méthode Aristote
+  - **Resource evaluation**: `docs/resource-evaluations/017-pat-cullen-final-review.md`
+    - Score: 5/5 (Critical - Must integrate immediately)
+    - Source: [Pat Cullen's Final Review Gist](https://gist.github.com/patyearone/c9a091b97e756f5ed361f7514d88ef0b) (Jan 28, 2026)
+    - Multi-agent workflow with 3 specialized agents: Consistency Auditor, SOLID Analyst, Defensive Code Auditor
+    - Anti-hallucination safeguards: pre-flight check (git log Co-Authored-By detection), verification protocol, occurrence rule
+    - Production patterns: reconciliation step, severity classification (🔴🟡🟢), auto-fix convergence loop
+    - Fact-checked: All claims verified, workflow production-ready (used regularly by author)
+  - **Enhanced `/review-pr` command**: `examples/commands/review-pr.md` (+150 lines: 80 → 230)
+    - Simple template PRESERVED (lines 1-80) for beginners
+    - NEW "Advanced: Multi-Agent Review" section (line 81+)
+    - Pre-flight check: `git log --oneline -10 | grep "Co-Authored-By: Claude"` to avoid repeating suggestions
+    - Multi-agent specialization: 3 parallel agents (Consistency, SOLID, Defensive)
+    - Anti-hallucination rules: verify patterns with Grep/Glob before recommending (occurrence rule: >10 = established)
+    - Reconciliation: prioritize existing project patterns, skip with documented reasoning
+    - Severity classification: 🔴 Must Fix (blockers) / 🟡 Should Fix / 🟢 Can Skip
+    - Auto-fix loop: review → fix → re-review → converge (max 3 iterations)
+    - Conditional context loading: stack-agnostic table (DB queries → check indexes, API routes → check auth, etc.)
+  - **Enhanced `code-reviewer` agent**: `examples/agents/code-reviewer.md` (+219 lines: 72 → 291)
+    - NEW "Anti-Hallucination Rules" section (line 75)
+      - Verification protocol: Use Grep/Glob before claiming patterns exist
+      - Occurrence rule: >10 occurrences = established, 3-10 = emerging, <3 = not established
+      - Read full file context (not just diff lines)
+      - Uncertainty markers: ❓ To verify / 💡 Consider / 🔴 Must fix
+    - NEW "Conditional Context Loading" section
+      - Detailed table: if diff contains X → load context Y → use tools Z
+      - Stack-agnostic patterns (imports → check package.json, DB queries → check schema, etc.)
+    - NEW "Defensive Code Audit" section
+      - Silent catches detection: empty catch blocks, console-only catches
+      - Hidden fallbacks detection: chained fallbacks (a || b || c), optional chaining with fallback
+      - Unchecked nulls detection: property access without validation
+      - Ignored promise rejections: async calls without .catch()
+    - NEW "Severity Classification System" with justification requirements
+    - Enhanced output format with evidence-based findings
+    - Attribution: Méthode Aristote production code review patterns
+  - **Enhanced iterative refinement workflow**: `guide/workflows/iterative-refinement.md` (+133 lines: 389 → 522)
+    - NEW "Review Auto-Correction Loop" section (line 347)
+    - Pattern: review → fix → re-review → converge (with visual diagram)
+    - Safeguards: max iterations, quality gates (tsc/lint), protected files, change threshold, rollback capability
+    - Example session: 3 iterations with 🔴 Must Fix → 🟡 Should Fix → 🟢 Can Skip convergence
+    - Comparison: one-pass review vs convergence loop (when to use each)
+    - Integration with multi-agent review
+    - Convergence criteria: 5 conditions (no issues, max iterations, change threshold, quality gate failure, manual stop)
+    - Anti-patterns table: infinite loop, scope creep, breaking fixes, protected file changes, context loss
+  - **Enhanced ultimate guide**: `guide/ultimate-guide.md` (+28 lines, ~line 4623)
+    - NEW "Production Example: Multi-Agent Code Review" after existing Code Review Prompt
+    - 3 specialized agent roles: Consistency, SOLID, Defensive Code Auditor
+    - Key patterns beyond generic Split Role: pre-flight check, anti-hallucination (Grep/Glob verification), reconciliation, severity classification, convergence loop
+    - Production safeguards: full file context, conditional loading, protected files, quality gates
+    - Attribution: Pat Cullen's Final Review Gist + implementation references
+  - **Reference updates**: `machine-readable/reference.yaml` (+3 entries)
+    - `review_pr_advanced: "examples/commands/review-pr.md:81"`
+    - `review_anti_hallucination: "examples/agents/code-reviewer.md:75"`
+    - `review_auto_fix_loop: "guide/workflows/iterative-refinement.md:347"`
+  - **Impact**: Transforms basic `/review-pr` template into production-grade multi-agent system
+    - Beginner-friendly: simple template preserved (lines 1-80)
+    - Advanced users: comprehensive patterns for critical code review
+    - Anti-hallucination safeguards prevent false suggestions
+    - Defensive code audit catches silent failures (empty catches, hidden fallbacks, unchecked nulls)
+    - Convergence loop ensures quality through iterative refinement
+  - **Design principles**: Enrich existing files (no fragmentation), no breaking changes (review-pr.md not renamed), complete attribution (Pat Cullen + Méthode Aristote), audience-aware (simple → advanced progression)
+
 ## [3.19.0] - 2026-01-30
 
 ### Added
diff --git a/README.md b/README.md
index 0bbd809..24c44be 100644
--- a/README.md
+++ b/README.md
@@ -482,7 +482,7 @@ See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
 
 ---
 
-*Version 3.19.0 | January 2026 | Crafted with Claude*
+*Version 3.20.0 | January 2026 | Crafted with Claude*
 
 <!-- SEO Keywords -->
 <!-- claude code, claude code tutorial, anthropic cli, ai coding assistant, claude code mcp,
diff --git a/VERSION b/VERSION
index 419f300..eb9b76c 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-3.19.0
+3.20.0
diff --git a/docs/resource-evaluations/017-pat-cullen-final-review.md b/docs/resource-evaluations/017-pat-cullen-final-review.md
new file mode 100644
index 0000000..585c2a6
--- /dev/null
+++ b/docs/resource-evaluations/017-pat-cullen-final-review.md
@@ -0,0 +1,190 @@
+# Pat Cullen - Multi-Agent PR Review (Final Review)
+
+## Métadonnées
+
+| Champ | Valeur |
+|-------|--------|
+| **Auteur** | Pat Cullen |
+| **Source** | [LinkedIn Post](https://www.linkedin.com/posts/patrickyearconsulting_a-multi-agent-ai-workflow-for-production-activity-7289349732127461377-tWGb) + [Gist Public](https://gist.github.com/patyearone/c9a091b97e756f5ed361f7514d88ef0b) |
+| **Date** | 2026-01-28 |
+| **Type** | Code Review Automation |
+| **Langue** | Anglais |
+| **Format** | Workflow + Code (Claude Code slash command) |
+
+## Résumé
+
+Workflow multi-agent de code review production-ready développé par Pat Cullen. Système sophistiqué utilisant le Task tool de Claude Code pour coordonner 3 agents spécialisés :
+
+1. **Consistency Agent**: Détecte DRY violations, duplications, inconsistances de patterns
+2. **SOLID Principles Agent**: Analyse SRP violations, nested conditionals, cyclomatic complexity
+3. **Defensive Code Auditor**: Traque les silent catches, swallowed exceptions, fallbacks cachés (hidden rescues)
+
+**Innovation clé**: Pre-flight check via `git log` pour détecter les follow-up passes (Co-Authored-By: Claude) et éviter les répétitions de suggestions. Reconciliation step pour prioriser les patterns existants du projet.
+
+## Scoring
+
+### Score Initial: 5/5
+
+| Critère | Note | Justification |
+|---------|------|---------------|
+| **Nouveauté** | 5/5 | First production-ready multi-agent review workflow public |
+| **Applicabilité** | 5/5 | Ready-to-use slash command, adapté à tout codebase |
+| **Qualité** | 5/5 | Testé en production, anti-hallucination safeguards |
+| **Documentation** | 4/5 | Workflow complet mais mériterait exemples de output |
+| **Impact** | 5/5 | Transforme le `/review-pr` basique en système expert |
+
+**Score Final**: **5/5** — Critical, must integrate immediately
+
+## Comparatif avec l'existant
+
+| Aspect | Guide Actuel | Pat Cullen Final Review | Valeur Ajoutée |
+|--------|--------------|-------------------------|----------------|
+| **Structure** | Checklist simple, 1 agent | 3 agents spécialisés parallèles | Perspectives multiples, spécialisation |
+| **Anti-hallucination** | Aucun safeguard explicite | Pre-flight check + reconciliation | Évite suggestions répétées/non pertinentes |
+| **Defensive Code** | Non couvert | Agent dédié (silent catches) | Détecte masked bugs silencieux |
+| **Pattern Respect** | Mentionné | Priorisé via reconciliation | Cohérence avec codebase existante |
+| **Severity** | Format fixe (Critical/Suggestions) | 🔴 Must Fix / 🟡 Should Fix / 🟢 Can Skip | Meilleure priorisation pour devs |
+| **Follow-up Awareness** | Non | Détection via git history | Évite redondance sur PRs itérées |
+
+**Résultat**: Le workflow Cullen complète et améliore radicalement le template actuel sans le remplacer.
+
+## Recommandations d'Intégration
+
+### 1. Enrichir `/review-pr` (pas remplacer)
+
+**Fichier cible**: `examples/commands/review-pr.md`
+
+**Action**: Garder template simple actuel (80 lignes) ET ajouter section "Advanced: Multi-Agent Review"
+
+Ajouts:
+- Pre-flight check: `git log --oneline -10 | grep "Co-Authored-By: Claude"`
+- Multi-agent option avec référence Split Role Sub-Agents (guide:4575)
+- Reconciliation step: prioritize existing patterns, skip with reasoning
+- Severity levels: 🔴 Must Fix / 🟡 Should Fix / 🟢 Can Skip
+- Auto-fix option (`--auto`): review → fix → re-review loop (max 3 iterations)
+
+**Estimation**: +70-100 lignes (~150-180 total)
+
+### 2. Enrichir `code-reviewer.md` agent
+
+**Fichier cible**: `examples/agents/code-reviewer.md`
+
+Agent actuel = 72 lignes squelette. Enrichir avec patterns concrets:
+
+- Anti-hallucination rules: "Verify before asserting" (Grep/Glob first)
+- Occurrence rule: Pattern >10 occurrences = established (Suggestion, pas Bloquant)
+- Conditional context loading: table "if diff contains X → check Y"
+- Defensive code audit: silent catches, swallowed exceptions, hidden fallbacks
+- Marquer "❓ À vérifier" si incertain
+
+**Estimation**: +50-70 lignes (~120-140 total)
+
+### 3. Nouvelle section dans `iterative-refinement.md`
+
+**Fichier cible**: `guide/workflows/iterative-refinement.md`
+
+Sous-section "Review Auto-Correction Loop" (~30-40 lignes):
+- Pattern review → fix → re-review → convergence
+- Safeguards: max iterations, tsc/lint check, protected files
+- Comparaison one-pass (Cullen follow-up) vs convergence loop
+
+### 4. Enrichir Split Role section du guide
+
+**Fichier cible**: `guide/ultimate-guide.md` (~ligne 4612)
+
+Ajouter après "Code Review Prompt" existant (~10-15 lignes):
+
+```markdown
+**Production Example: Multi-Agent Code Review** (Pat Cullen, Jan 2026):
+
+Specialized agent roles:
+1. **Consistency Agent**: Duplicate logic, pattern violations
+2. **SOLID Agent**: SRP violations, nested conditionals, method bloat
+3. **Defensive Code Auditor**: Silent rescues, swallowed exceptions
+
+Key additions:
+- Pre-flight: Check git history for follow-up pass awareness
+- Reconciliation: Prioritize existing patterns, skip with reasoning
+- Convergence: Auto-fix loop until minimal changes
+
+Source: [Pat Cullen's Final Review](https://gist.github.com/patyearone/c9a091b97e756f5ed361f7514d88ef0b)
+```
+
+### 5. Update `reference.yaml` (3 entrées max)
+
+```yaml
+# Code Review Automation (Pat Cullen, Jan 2026)
+review_pr_advanced: "examples/commands/review-pr.md:85"
+review_anti_hallucination: "examples/agents/code-reviewer.md:75"
+review_auto_fix_loop: "guide/workflows/iterative-refinement.md:395"
+```
+
+## Challenge Critique (Technical Writer Agent)
+
+**Question**: Score 5/5 justifié ? Workflow testé ou théorique ?
+
+**Réponse**:
+- ✅ **Testé production**: Cullen affirme usage régulier ("I've been using this")
+- ✅ **Code complet**: Slash command fonctionnel dans le Gist
+- ✅ **Patterns vérifiables**: Defensive code audit = détection swallowed exceptions (pattern connu)
+- ⚠️ **Metrics absents**: Pas de "found 23 issues, 18 valid" ou taux de faux positifs
+
+**Conclusion**: Score 5/5 maintenu car workflow complet + production-ready + patterns innovants. Cependant, intégration doit marquer "inspired by production usage" sans sur-promettre les résultats.
+
+**Question**: Overlap avec SE-CoVe plugin (fact-checking) ?
+
+**Réponse**:
+- **SE-CoVe**: Fact-checking général, detect hallucinated claims
+- **Cullen**: Anti-hallucination spécifique code review (verify patterns before suggesting)
+- **Overlap**: ~30% (verification principle)
+- **Complémentaire**: SE-CoVe = détection post-génération, Cullen = prévention en amont
+
+Action: Mentionner SE-CoVe comme alternative dans section anti-hallucination.
+
+## Fact-Check
+
+| Claim | Vérification | Résultat |
+|-------|--------------|----------|
+| "Multi-agent workflow" | Gist contient 3 agents distincts | ✅ Vérifié |
+| "Production-ready" | Code complet, git log check, reconciliation | ✅ Vérifié |
+| "Defensive code auditor" | Agent traque silent catches, swallowed exceptions | ✅ Vérifié |
+| "Pre-flight check" | `git log` pour Co-Authored-By detection | ✅ Vérifié |
+| "Reduces repeated suggestions" | Reconciliation step explicitly states this | ✅ Vérifié |
+
+Aucun claim infondé détecté.
+
+## Risques d'Intégration
+
+| Risque | Mitigation |
+|--------|------------|
+| **Frankenstein risk** | Ne PAS fusionner Cullen + Aristote. Enrichir existant avec patterns séparés. |
+| **Breaking rename** | Garder `review-pr.md`, ne pas renommer → `final-review.md` |
+| **Over-complexity** | Section simple en premier, Advanced en fin (débutants OK) |
+| **Hallucination claim** | Marquer "inspired by production" sans garantir même résultats |
+| **Overlap SE-CoVe** | Clarifier complémentarité, pas duplication |
+
+## Décision Finale
+
+**Action**: ✅ Intégrer immédiatement (sous 24h)
+
+**Fichiers touchés**:
+1. ✅ Créer `docs/resource-evaluations/017-pat-cullen-final-review.md` (ce fichier)
+2. ✅ Enrichir `examples/commands/review-pr.md` (+70-100 lignes)
+3. ✅ Enrichir `examples/agents/code-reviewer.md` (+50-70 lignes)
+4. ✅ Enrichir `guide/workflows/iterative-refinement.md` (+30-40 lignes)
+5. ✅ Enrichir `guide/ultimate-guide.md` (~ligne 4612, +10-15 lignes)
+6. ✅ Update `machine-readable/reference.yaml` (+3 entrées)
+
+**Total**: 1 nouveau fichier (evaluation), 5 fichiers enrichis, 0 fichier renommé/supprimé.
+
+**Attribution**: Pat Cullen, lien Gist public dans tous les fichiers enrichis.
+
+## Timeline
+
+- **2026-01-28**: Publication LinkedIn + Gist
+- **2026-01-30**: Évaluation 5/5 + intégration guide (ce fichier)
+
+---
+
+**Évalué par**: Claude Code Ultimate Guide
+**Date d'évaluation**: 2026-01-30
diff --git a/docs/resource-evaluations/README.md b/docs/resource-evaluations/README.md
index 5574572..bad5e8a 100644
--- a/docs/resource-evaluations/README.md
+++ b/docs/resource-evaluations/README.md
@@ -54,7 +54,8 @@ Les documents de travail bruts (prompts Perplexity, audits clients) restent dans
 | **Peter Wooldridge** (Productivity Stack) | 2/5 | **3/5** | ✅ Practitioner Insights | [wooldridge-productivity-stack.md](./wooldridge-productivity-stack.md) |
 | **System Prompts** (Official vs Community) | 4/5 | **2/5** | ⚠️ Watch only (official sources exist) | [system-prompts-official-vs-community.md](./system-prompts-official-vs-community.md) |
 | **Worktrunk** | 4/5 | **4/5** | ✅ Intégré (workflow) | [worktrunk-evaluation.md](./worktrunk-evaluation.md) |
+| **Pat Cullen** (Multi-Agent PR Review) | 5/5 | **5/5** | ✅ Intégré (review-pr, code-reviewer, guide) | [017-pat-cullen-final-review.md](./017-pat-cullen-final-review.md) |
 
 ---
 
-**Dernier update**: 2026-01-30 (16 évaluations)
+**Dernier update**: 2026-01-30 (17 évaluations)
diff --git a/examples/agents/code-reviewer.md b/examples/agents/code-reviewer.md
index 07dfc45..b7d23b3 100644
--- a/examples/agents/code-reviewer.md
+++ b/examples/agents/code-reviewer.md
@@ -69,3 +69,223 @@ Always reference specific lines: `file.ts:45-50`
 - Explain WHY, not just WHAT
 - Suggest alternatives when pointing out issues
 - Acknowledge good patterns when you see them
+
+---
+
+## Anti-Hallucination Rules
+
+Critical: **Verify before asserting**. Never claim patterns exist without checking.
+
+### Verification Protocol
+
+Before making any suggestion:
+
+1. **Pattern Claims**: Use `Grep` or `Glob` to verify
+   ```
+   ❌ Wrong: "This project uses UserService pattern, apply it here"
+   ✅ Right: [Grep for UserService] → Found 12 occurrences → "Project uses UserService (12 occurrences), apply here"
+   ```
+
+2. **Occurrence Rule**:
+   - Pattern >10 occurrences = Established (Suggestion level)
+   - Pattern 3-10 occurrences = Emerging (Ask maintainer)
+   - Pattern <3 occurrences = Not established (Can Skip)
+
+3. **Read Full File**: Never review just diff lines
+   ```
+   ❌ Wrong: Review only changed lines (+/- in diff)
+   ✅ Right: Read entire file for context, then review changes
+   ```
+
+4. **Uncertainty Markers**:
+   ```
+   ❓ To verify: [pattern claim that needs confirmation]
+   💡 Consider: [optional improvement, not blocking]
+   🔴 Must fix: [critical bug/security, verified]
+   ```
+
+### Conditional Context Loading
+
+Load additional context based on diff content:
+
+| Diff Contains | Context to Load | Tools |
+|---------------|-----------------|-------|
+| `import`/`require` statements | Check package.json, verify deps exist | `Read package.json` |
+| Database queries (`SELECT`, `prisma.`, `knex`) | Check schema, indexes, N+1 patterns | `Read schema/*`, `Grep "prisma."` |
+| API routes (`app.get`, `router.post`) | Check auth middleware, input validation | `Grep "middleware"`, `Read routes/*` |
+| Auth logic (`bcrypt`, `jwt`, `session`) | Check security patterns, token storage | `Grep "password"`, `Grep "token"` |
+| File uploads (`multer`, `formidable`) | Check size limits, MIME validation | `Grep "upload"` |
+| Environment vars (`process.env`, `import.meta.env`) | Check .env.example, startup validation | `Read .env.example` |
+| External API calls (`fetch`, `axios`) | Check timeout, retry, error handling | `Grep "timeout"`, `Grep "retry"` |
+
+**Example**:
+```
+[See diff contains database query]
+1. Read schema/prisma.schema → verify table exists
+2. Grep "@@index" → check if queried fields are indexed
+3. Grep similar queries → check for N+1 pattern
+4. Then provide review with verified context
+```
+
+---
+
+## Defensive Code Audit
+
+Dedicated focus on **silent failures** and **masked bugs**.
+
+### Silent Catches (Critical)
+
+```javascript
+// 🔴 Critical: Swallowed exception
+try {
+  await sendEmail(user);
+} catch (e) {
+  // Silent failure - user thinks email sent
+}
+
+// ✅ Fixed: Log + fallback
+try {
+  await sendEmail(user);
+} catch (e) {
+  logger.error('Email failed', { userId: user.id, error: e });
+  throw new Error('Email delivery failed');
+}
+```
+
+**Detection pattern**: Search for:
+- Empty catch blocks: `catch (e) { }`
+- Console-only catches: `catch (e) { console.log(e) }`
+- Return-in-catch without re-throw: `catch (e) { return null }`
+
+### Hidden Fallbacks (High Priority)
+
+```javascript
+// 🔴 Masks missing data
+const userName = user?.name || 'Anonymous';
+// Problem: Can't distinguish "no user" from "user without name"
+
+// ✅ Explicit handling
+if (!user) throw new Error('User required');
+const userName = user.name || 'Anonymous';
+```
+
+**Detection pattern**: Search for:
+- Chained fallbacks: `a || b || c || DEFAULT`
+- Optional chaining with fallback: `obj?.nested?.value || fallback`
+- Destructuring with defaults on nullable: `const { x = 5 } = maybeNull || {}`
+
+### Unchecked Nulls (Medium Priority)
+
+```javascript
+// 🔴 Potential crash
+const email = user.email.toLowerCase();
+// Crashes if user.email is undefined
+
+// ✅ Validated
+if (!user?.email) throw new ValidationError('Email required');
+const email = user.email.toLowerCase();
+```
+
+**Detection pattern**: Search for:
+- Property access without optional chaining: `obj.prop.nested`
+- Array access without length check: `arr[0].value`
+- Function calls on potentially undefined: `fn().result`
+
+### Ignored Promise Rejections (Critical)
+
+```javascript
+// 🔴 Unhandled rejection
+async function processAll() {
+  items.forEach(item => processItem(item)); // Fire and forget
+}
+
+// ✅ Handled
+async function processAll() {
+  await Promise.all(items.map(item => processItem(item).catch(e => {
+    logger.error('Item processing failed', { item, error: e });
+    return null; // Explicit fallback
+  })));
+}
+```
+
+**Detection pattern**: Search for:
+- `async` function calls without `await` or `.catch()`
+- `.forEach()` with async callback
+- Event handlers that return promises without error handling
+
+---
+
+## Severity Classification System
+
+Use this hierarchy for all findings:
+
+```
+🔴 Must Fix (Blockers) — PR should not merge until fixed
+├─ Security vulnerabilities (OWASP Top 10)
+├─ Data loss risks (deletions without confirmation)
+├─ Silent failures masking bugs
+└─ Breaking changes without migration path
+
+🟡 Should Fix (Improvements) — Fix before next release
+├─ SOLID violations causing maintenance burden
+├─ DRY violations (>3 duplicates of same logic)
+├─ Performance bottlenecks (N+1, memory leaks)
+└─ Missing error handling for critical paths
+
+🟢 Can Skip (Nice-to-haves) — Optional improvements
+├─ Style inconsistencies (if no automated linter)
+├─ Minor naming improvements
+├─ Overly nested code (<3 levels)
+└─ Documentation gaps (if code self-documenting)
+```
+
+**Severity Justification**: Always explain why an issue is at its severity level.
+
+```
+❌ Wrong: "🔴 This is a critical issue"
+✅ Right: "🔴 Must fix: Empty catch block masks email delivery failures (user sees success but email never sent)"
+```
+
+---
+
+## Output Format (Enhanced)
+
+```markdown
+## Summary
+[1-2 sentence overall assessment with verified context]
+
+## 🔴 Must Fix (Blockers: X)
+1. **[Issue title]** — `file.ts:45-50`
+   - **Pattern**: [What pattern/anti-pattern detected]
+   - **Impact**: [Why this is critical]
+   - **Evidence**: [Grep/Glob results showing pattern]
+   - **Fix**: [Concrete code suggestion]
+
+## 🟡 Should Fix (Improvements: X)
+[Same structure as Must Fix]
+
+## 🟢 Can Skip (Optional: X)
+[Same structure, but mark as optional]
+
+## ❓ To Verify
+[Claims that need maintainer confirmation]
+- [ ] Project uses [pattern]? (Found X occurrences but unclear if intentional)
+
+## Positives
+[Specific patterns done well with line references]
+```
+
+---
+
+## Integration Notes
+
+- **SE-CoVe Plugin**: Use for fact-checking review claims (complementary to verification protocol)
+- **Multi-Agent Review**: This agent can be one of 3 specialized agents (see `/review-pr` advanced section)
+- **Auto-Fix Loop**: Can be used in iterative refinement workflow (max 3 iterations)
+
+---
+
+**Sources**:
+- Base template: Claude Code Ultimate Guide
+- Anti-hallucination & defensive patterns: [Méthode Aristote](https://github.com/FlorianBruniaux) code review system
+- Conditional context loading: Production Next.js/T3 Stack code review practices
diff --git a/examples/commands/review-pr.md b/examples/commands/review-pr.md
index 726bf04..3643232 100644
--- a/examples/commands/review-pr.md
+++ b/examples/commands/review-pr.md
@@ -76,4 +76,155 @@ Perform a comprehensive code review of a pull request.
 /review-pr https://github.com/owner/repo/pull/123
 ```
 
+---
+
+## Advanced: Multi-Agent Review
+
+For production-grade reviews requiring specialized perspectives and anti-hallucination safeguards.
+
+### Pre-flight Check
+
+Before reviewing, check if this is a follow-up pass to avoid repeating suggestions:
+
+```bash
+# Detect if Claude already reviewed this PR
+git log --oneline -10 | grep "Co-Authored-By: Claude"
+```
+
+If detected, note: "This appears to be a follow-up pass. I'll focus on new issues and avoid repeating previous suggestions."
+
+### Multi-Agent Specialization
+
+Launch 3 parallel specialized agents (see [Split Role Sub-Agents](../../guide/ultimate-guide.md#split-role-sub-agents)):
+
+**Agent 1: Consistency Auditor**
+```
+Focus: DRY violations, duplicate logic, pattern inconsistencies
+Check for:
+- Duplicated code blocks (>5 lines similar)
+- Inconsistent naming conventions
+- Pattern violations (if project uses X pattern, enforce it)
+```
+
+**Agent 2: SOLID Principles Analyst**
+```
+Focus: Single Responsibility Principle violations, complexity
+Check for:
+- Functions >50 lines (likely doing too much)
+- Nested conditionals >3 levels deep
+- Cyclomatic complexity >10
+- Mixed concerns in single component
+```
+
+**Agent 3: Defensive Code Auditor**
+```
+Focus: Silent failures, masked bugs, hidden fallbacks
+Check for:
+- Empty catch blocks: try { } catch (e) { } // swallows error
+- Silent fallbacks: return data || DEFAULT // hides missing data
+- Unchecked null/undefined: user.name without validation
+- Ignored promise rejections: async fn without .catch()
+```
+
+### Anti-Hallucination Rules
+
+**Verify before asserting**:
+- Use `Grep` or `Glob` to verify patterns before recommending them
+- If suggesting "use existing UserService pattern", confirm UserService exists first
+- Never claim "project uses X" without checking actual codebase
+
+**Occurrence rule**:
+- Pattern with >10 occurrences = established (Suggestion level)
+- Pattern with <3 occurrences = not established (Can Skip or ask maintainer)
+- Read full file context, not just diff lines
+
+**Uncertainty markers**:
+- Use "❓ To verify:" when unsure about project conventions
+- Use "💡 Consider:" for optional improvements
+- Use "🔴 Must fix:" only for critical bugs/security
+
+### Reconciliation
+
+After agents report findings:
+
+1. **Deduplicate**: Remove overlapping suggestions across agents
+2. **Prioritize existing patterns**: If codebase uses pattern X, recommend X (not ideal pattern Y)
+3. **Mark skipped suggestions**: "Skipping [suggestion] because project uses [alternative pattern]"
+4. **Track reasoning**: Document why suggestion was kept or skipped
+
+### Severity Classification
+
+```
+🔴 Must Fix (Blockers)
+- Security vulnerabilities
+- Data loss risks
+- Breaking changes without migration
+- Silent failures masking bugs
+
+🟡 Should Fix (Improvements)
+- SOLID violations causing maintenance issues
+- DRY violations (>3 duplicates)
+- Performance bottlenecks (N+1 queries)
+- Missing error handling for critical paths
+
+🟢 Can Skip (Nice-to-haves)
+- Style inconsistencies (if no linter)
+- Minor naming improvements
+- Overly nested code (if <3 levels)
+- Documentation gaps (if code self-documenting)
+```
+
+### Auto-Fix Loop (Optional)
+
+For automated convergence:
+
+```
+Review → Identify issues → Fix → Re-review → Repeat until minimal changes
+
+Safeguards:
+- Max 3 iterations to prevent infinite loops
+- Run tsc/lint check before each iteration
+- Skip auto-fix for protected files (package.json, migrations, etc.)
+```
+
+**Example prompt**:
+```
+Review this PR with auto-fix enabled:
+1. Review using 3 agents above
+2. Fix all 🔴 Must Fix issues
+3. Re-review to verify fixes
+4. Repeat for 🟡 Should Fix (max 2 more iterations)
+5. Stop when only 🟢 Can Skip remain
+```
+
+### Conditional Context Loading
+
+Load additional context based on diff content (stack-agnostic):
+
+| If diff contains... | Then check... |
+|---------------------|---------------|
+| Database queries | Indexes, N+1 patterns, query optimization |
+| API endpoints | Auth middleware, input validation, rate limiting |
+| Authentication logic | Password hashing, session management, CSRF tokens |
+| File uploads | Size limits, MIME validation, storage security |
+| Date/time operations | Timezone handling, DST edge cases |
+| External API calls | Timeout configs, retry logic, error handling |
+| Environment variables | Presence in .env.example, validation at startup |
+
+### Integration with Existing Tools
+
+**SE-CoVe Plugin**: Use for general fact-checking of review claims (complementary to anti-hallucination rules above)
+
+**Worktrunk**: For codebase-wide pattern analysis before suggesting changes
+
+**AST-grep**: For structural pattern matching (e.g., find all similar try/catch blocks)
+
+---
+
+## Sources
+
+- Base template: Claude Code Ultimate Guide
+- Multi-agent review: [Pat Cullen](https://gist.github.com/patyearone/c9a091b97e756f5ed361f7514d88ef0b) (Jan 2026)
+- Anti-hallucination patterns: [Méthode Aristote](https://github.com/FlorianBruniaux) code review system
+
 $ARGUMENTS
diff --git a/guide/cheatsheet.md b/guide/cheatsheet.md
index 727e0a5..08f5c6a 100644
--- a/guide/cheatsheet.md
+++ b/guide/cheatsheet.md
@@ -6,7 +6,7 @@
 
 **Written with**: Claude (Anthropic)
 
-**Version**: 3.19.0 | **Last Updated**: January 2026
+**Version**: 3.20.0 | **Last Updated**: January 2026
 
 ---
 
@@ -484,4 +484,4 @@ where.exe claude; claude doctor; claude mcp list
 
 **Author**: Florian BRUNIAUX | [@Méthode Aristote](https://methode-aristote.fr) | Written with Claude
 
-*Last updated: January 2026 | Version 3.19.0*
+*Last updated: January 2026 | Version 3.20.0*
diff --git a/guide/ultimate-guide.md b/guide/ultimate-guide.md
index 48f14cf..153302d 100644
--- a/guide/ultimate-guide.md
+++ b/guide/ultimate-guide.md
@@ -10,7 +10,7 @@
 
 **Last updated**: January 2026
 
-**Version**: 3.19.0
+**Version**: 3.20.0
 
 ---
 
@@ -4621,6 +4621,32 @@ Evaluate this interface with perspectives:
 5. Mobile User: Responsive and touch
 ```
 
+**Production Example: Multi-Agent Code Review** (Pat Cullen, Jan 2026):
+
+Specialized agent roles for comprehensive PR review:
+
+1. **Consistency Agent**: Duplicate logic, pattern violations, DRY compliance
+2. **SOLID Agent**: SRP violations, nested conditionals (>3 levels), cyclomatic complexity >10
+3. **Defensive Code Auditor**: Silent catches, swallowed exceptions, hidden fallbacks
+
+**Key patterns** (beyond generic Split Role):
+
+- **Pre-flight check**: `git log --oneline -10 | grep "Co-Authored-By: Claude"` to detect follow-up passes and avoid repeating suggestions
+- **Anti-hallucination**: Use `Grep`/`Glob` to verify patterns before recommending them (occurrence rule: >10 = established, <3 = not established)
+- **Reconciliation**: Prioritize existing project patterns over ideal patterns, skip suggestions with documented reasoning
+- **Severity classification**: 🔴 Must Fix (blockers) / 🟡 Should Fix (improvements) / 🟢 Can Skip (nice-to-haves)
+- **Convergence loop**: Review → fix → re-review → repeat (max 3 iterations) until only optional improvements remain
+
+**Production safeguards**:
+
+- Read full file context (not just diff lines)
+- Conditional context loading based on diff content (DB queries → check indexes, API routes → check auth middleware)
+- Protected files skip list (package.json, migrations, .env)
+- Quality gates: `tsc && lint` validation before each iteration
+
+**Source**: [Pat Cullen's Final Review](https://gist.github.com/patyearone/c9a091b97e756f5ed361f7514d88ef0b)
+**Implementation**: See `/review-pr` advanced section, `examples/agents/code-reviewer.md`, `guide/workflows/iterative-refinement.md` (Review Auto-Correction Loop)
+
 ### Parallelization Decision Matrix
 
 ```
@@ -15717,4 +15743,4 @@ We'll evaluate and add it to this section if it meets quality criteria.
 
 **Contributions**: Issues and PRs welcome.
 
-**Last updated**: January 2026 | **Version**: 3.19.0
+**Last updated**: January 2026 | **Version**: 3.20.0
diff --git a/guide/workflows/iterative-refinement.md b/guide/workflows/iterative-refinement.md
index 2350680..256edb9 100644
--- a/guide/workflows/iterative-refinement.md
+++ b/guide/workflows/iterative-refinement.md
@@ -344,6 +344,140 @@ Next: add Redis backend."
 
 ---
 
+## Review Auto-Correction Loop
+
+Specialized iterative pattern for code review where Claude reviews → fixes → re-reviews until convergence.
+
+### Pattern
+
+```
+┌─────────────────────────────────────────┐
+│   Review Auto-Correction Loop           │
+│                                          │
+│   Review (identify issues)               │
+│        ↓                                 │
+│   Fix (apply corrections)                │
+│        ↓                                 │
+│   Re-Review (verify fixes)               │
+│        ↓                                 │
+│   Converge (minimal changes) → Done      │
+│        ↑                                 │
+│        └──── Repeat (max iterations)     │
+└─────────────────────────────────────────┘
+```
+
+### Prompt Template
+
+```
+Review this PR with auto-correction:
+1. Multi-agent review (3 specialized agents)
+2. Fix all 🔴 Must Fix issues
+3. Re-review to verify fixes didn't introduce new issues
+4. Fix all 🟡 Should Fix issues
+5. Re-review one final time
+6. Stop when only 🟢 Can Skip remain
+
+Max iterations: 3
+Stop early if iteration produces <5 lines changed
+```
+
+### Safeguards
+
+| Safeguard | Purpose | Implementation |
+|-----------|---------|----------------|
+| **Max iterations** | Prevent infinite loops | Hard limit: 3 iterations |
+| **Quality gates** | Ensure fixes are valid | Run `tsc && lint` before each iteration |
+| **Protected files** | Prevent risky changes | Skip auto-fix for: package.json, migrations, .env |
+| **Change threshold** | Stop when converged | Exit if iteration changes <5 lines |
+| **Rollback capability** | Recover from bad fixes | Git commit before each iteration |
+
+### Example Session
+
+**Iteration 1: Initial Review**
+```
+Claude: Found 8 issues:
+- 🔴 3 Must Fix (SQL injection, empty catch, missing auth)
+- 🟡 4 Should Fix (DRY violations, N+1 query)
+- 🟢 1 Can Skip (naming style)
+```
+
+**Iteration 2: Fix Must Fix + Re-Review**
+```
+Claude: Fixed 3 Must Fix issues.
+Re-review: All 🔴 resolved. No new issues introduced.
+Remaining: 4 🟡 Should Fix, 1 🟢 Can Skip
+```
+
+**Iteration 3: Fix Should Fix + Re-Review**
+```
+Claude: Fixed 4 Should Fix issues.
+Re-review: All 🟡 resolved. No new issues.
+Remaining: 1 🟢 Can Skip (optional improvement)
+```
+
+**Convergence**
+```
+Claude: Converged. Only optional improvements remain.
+Changes this iteration: 2 lines (below threshold).
+Review complete. ✅
+```
+
+### Comparison: One-Pass vs Convergence Loop
+
+| Aspect | One-Pass Review | Convergence Loop |
+|--------|-----------------|------------------|
+| **Detection** | Find all issues once | Find issues → fix → verify → repeat |
+| **Follow-up awareness** | Check git log for "Co-Authored-By: Claude" | Each iteration is aware of previous |
+| **False positives** | Can suggest fixes for already-fixed code | Re-review catches this |
+| **Confidence** | Single validation | Multiple validation passes |
+| **Time cost** | Fastest (1 review) | Slower (3+ reviews) |
+| **Quality** | Good for experienced devs | Better for critical code |
+
+**When to use**:
+- **One-pass**: Simple PRs, experienced team, time-sensitive
+- **Convergence loop**: Security-critical code, junior team, high-stakes production
+
+### Integration with Multi-Agent Review
+
+Combine convergence loop with multi-agent review for maximum quality:
+
+```
+Each iteration:
+├─ Agent 1: Consistency Auditor
+├─ Agent 2: SOLID Principles Analyst
+└─ Agent 3: Defensive Code Auditor
+     ↓
+  Fix issues
+     ↓
+  Re-run 3 agents
+     ↓
+  Verify fixes + check for new issues
+     ↓
+  Repeat until convergence
+```
+
+### Convergence Criteria
+
+Stop iterating when ANY of these is true:
+
+1. **No issues remaining** (ideal outcome)
+2. **Max iterations reached** (3 iterations default)
+3. **Change threshold** (iteration changed <5 lines)
+4. **Quality gate failure** (tsc/lint fails after fix)
+5. **Manual stop** (user requests halt)
+
+### Anti-Patterns in Review Loops
+
+| Anti-Pattern | Problem | Solution |
+|--------------|---------|----------|
+| **Infinite loop** | No convergence criteria | Set max iterations + change threshold |
+| **Scope creep** | Each iteration adds new requirements | Lock scope before starting loop |
+| **Breaking fixes** | Fix introduces new bugs | Re-review after each fix + quality gates |
+| **Protected file changes** | Modifies package.json, migrations | Explicit skip list for protected files |
+| **Context loss** | Forgets original issues after iteration 3 | Maintain issue tracker across iterations |
+
+---
+
 ## Example Session
 
 ### Initial Request
diff --git a/machine-readable/reference.yaml b/machine-readable/reference.yaml
index 5e69c29..d136a86 100644
--- a/machine-readable/reference.yaml
+++ b/machine-readable/reference.yaml
@@ -3,7 +3,7 @@
 # Source: guide/ultimate-guide.md
 # Purpose: Condensed index for LLMs to quickly answer user questions about Claude Code
 
-version: "3.19.0"
+version: "3.20.0"
 updated: "2026-01-30"
 
 # ════════════════════════════════════════════════════════════════
@@ -22,6 +22,10 @@ deep_dive:
   # Claude Code Releases
   claude_code_releases: "guide/claude-code-releases.md"
   claude_code_releases_yaml: "machine-readable/claude-code-releases.yaml"
+  # Code Review Automation (Pat Cullen, Jan 2026)
+  review_pr_advanced: "examples/commands/review-pr.md:81"
+  review_anti_hallucination: "examples/agents/code-reviewer.md:75"
+  review_auto_fix_loop: "guide/workflows/iterative-refinement.md:347"
   # Known Issues & Critical Bugs (verified community reports)
   known_issues: "guide/known-issues.md"
   known_issues_github_bug: "guide/known-issues.md:16"  # GitHub auto-creation bug
@@ -822,7 +826,7 @@ ecosystem:
       - "Cross-links modified → Update all 4 repos"
     history:
       - date: "2026-01-20"
-        event: "Code Landing sync v3.19.0, 66 templates, cross-links"
+        event: "Code Landing sync v3.20.0, 66 templates, cross-links"
         commit: "5b5ce62"
       - date: "2026-01-20"
         event: "Cowork Landing fix (paths, README, UI badges)"