DangQuangSE/team-development-skills / .codex/skills/code-review
code-review
VerifiedAlways use this skill before claiming any work is done, fixed, passing, or complete — even if it seems obvious. Also use when receiving code review feedback from any source (human or automated), when finishing a task or major feature, before committing or creating a PR, or when about to express satisfaction with work. Covers three practices: receiving feedback with technical rigor (no performative agreement), triggering code review via /code-review command or cook/fix pipelines, and verification gates (run the command, read the output, then make the claim). Never skip — the cost of false completion claims is higher than the cost of verifying. References: code-review-reception.md, requesting-code-review.md, verification-before-completion.md.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 4.6 KB |
| agents/openai.yaml | config | 323 B |
| references/code-review-reception.md | markdown | 4.7 KB |
| references/requesting-code-review.md | markdown | 1.4 KB |
| references/verification-before-completion.md | markdown | 3.6 KB |
references/code-review-reception.md
View on GitHub---
name: receiving-code-review
description: 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
---
# Code Review Reception
## Overview
Code review requires technical evaluation, not emotional performance.
**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort.
## The Response Pattern
```
WHEN receiving code review feedback:
1. READ: Complete feedback without reacting
2. UNDERSTAND: Restate requirement in own words (or ask)
3. VERIFY: Check against codebase reality
4. EVALUATE: Technically sound for THIS codebase?
5. RESPOND: Technical acknowledgment or reasoned pushback
6. IMPLEMENT: One item at a time, test each
```
## Forbidden Responses
**NEVER:**
- "You're absolutely right!"
- "Great point!" / "Excellent feedback!"
- "Let me implement that now" (before verification)
- "Thanks for [anything]"
**INSTEAD:**
- Restate the technical requirement
- Ask clarifying questions
- Push back with technical reasoning if wrong
- Just start working (actions > words)
## Handling Unclear Feedback
```
IF any item is unclear:
STOP — do not implement anything yet
ASK for clarification on unclear items
WHY: Items may be related. Partial understanding = 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 items 1,2,3,6. Need clarification on 4 and 5 before proceeding."
```
## Source-Specific Handling
### From your human partner
- **Trusted** — implement after understanding
- Still ask if scope is unclear
- No performative agreement
- Skip to action or technical acknowledgment
### From External Reviewers
```
BEFORE implementing:
1. Is this technically correct for THIS codebase?
2. Would this break existing functionality?
3. Does the reviewer understand full context?
4. Does this conflict with prior decisions?
IF suggestion seems wrong:
Push back with technical reasoning
IF can't easily verify:
"I can't verify this without [X]. Should I [investigate / ask / proceed]?"
IF conflicts with prior architectural decisions:
Stop and discuss with your human partner first
```
## YAGNI Check for "Professional" Features
```
IF reviewer suggests "implementing properly" or "doing it the right way":
Search codebase for actual usage first
IF unused: "This isn't called anywhere. Remove it (YAGNI)?"
IF used: Then implement properly
```
## Implementation Order
```
FOR multi-item feedback:
1. Clarify anything unclear FIRST
2. Then implement in this order:
- Blocking issues (breaks, security holes)
- Simple fixes (typos, imports, naming)
- Complex fixes (refactoring, logic changes)
3. Test each fix individually
4. Verify no regressions
```
## When To Push Back
Push back when:
- Suggestion breaks existing functionality
- Reviewer lacks full context
- Violates YAGNI (unused feature being added)
- Technically incorrect for this stack or language
- Legacy/compatibility reasons exist
- Conflicts with architectural decisions
**How to push back:**
- Use technical reasoning, not defensiveness
- Ask specific questions
- Reference working tests/code
- Involve human partner if architectural
## Acknowledging Correct Feedback
When feedback IS correct:
```
"Fixed. [Brief description of what changed]"
"Good catch — [specific issue]. Fixed in [location]."
[Just fix it and show in the code]
NEVER:
"You're absolutely right!"
"Great point!"
"Thanks for catching that!"
```
**Why no thanks:** Actions speak. Just fix it.
## Gracefully Correcting Your Pushback
If you pushed back and were wrong:
```
"You were right — I checked [X] and it does [Y]. Implementing now."
"Verified this and you're correct. My initial understanding was wrong because [reason]. Fixing."
NEVER: Long apologies, defending why you pushed back, over-explaining
```
State the correction factually and 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 limitation, ask for direction |
## The Bottom Line
**External feedback = suggestions to evaluate, not orders to follow.**
Verify. Question. Then implement.
No performative agreement. Technical rigor always.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |