receiving-code-review

Evaluate code review feedback against the actual codebase before implementing changes.

1|Updated Mar 20, 2026
One-click install
npx skills add https://github.com/greglamb/macos-name-tag-app --skill receiving-code-review-greglamb
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: receiving-code-review
Source: https://github.com/greglamb/macos-name-tag-app/tree/main/.claude/skills/receiving-code-review
Command: npx skills add https://github.com/greglamb/macos-name-tag-app --skill receiving-code-review-greglamb

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents blind implementation of code review feedback by requiring technical verification, clarification of ambiguous requests, and evidence-based decisions before changes are made.

Core Features & Use Cases

  • Structured Feedback Evaluation: Read, understand, verify, and technically assess each review comment against the actual codebase.
  • Constructive Pushback: Identify suggestions that are incorrect, unnecessary, incompatible, or inconsistent with project requirements.
  • Safe Implementation Workflow: Prioritize blocking issues, clarify unclear items, test changes individually, and verify that fixes do not introduce regressions.
  • Use Case: When an external reviewer requests a large refactor or a supposedly professional feature, use this Skill to check actual usage, apply YAGNI principles, and implement only technically justified changes.

Quick Start

Use the receiving-code-review skill to evaluate the attached code review feedback against the current codebase before implementing any suggestions.

Frequently Asked Questions about receiving-code-review

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I evaluate code review feedback before implementing changes?

Evaluating code review feedback requires reading, understanding, and technically assessing each comment against the actual codebase. You must verify suggestions, clarify ambiguous requests, and apply YAGNI principles to ensure only technically justified changes are implemented.

What is the best way to handle a code review requesting a large refactor?

Handling a large refactor request involves checking actual usage and applying YAGNI principles to determine necessity. You should technically verify the suggestions against the codebase, prioritize blocking issues, and implement only technically justified changes to avoid regressions.

How do I push back on incorrect code review suggestions?

Pushing back on incorrect code review suggestions means identifying feedback that is incorrect, unnecessary, or incompatible with project requirements. You must verify the technical claims against the codebase and request clarification for ambiguous items before making any changes.

How do I safely implement multi-item fixes from a pull request review?

Safely implementing multi-item fixes requires prioritizing blocking issues, clarifying unclear items, and testing changes individually. You must verify that each fix does not introduce regressions by conducting targeted testing and platform checks during incremental implementation.

When should I apply YAGNI to code review feedback?

Apply YAGNI to code review feedback when an external reviewer requests a supposedly professional feature or large refactor. Check actual usage in the codebase to determine if the suggestion is unnecessary before implementing only technically justified changes.

Does this approach work for evaluating ambiguous technical recommendations from external reviews?

Yes, evaluating ambiguous technical recommendations from external reviews requires technical verification and clarification of unclear items. You must assess each comment against the actual codebase to identify suggestions that are incompatible or inconsistent with project requirements.