receiving-code-review

name	receiving-code-review
description	Use when receiving code review feedback, before implementing suggestions. 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

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:

Reviewer: "Fix items 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 Trusted Collaborators

• Implement after understanding
• Still ask if scope is unclear
• 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 cannot easily verify:
  Say so: "I cannot verify this without [X]. Should I [investigate/ask/proceed]?"

YAGNI Check

IF reviewer suggests adding features:
  Search codebase for actual usage

  IF unused: "This is not called anywhere. Remove it (YAGNI)?"
  IF used: Then implement properly

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 established architectural decisions

How to push back:

• Use technical reasoning, not defensiveness
• Ask specific questions
• Reference working tests/code

Acknowledging Correct Feedback

When feedback IS correct:

DO: "Fixed. [Brief description of what changed]"
DO: "Good catch — [specific issue]. Fixed in [location]."
DO: [Just fix it and show in the code]

AVOID: Performative gratitude — actions speak louder than words

Common Mistakes

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 it breaks things
Avoiding pushback	Technical correctness matters
Partial implementation	Clarify all items first
Cannot verify, proceed anyway	State limitation, ask for direction

The Bottom Line

External feedback = suggestions to evaluate, not orders to follow.

Verify. Question. Then implement.

Technical rigor always.

Generated by autoharness | Template: community/skills/receiving-code-review/SKILL.md.tmpl