receiving-code-review

Validate code review feedback against the codebase before implementing changes.

Updated Oct 22, 2025
One-click install
npx skills add https://github.com/franroa/chezmoi --skill receiving-code-review-franroa
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: receiving-code-review
Source: https://github.com/franroa/chezmoi/tree/main/dot_opencode/superpowers/skills/receiving-code-review
Command: npx skills add https://github.com/franroa/chezmoi --skill receiving-code-review-franroa

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill ensures that code review feedback is processed with technical rigor, not performative agreement. It prevents blind implementation of suggestions, ensuring that changes are technically sound, verified against the codebase, and align with architectural decisions.

Core Features & Use Cases

  • Verify Before Implement: Mandates a process of reading, understanding, verifying, and evaluating feedback before implementing any suggestions.
  • Technical Pushback: Guides you on when and how to push back on technically questionable feedback, using reasoned arguments rather than defensiveness.
  • YAGNI Check: Requires checking if suggested "professional" features are actually used in the codebase before implementing them.
  • Use Case: When you receive code review feedback, use this Skill to process it effectively. For example, if a reviewer suggests removing "legacy code," this Skill will guide you to verify if it's truly unused or if it's needed for backward compatibility before making the change.

Quick Start

Announce skill usage

I'm using the receiving-code-review skill to process this feedback.

Example: Handling unclear feedback

If items 4 and 5 are unclear:

"I understand items 1,2,3,6. Need clarification on 4 and 5 before proceeding."

Frequently Asked Questions about receiving-code-review

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

FAQPage Schema
How do I process code review feedback effectively without implementing everything blindly?

Process code review feedback through a structured six-step protocol: READ the feedback carefully, UNDERSTAND what's being suggested, VERIFY it against your codebase, EVALUATE its technical correctness, RESPOND with clarification if needed, and IMPLEMENT only validated changes. This ensures changes are technically sound rather than performative.

When should I push back on code review suggestions?

Push back on code review feedback when it's technically questionable or unsupported by codebase usage. Before rejecting a suggestion—like removing 'legacy code'—verify whether the code is actually unused or serves backward compatibility needs, then respond with reasoned technical arguments rather than defensiveness.

How do I handle unclear or ambiguous code review comments?

When code review feedback is unclear, explicitly state which items you understand and request clarification on specific points before proceeding. This prevents misinterpretation and ensures you're addressing the reviewer's actual intent, not assumptions about their feedback.

What's the best approach to validating code review suggestions against the codebase?

Verify suggested changes by checking actual codebase usage patterns. Apply a YAGNI check to confirm whether 'professional' features or refactorings are genuinely needed—not just theoretically sound—before implementing, ensuring changes deliver real value rather than technical debt.

How do I implement code review feedback incrementally and testably?

Implement code review changes one item at a time with testable validation for each change. This approach isolates which modifications improve code quality, prevents bundling unrelated suggestions, and allows rollback of individual changes if problems emerge.

Why should I verify feedback before making changes to pull requests?

Verifying code review feedback prevents blind implementation of technically unsound suggestions. This verification step—checking against architectural decisions, codebase patterns, and actual usage—ensures changes maintain quality standards and don't introduce regressions or unnecessary refactoring.