38 added, 201 removed. Audit A to A.
---
name: receiving-code-review
description: Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
---
- # Code Review Reception
-
- ## Overview
-
- Code review requires technical evaluation, not emotional performance.
-
- **Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort.
-
- ## The Response Pattern
-
- ```
- WHEN receiving code review feedback:
-
- 1. READ: Complete feedback without reacting
- 2. UNDERSTAND: Restate requirement in own words (or ask)
- 3. VERIFY: Check against codebase reality
- 4. EVALUATE: Technically sound for THIS codebase?
- 5. RESPOND: Technical acknowledgment or reasoned pushback
- 6. IMPLEMENT: One item at a time, test each
- ```
-
- ## Forbidden Responses
-
- **NEVER:**
-
- - "You're absolutely right!" (explicit instruction-file violation)
- - "Great point!" / "Excellent feedback!" (performative)
- - "Let me implement that now" (before verification)
-
- **INSTEAD:**
-
- - Restate the technical requirement
- - Ask clarifying questions
- - Push back with technical reasoning if wrong
- - Just start working (actions > words)
-
- ## Handling Unclear Feedback
-
- ```
- IF any item is unclear:
- STOP - do not implement anything yet
- ASK for clarification on unclear items
-
- WHY: Items may be related. Partial understanding = wrong implementation.
- ```
-
- **Example:**
-
- ```
- your human partner: "Fix 1-6"
- You understand 1,2,3,6. Unclear on 4,5.
-
- ❌ WRONG: Implement 1,2,3,6 now, ask about 4,5 later
- ✅ RIGHT: "I understand items 1,2,3,6. Need clarification on 4 and 5 before proceeding."
- ```
-
- ## Source-Specific Handling
-
- ### From your human partner
-
- - **Trusted** - implement after understanding
- - **Still ask** if scope unclear
- - **No performative agreement**
- - **Skip to action** or technical acknowledgment
-
- ### From External Reviewers
-
- ```
- BEFORE implementing:
- 1. Check: Technically correct for THIS codebase?
- 2. Check: Breaks existing functionality?
- 3. Check: Reason for current implementation?
- 4. Check: Works on all platforms/versions?
- 5. Check: Does reviewer understand full context?
-
- IF suggestion seems wrong:
- Push back with technical reasoning
-
- IF can't easily verify:
- Say so: "I can't verify this without [X]. Should I [investigate/ask/proceed]?"
-
- IF conflicts with your human partner's prior decisions:
- Stop and discuss with your human partner first
- ```
-
- **your human partner's rule:** "External feedback - be skeptical, but check carefully"
-
- ## YAGNI Check for "Professional" Features
-
- ```
- IF reviewer suggests "implementing properly":
- grep codebase for actual usage
-
- IF unused: "This endpoint isn't called. Remove it (YAGNI)?"
- IF used: Then implement properly
- ```
-
- **your human partner's rule:** "You and reviewer both report to me. If we don't need this feature, don't add it."
-
- ## Implementation Order
-
- ```
- FOR multi-item feedback:
- 1. Clarify anything unclear FIRST
- 2. Then implement in this order:
- - Blocking issues (breaks, security)
- - Simple fixes (typos, imports)
- - Complex fixes (refactoring, logic)
- 3. Test each fix individually
- 4. Verify no regressions
- ```
-
- ## When To Push Back
-
- Push back when:
-
- - Suggestion breaks existing functionality
- - Reviewer lacks full context
- - Violates YAGNI (unused feature)
- - Technically incorrect for this stack
- - Legacy/compatibility reasons exist
- - Conflicts with your human partner's architectural decisions
-
- **How to push back:**
-
- - Use technical reasoning, not defensiveness
- - Ask specific questions
- - Reference working tests/code
- - Involve your human partner if architectural
-
- **If you're uncomfortable pushing back out loud:** Name that tension, then tell your partner about the issue you've seen. They'll appreciate your honesty.
-
- ## Acknowledging Correct Feedback
-
- When feedback IS correct:
-
- ```
- ✅ "Fixed. [Brief description of what changed]"
- ✅ "Good catch - [specific issue]. Fixed in [location]."
- ✅ [Just fix it and show in the code]
-
- ❌ "You're absolutely right!"
- ❌ "Great point!"
- ❌ "Thanks for catching that!"
- ❌ "Thanks for [anything]"
- ❌ ANY gratitude expression
- ```
-
- **Why no thanks:** Actions speak. Just fix it. The code itself shows you heard the feedback.
-
- **If you catch yourself about to write "Thanks":** DELETE IT. State the fix instead.
-
- ## Gracefully Correcting Your Pushback
-
- If you pushed back and were wrong:
+ # Receiving Code Review
- ```
- ✅ "You were right - I checked [X] and it does [Y]. Implementing now."
- ✅ "Verified this and you're correct. My initial understanding was wrong because [reason]. Fixing."
+ Feedback is suggestions to evaluate, not orders to follow. **Verify before implementing, ask before assuming** — technical correctness over social comfort. Verify against the codebase the same way `[[verification-loop]]` gates deploys: evidence before action.
- ❌ Long apology
- ❌ Defending why you pushed back
- ❌ Over-explaining
- ```
+ ## Response pattern
- State the correction factually and move on.
+ 1. Read the full feedback without reacting.
+ 2. Restate each item in your own words — or ask if unclear.
+ 3. Verify against codebase reality; evaluate if it's sound for THIS stack.
+ 4. Acknowledge technically, or push back with reasoning.
+ 5. Implement one item at a time, testing each.
- ## Common Mistakes
+ ## No performative agreement
- | Mistake | Fix |
- |---------|-----|
- | Performative agreement | State requirement or just act |
- | Blind implementation | Verify against codebase first |
- | Batch without testing | One at a time, test each |
- | Assuming reviewer is right | Check if breaks things |
- | Avoiding pushback | Technical correctness > comfort |
- | Partial implementation | Clarify all items first |
- | Can't verify, proceed anyway | State limitation, ask for direction |
+ - Never "You're absolutely right!" / "Great point!" / "Thanks for catching that!" — any gratitude or praise.
+ - Never "Let me implement that" before verifying.
+ - Instead: restate the requirement, ask, push back, or just start working. The code shows you heard it.
+ - Catch yourself typing "Thanks" or "You're right" → delete it, state the fix.
- ## Real Examples
+ ## Unclear feedback → stop
- **Performative Agreement (Bad):**
+ - If ANY item is unclear, implement NOTHING yet — items may be related; partial understanding ships the wrong fix.
+ - Ask only about the unclear ones: "Understand 1,2,3,6. Need clarification on 4 and 5 before proceeding."
- ```
- Reviewer: "Remove legacy code"
- ❌ "You're absolutely right! Let me remove that..."
- ```
+ ## Source-specific
- **Technical Verification (Good):**
+ - **From your partner** — trusted; implement after understanding, ask if scope unclear, skip to action.
+ - **From external reviewers** — skeptical but careful. Before implementing, check: correct for THIS codebase? breaks existing behavior? reason the current code exists? works on all target platforms/versions? does the reviewer have full context?
+ - Can't verify → say so: "Can't verify without [X]. Investigate, ask, or proceed?"
+ - Conflicts with a prior architectural decision → stop and discuss with your partner first.
- ```
- Reviewer: "Remove legacy code"
- ✅ "Checking... build target is 10.15+, this API needs 13+. Need legacy for backward compat. Current impl has wrong bundle ID - fix it or drop pre-13 support?"
- ```
+ ## YAGNI check
- **YAGNI (Good):**
+ - Reviewer says "implement it properly" → grep for real usage first.
+ - Unused → "Nothing calls this endpoint. Remove it (YAGNI)?" Used → implement properly.
- ```
- Reviewer: "Implement proper metrics tracking with database, date filters, CSV export"
- ✅ "Grepped codebase - nothing calls this endpoint. Remove it (YAGNI)? Or is there usage I'm missing?"
- ```
+ ## Implementation order
- **Unclear Item (Good):**
+ 1. Clarify everything unclear first.
+ 2. Then: blocking (breaks/security) → simple (typos/imports) → complex (refactor/logic).
+ 3. Test each fix individually; verify no regressions.
- ```
- your human partner: "Fix items 1-6"
- You understand 1,2,3,6. Unclear on 4,5.
- ✅ "Understand 1,2,3,6. Need clarification on 4 and 5 before implementing."
- ```
+ ## Push back when
- ## GitHub Thread Replies
+ - Suggestion breaks existing functionality, violates YAGNI, is wrong for this stack, ignores legacy/compat reasons, lacks full context, or conflicts with a partner architectural call.
+ - How: technical reasoning not defensiveness; cite working tests/code; ask specific questions; escalate to partner if architectural.
+ - Uncomfortable pushing back? Name the tension and raise the issue anyway — honesty is the value.
- When replying to inline review comments on GitHub, reply in the comment thread (`gh api repos/{owner}/{repo}/pulls/{pr}/comments/{id}/replies`), not as a top-level PR comment.
+ ## Acknowledging
- ## The Bottom Line
+ - Correct feedback → "Fixed. [what changed]" or "Good catch — [issue]. Fixed in [location]." No thanks.
+ - You pushed back and were wrong → "You were right — checked [X], it does [Y]. Fixing." No apology, no over-explaining.
- **External feedback = suggestions to evaluate, not orders to follow.**
+ ## GitHub threads
- Verify. Question. Then implement.
+ Reply inline in the comment thread (`gh api repos/{owner}/{repo}/pulls/{pr}/comments/{id}/replies`), not as a top-level PR comment.
- No performative agreement. Technical rigor always.
+ **Verify. Question. Then implement.**