# Code Review Reception

> Receives code review feedback through technical verification rather than performative agreement or blind implementation. Use when receiving review comments, before implementing reviewer suggestions, when feedback is unclear, or when a suggestion may be wrong for this codebase.

- **Type:** Skill
- **Install:** `agentstack add skill-jagreehal-jagreehal-claude-skills-code-review-reception`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [jagreehal](https://agentstack.voostack.com/s/jagreehal)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [jagreehal](https://github.com/jagreehal)
- **Source:** https://github.com/jagreehal/jagreehal-claude-skills/tree/main/skills/code-review-reception

## Install

```sh
agentstack add skill-jagreehal-jagreehal-claude-skills-code-review-reception
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Code Review Reception

## Overview

Treat code review as technical evaluation, not emotional performance. The core principle is one rule: **verify before implementing.** Technical correctness comes before social comfort, and evidence comes before agreement. A reviewer's suggestion is a hypothesis about your code, not a command. Check it against the codebase before applying it, push back with reasoning when it's wrong, and acknowledge it factually when it's right.

This matters because performative agreement ("You're absolutely right!") and blind implementation both skip the step that makes review valuable: judgment. Rubber-stamping a wrong suggestion ships a bug; thanking a reviewer instead of verifying wastes the review.

## When to Use

- Receiving code review feedback from a human, another agent, or a model
- Before implementing any reviewer suggestion
- When feedback is unclear or items may be related
- When a suggestion may break existing functionality or conflict with established patterns

**When NOT to use:** Authoring a review of someone else's code; that is the reviewer's role, not reception.

**Related:** [verification-before-completion](../verification-before-completion/SKILL.md) (verify each fix before claiming done), [tdd-workflow](../tdd-workflow/SKILL.md) (use TDD when implementing fixes), [debugging-methodology](../debugging-methodology/SKILL.md) (follow the loop for complex fixes), [critical-peer](../critical-peer/SKILL.md) (the same honesty standard applied as a reviewer).

## The Response Pattern

```
WHEN receiving code review feedback:

1. READ:      Complete feedback without reacting
2. UNDERSTAND: Restate the requirement in your own words (or ask)
3. VERIFY:    Check the suggestion against codebase reality
4. EVALUATE:  Is it 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 the unclear items

WHY: Items may be related. Partial understanding produces 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 1, 2, 3, 6. Need clarification on 4 and 5 before starting."
```

## When to Push Back

Push back when the suggestion:

- Breaks existing functionality
- Comes from a reviewer who lacks full context
- Violates YAGNI (requests an unused feature)
- Is technically incorrect for this stack
- Conflicts with established patterns

**How to push back, with evidence, not defensiveness:**

```
RIGHT: "Checking — this API requires legacy support for <13. Current impl
        has the wrong bundle ID. Fix it, or drop pre-13 support?"

WRONG: "But I think..." (defensive, no evidence)
```

### YAGNI Check

```
IF reviewer suggests "implementing properly":
  grep the codebase for actual usage

  IF unused: "This endpoint isn't called anywhere. Remove it (YAGNI)?"
  IF used:   implement properly
```

## Implementation Order

For multi-item feedback:

1. Clarify anything unclear FIRST
2. Then implement in order:
   - Blocking issues (breaks, security)
   - Simple fixes (typos, imports)
   - Complex fixes (refactoring, logic)
3. Test each fix individually
4. Verify no regressions

## Acknowledging Feedback

When feedback IS correct, acknowledge through action:

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

WRONG: "You're absolutely right!"
WRONG: "Great point!"
WRONG: "Thanks for catching that!"
```

When you pushed back and were wrong, correct factually and move on:

```
RIGHT: "You were right — I checked [X] and it does [Y]. Implementing now."
RIGHT: "Verified, you're correct. My understanding was wrong. Fixing."

WRONG: A long apology
WRONG: Defending why you pushed back
```

## Common Rationalizations

| Rationalization | Reality |
|---|---|
| "Agreeing keeps things friendly" | Friendliness that ships a wrong fix helps no one. Verify, then respond on the merits. |
| "The reviewer knows best, just do it" | Reviewers lack your full context too. A suggestion is a hypothesis to check, not a command. |
| "I'll implement all six at once to save time" | Untested batches hide which change broke what. One item, one test, every time. |
| "Pushing back looks defensive" | Pushback with evidence is engineering. Silent compliance with a wrong suggestion is the real failure. |
| "Saying thanks is just being polite" | Actions acknowledge feedback better than words. Show the fix, not the gratitude. |

## Red Flags

- "You're absolutely right!" / "Great point!" / "Thanks for catching that!"
- Implementing before verifying against the codebase
- Implementing multiple items without testing each
- Implementing partial feedback while some items are still unclear
- Pushing back with opinion ("I think...") instead of evidence
- Accepting a suggestion that breaks a passing test

## Verification

Before responding to feedback:

- [ ] Read all feedback completely without reacting
- [ ] Restated each requirement (or asked about unclear items)
- [ ] Verified each suggestion against the codebase

Before claiming done:

- [ ] Implemented one item at a time
- [ ] Tested each fix individually
- [ ] Confirmed no regressions
- [ ] Acknowledged correct feedback factually, pushed back with evidence where warranted

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [jagreehal](https://github.com/jagreehal)
- **Source:** [jagreehal/jagreehal-claude-skills](https://github.com/jagreehal/jagreehal-claude-skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-jagreehal-jagreehal-claude-skills-code-review-reception
- Seller: https://agentstack.voostack.com/s/jagreehal
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.