receiving-code-review

Clarify and verify code-review feedback before implementing changes.

68|6|Updated Apr 16, 2020
One-click install
npx skills add https://github.com/zenobi-us/dotfiles --skill receiving-code-review-zenobi-us
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: receiving-code-review
Source: https://github.com/zenobi-us/dotfiles/tree/main/devtools/files/opencode/skills/receiving-code-review
Command: npx skills add https://github.com/zenobi-us/dotfiles --skill receiving-code-review-zenobi-us

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solves? Receiving code review feedback can lead to performative agreement or blind implementation without proper technical evaluation, potentially introducing new issues or regressions.

Core Features & Use Cases

  • Technical Verification: Requires verifying feedback against codebase reality before implementing, ensuring technical correctness.
  • Clarification Protocol: Guides asking for clarification on unclear items to prevent partial understanding and incorrect implementation.
  • Reasoned Pushback: Provides strategies for technically sound pushback when suggestions are incorrect or conflict with architectural decisions.
  • Use Case: You've received code review feedback, but some suggestions seem unclear or might conflict with existing architecture. Use this Skill to systematically evaluate each item, clarify ambiguities, and implement changes only after technical verification, ensuring quality and preventing regressions.

Quick Start

Use the receiving-code-review skill to process feedback on your recent pull request, starting by reading all comments without reacting.

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?

Evaluate code review feedback by systematically reading all comments, understanding each suggestion against your codebase, verifying technical correctness, and assessing whether it aligns with your architecture before implementing. This prevents blind fixes and ensures quality.

What should I do when code review suggestions seem unclear or ambiguous?

When feedback is unclear, follow a clarification protocol: ask reviewers specific questions about ambiguous items, confirm your understanding of technical rationale, and verify suggestions against your actual codebase before proceeding. This prevents partial understanding and incorrect implementation.

How do I handle code review feedback that conflicts with existing architecture?

Evaluate conflicting feedback by verifying it against your architectural decisions and codebase patterns. If justified, provide technically sound pushback with specific reasons why the suggestion conflicts with existing design, or negotiate a resolution that maintains consistency.

Can I push back on code review suggestions if I disagree?

Yes. Provide reasoned pushback when suggestions are technically incorrect or conflict with architecture. Base your response on codebase reality and documented decisions, not preference, so reviewers understand your reasoning and can agree or escalate the decision.

What's the best way to prevent regressions when implementing code review changes?

Before implementing feedback, test proposed changes against your target codebase to verify correctness. After implementing, run test suites to catch regressions. This systematic verification ensures feedback improves code quality rather than introducing new issues.

When should I use a code review evaluation process instead of implementing feedback immediately?

Use systematic evaluation when feedback is unclear, technically questionable, or potentially conflicts with architecture. This process is essential in development workflows with complex pull requests or when reviewers may not have full codebase context.