requesting-code-review

Name: requesting-code-review
Availability: InStock
Author: lifangda

Dispatch a code-reviewer subagent to assess code changes against requirements.

43|13|Updated Oct 10, 2025

Search Tags:#git #quality assurance #code review #development workflow #AI assistant #software quality #subagent

Ready to run

npx skills add https://github.com/lifangda/claude-plugins --skill requesting-code-review-lifangda

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: requesting-code-review
Source: https://github.com/lifangda/claude-plugins/tree/main/cli-tool/skills-library/collaboration/requesting-code-review
Command: npx skills add https://github.com/lifangda/claude-plugins --skill requesting-code-review-lifangda

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill streamlines the code review process by dispatching an AI subagent to rigorously evaluate code changes against requirements and best practices, catching issues early and ensuring production readiness.

Core Features & Use Cases

Automated Code Evaluation: Dispatches a code-reviewer subagent to analyze code quality, architecture, testing, and adherence to requirements.
Early Issue Detection: Integrates review into development workflows (e.g., after each task) to prevent issues from compounding.
Structured Feedback: Provides categorized feedback (Critical, Important, Minor) with specific file/line references and suggested fixes.
Use Case: After implementing a new feature, use this skill to trigger an AI code review, providing the git diff range and the original plan. The AI will then provide a detailed assessment, highlighting any bugs or architectural concerns.

Quick Start

I've just completed a new feature. Dispatch the code-reviewer subagent to review my changes against the plan.

Frequently Asked Questions about requesting-code-review

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

FAQPage Schema

How do I automate code reviews for my git changes?▼

Automate code reviews by dispatching a dedicated code-review subagent to analyze your changes. Provide the git diff range (BASE_SHA to HEAD_SHA), your implementation details, and the original plan or requirements. The subagent evaluates code quality, architecture, testing, and requirement adherence, returning categorized feedback with a production-readiness recommendation.

When should I run code reviews in my development workflow?▼

Run code reviews after completing features, after each development task, or before merging to main. Early reviews catch issues before they compound, prevent bugs from reaching production, and ensure alignment with plans. Integrate reviews into your workflow as a quality checkpoint between implementation and merge.

What does a code review assessment include?▼

A code review assessment provides structured feedback organized by severity (Critical, Important, Minor), specific file and line references, suggested fixes, identified strengths, and a production-readiness verdict. This categorized output helps you prioritize issues and make informed merge decisions.

Can I use code reviews across different subagent-driven tasks?▼

Yes, code reviews apply across any subagent-driven development workflow. Whether you're building features, refactoring, or integrating components, dispatch the code-reviewer subagent with your changes, plan, and implementation summary. The review process remains consistent regardless of task type.

What input does the code-review subagent need?▼

Provide WHAT_WAS_IMPLEMENTED (your code changes), PLAN_OR_REQUIREMENTS (original specifications), BASE_SHA and HEAD_SHA (git commit range), and DESCRIPTION (summary of changes). These inputs enable the subagent to evaluate whether your implementation meets requirements and follows best practices.

How does code review catch production issues early?▼

Code review analyzes implementation against requirements and best practices before merge, identifying bugs, architectural concerns, and quality gaps. Early detection prevents issues from reaching production, reduces debugging effort, and ensures code meets functional and technical standards.