Skip to content
Skills Library
Programming · Review & audit

receiving-code-review

/receiving-code-review

Use when receiving code review feedback — before implementing any suggestion, especially if feedback is unclear, conflicts with prior decisions, or seems technically questionable. Requires verification and technical rigor, not performative agreement or blind implementation.

Licence
MIT
Last repository change
30.06.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 30.06.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when receiving code review feedback — before implementing any suggestion, especially if feedback is unclear, conflicts with prior decisions, or seems technically questionable. Requires verification and technical rigor, not performative agreement or blind implementation.

Original author description

Use when receiving code review feedback — before implementing any suggestion, especially if feedback is unclear, conflicts with prior decisions, or seems technically questionable. Requires verification and technical rigor, not performative agreement or blind implementation.

How it works

  1. Overview
  2. The 6-Step Pattern
  3. Handling Unclear Feedback
  4. Source-Specific Handling
  5. YAGNI Check (Before "Professional" Suggestions)
  6. When to Push Back
  7. Acknowledging Correct Feedback
  8. Correcting a Wrong Pushback
  9. Common Mistakes
  10. Concrete Example — Responding to a Review Comment
Original SKILL.md headings · 180 lines, 988 words
SKILL.md preview
---
name: receiving-code-review
description: Use when receiving code review feedback — before implementing any suggestion, especially if feedback is unclear, conflicts with prior decisions, or seems technically questionable. Requires verification and technical rigor, not performative agreement or blind implementation.
allowed-tools: Read, Grep, Glob
metadata:
  triggers: code review feedback, receiving feedback, implementing review suggestions, code review response, review comment
  related-skills: pr-review, code-reviewer, test-driven-development
  domain: workflow
  role: specialist
  scope: review
  output-format: document
last-reviewed: "2026-03-15"
---

**Iron Law:** Never dismiss review feedback without re-reading the flagged code; always respond to each finding with file:line evidence for your position.

# Receiving Code Review

## Overview

Receiving a review is not the same as agreeing with it.

**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort.

## The 6-Step Pattern

Process ALL feedback before implementing ANY of it:

```
1. READ       — Complete feedback without reacting. Do not implement mid-read.
2. UNDERSTAND — Restate each item in your own words. Cannot restate = ask first.
3. VERIFY     — Check the codebase. Does the problem actually exist at file:line?
4. EVALUATE   — Technically correct for THIS stack? YAGNI? Conflicts prior decision?
5. RESPOND    — Clarify unclear items. Push back on incorrect ones. Acknowledge valid ones.
6. IMPLEMENT  — One item at a time, test each. Fix order: blocking → simple → complex.
```

**Forbidden:**
- "You're absolutely right!" / "Great point!" / "Thanks for catching that!" (performative)
- Starting implementation before finishing full read
- Implementing anything you cannot restate in your own words

**Instead:** Restate the requirement, or just act — code shows you heard the feedback.

## Handling Unclear Feedback

If ANY item is unclear: **STOP. Do not implement anything yet.**

```
your partner: "Fix items 1-6"
You understand 1, 2, 3, 6. Unclear on 4, 5.

❌ Implement 1,2,3,6 now, ask about 4,5 later
✅ "Understand 1,2,3,6. Need clarification on 4 and 5 before proceeding."
```

Partial understanding → wrong implementation. Items may be related.

## Source-Specific Handling

**From human partner (internal):**
- Trusted — implement after understanding
- Still ask if scope is unclear or conflicts with a prior decision
- Skip to action or technical acknowledgment (no gratitude)

**From external reviewers (CI, automated tools, external PRs):**
```
BEFORE implementing:
  1. Technically correct for THIS stack/version?
  2. Breaks existing functionality or tests?
  3. Why does the current implementation exist?
  4. Does the reviewer understand the full context?

IF conflicts with human partner's prior decisions → stop and discuss first
IF can't verify → "I can't verify this without [X]. Should I [investigate/ask/proceed]?"
```

## YAGNI Check (Before "Professional" Suggestions)

When a reviewer suggests adding abstraction, proper patterns, or extra features:

```
grep codebase → is this actually used more than once?

IF unused: "Grepped codebase — nothing calls this. Remove it (YAGNI)?"
IF speculative: "This is used once. Per code-standards.md I'd keep it simple
                 unless we have a concrete second use case. Override?"
IF used: implement properly
```

## When to Push Back

Push back (technical reasoning, not refusal) when feedback:
- Breaks existing functionality or test coverage
- Conflicts with an established architectural decision (reference the plan or ADR)
- Conflicts with a prior instruction from the human partner
- Is technically incorrect for the framework/version in use (check MCP docs)
- Is speculative YAGNI — the feature does not exist in the codebase
- Adds complexity that `code-standards.md` explicitly forbids

**Format:**
```
"Not implementing [X] because [concrete reason + evidence at file:line].
 Proposed alternative: [Y if applicable].
 Do you want to override?"
```

## Acknowledging Correct Feedback

```
✅ "Fixed. [Brief description of what changed at file:line]"
✅ "Good catch — [specific issue]. Fixed in [location]."
✅ [Just fix it and show the diff]

❌ "You're absolutely right!"
❌ "Great point!"
❌ "Thanks for catching that!"
❌ ANY gratitude expression
```

Actions speak. The fix itself shows you heard the feedback.

## Correcting a Wrong Pushback

If you pushed back and were wrong:
```
✅ "You were right — checked [X] and it does [Y]. Implementing now."
✅ "Verified and you're correct. My initial read was wrong because [reason]. Fixing."

❌ Long apology
❌ Defending why you pushed back
❌ Over-explaining
```

State the correction factually. Move on.

## 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 > comfort |
| Partial implementation | Clarify ALL items first |
| Can't verify, proceed anyway | State the limitation, ask for direction |

## Concrete Example — Responding to a Review Comment

**Reviewer comment:** "This `getUserById` method should return `Optional<User>` instead of nullable."

```
Step 2 — UNDERSTAND:
  Reviewer wants null-safety: return Optional<User> so callers are forced to handle absence.

Step 3 — VERIFY:
  src/main/java/com/example/UserRepository.java:42
    public User getUserById(Long id) { ... }  // returns null if not found ✅ confirmed

Step 4 — EVALUATE:
  Correct for Spring Boot Java stack. Optional<User> is idiomatic here. No conflict with
  existing callers — grep shows only 2 call sites, both in tests.

Step 5 — RESPOND (inline thread reply):
  "Fixed. Changed return type to Optional<User> at UserRepository.java:42.
   Updated 2 call sites in UserServiceTest.java:18 and UserControllerTest.java:55."

Step 6 — IMPLEMENT:
  - Change signature to Optional<User>
  - Wrap return value: return Optional.ofNullable(userRepo.findById(id))
  - Update 2 test call sites
  - Run tests: all pass
```

## Integration

- Use after: `/review-code`, SDD pipeline (after quality reviewer responds), any PR review
- Pairs with: `requesting-code-review` skill (send path → receive path)
- GitHub replies: use inline thread replies, not top-level PR comments
  (`gh api repos/{owner}/{repo}/pulls/{pr}/comments/{id}/replies`)

## References

| Reference | Why |
|-----------|-----|
| `core-behaviors.md` §4 | Simplicity check — reject complexity added by reviewer if YAGNI |
| `core-behaviors.md` §5 | Scope discipline — don't over-fix adjacent code while addressing feedback |
| `code-standards.md` DRY/YAGNI | Authority for pushing back on speculative abstractions |
| `first-principles.md` Layer 1 | Hard stops that apply even when reviewer asks for them (e.g., `as any`) |
| `iterate-pr` skill | Use when iterating a PR loop based on review feedback + CI results |
| `pr-review` skill | The send side of this workflow (reviewing others' code) |

Versions

RepositoryScoreLicence
This page · kumaran-is/claude-code-onboarding100MIT
event4u-app/agent-config100MIT
drvoss/everything-copilot-cli100MIT
rootcastleco/rei-skills100MIT
foryourhealth111-pixel/Vibe-Skills100Apache-2.0
jjuraszek/pi-gauntlet100MIT
coco-research/coco100MIT
davila7/claude-code-templates100MIT
osmontero/opencode-skills100MIT

Database snapshot: 13.11.2026 · package version 6608cd1bd513 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100receiving-code-review-codex
    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
  • 100ferrox-receiving-code-review
    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
  • 100sr-receiving-code-review
    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
  • 100receiving-review
    Use when receiving any code review feedback, before implementing any suggestion - requires technical rigor and verification, not performative agreement or blind implementation
  • 100review-feedback
    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
  • 100receiving-critical-review
    Use when receiving critical feedback on an analysis or manuscript, before implementing suggestions, especially if feedback seems unclear or methodologically questionable - requires verification, not performative agreement or blind changes

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.