home / skills / doanchienthangdev / omgkit / requesting-code-review

requesting-code-review skill

/plugin/skills/methodology/requesting-code-review

This skill helps you craft effective code review requests by guiding self-review, clear PR descriptions, proper reviewer selection, and timely submission.

npx playbooks add skill doanchienthangdev/omgkit --skill requesting-code-review

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.4 KB
---
name: requesting-code-reviews
description: AI agent requests effective code reviews through proper preparation, clear descriptions, and appropriate reviewer selection. Use when creating PRs, requesting feedback, or submitting for review.
---

# Requesting Code Reviews

## Quick Start

1. **Self-Review** - Review your own diff first, catch obvious issues
2. **Prepare Code** - Tests pass, no debug code, documentation updated
3. **Write Description** - Clear summary, changes list, testing info, screenshots
4. **Select Reviewers** - Match expertise to changes, respect workload
5. **Time Appropriately** - Early week, morning hours, avoid Fridays

## Features

| Feature | Description | Guide |
|---------|-------------|-------|
| Self-Review | Catch issues before requesting | Check debug code, TODOs, test coverage |
| PR Description | Guide reviewers effectively | Summary, changes, testing, attention areas |
| Reviewer Selection | Match expertise to needs | Code owner, domain expert, security reviewer |
| PR Sizing | Optimal size for review quality | <400 lines ideal, split larger PRs |
| Timing | When to request reviews | Morning, early week, check availability |
| Reviewer Guidance | Help reviewers focus | Key areas, skip suggestions, questions |

## Common Patterns

```
# PR Description Template
## Summary
[What changed and why - 2-3 sentences]
Resolves #123

## Changes
- [Bullet point each significant change]

## Testing
### Automated Tests
- [x] Unit tests added/updated
- [x] Integration tests pass

### Manual Testing
1. [Step to verify]
2. [Expected result]

## Screenshots
[For UI changes]

## Areas Needing Review
- Security: [specific file/concern]
- Performance: [specific concern]

## Checklist
- [x] Self-review completed
- [x] Tests pass locally
- [x] Documentation updated
```

```
# PR Size Guide
| Size | Lines | Review Time | Recommendation |
|------|-------|-------------|----------------|
| Small | <100 | 15-30 min | Ideal for quality review |
| Medium | <400 | 30-60 min | Acceptable |
| Large | <800 | 1-2 hours | Consider splitting |
| Too Large | 800+ | 2+ hours | Split required |

# Reviewer Selection
1. Code owner - maintains affected area
2. Domain expert - knows the technology
3. Security - for auth/crypto changes
4. Architecture - for design changes

Max reviewers: 4 (too many = diffused responsibility)
```

```
# Self-Review Checklist
[ ] No console.log/debug statements
[ ] No commented-out code
[ ] No hardcoded values (should be config)
[ ] Error handling appropriate
[ ] All tests pass
[ ] New code has tests
[ ] Complex logic has comments
[ ] Commit messages clear
[ ] Rebased on latest main
```

## Best Practices

| Do | Avoid |
|----|-------|
| Self-review first | Submitting PRs without testing |
| Keep PRs small (<400 lines) | Creating massive PRs |
| Write clear descriptions | Leaving descriptions empty |
| Highlight key review areas | Expecting reviewers to find everything |
| Choose reviewers wisely | Overloading single reviewers |
| Be responsive to feedback | Ignoring reviewer availability |
| Include screenshots for UI | Rushing reviewers |
| Test thoroughly first | Wasting reviewer time on broken code |

## Related Skills

- `receiving-code-reviews` - Handle feedback professionally
- `finishing-development-branches` - Complete PR preparation
- `verifying-before-completion` - Pre-submission verification
- `writing-plans` - Plan review-ready deliverables

Overview

This skill helps you request effective code reviews by preparing your changes, writing clear pull request descriptions, and choosing the right reviewers. It provides concrete checklists and templates to reduce back-and-forth and speed up review cycles. Use it to increase review quality and shorten merge time.

How this skill works

You follow a step-by-step flow: self-review your diff, ensure tests and docs are up to date, and craft a focused PR description that highlights what changed and what needs attention. The skill advises optimal PR sizing, reviewer selection based on ownership and domain expertise, and timing recommendations to respect reviewer availability. Templates and checklists make each request consistent and actionable.

When to use it

  • When opening a new pull request
  • When requesting feedback on a feature or bugfix
  • When preparing a release or refactor for review
  • When PR size or scope may need reviewer guidance
  • When changes touch security, performance, or architecture areas

Best practices

  • Self-review before requesting—remove debug code, commented blocks, and obvious issues
  • Keep PRs small (ideally <400 lines) or split larger work into multiple PRs
  • Write a concise PR summary, list changes, include testing steps and screenshots for UI work
  • Select 1–3 reviewers: code owner, domain expert, and security/architecture as needed
  • Time requests thoughtfully—early in the week and morning hours; check reviewer workload

Example use cases

  • Submitting a bugfix PR: include failing scenario, tests added, and targeted reviewer who owns the module
  • Requesting review for a new feature: attach manual verification steps and highlight areas needing design feedback
  • Refactor PR: break into smaller commits, point reviewers to risky changes, and include performance notes
  • Security-sensitive change: add a security reviewer and call out files with auth/crypto logic
  • Large migration: split into incremental PRs and assign reviewers for each phase

FAQ

How many reviewers should I add?

Aim for 1–3 reviewers: a code owner, a domain expert if different, and a security or architecture reviewer only when needed. More reviewers can dilute responsibility.

What belongs in a PR description?

Include a 2–3 sentence summary, a bullet list of changes, automated and manual testing steps, screenshots if relevant, areas needing review, and a short checklist confirming self-review and tests.