Code Review

What Is Code Review?

Code review is a structured process in software development where code contributions are systematically examined and critiqued before integration or release. The Claude Code skill “Code Review” formalizes this process, emphasizing technical rigor, evidence-based evaluation, and verification over mere performative agreement. This approach ensures that feedback is not only acknowledged but critically analyzed and acted upon with due diligence, minimizing errors and improving code quality.

The skill outlines three core practices:

1. Receiving feedback with a focus on technical accuracy, not just agreement.
2. Requesting systematic reviews through a dedicated code-reviewer subagent.
3. Enforcing verification gates that require objective evidence before claiming task completion or success.

These practices are essential for subagent-driven development workflows, managing pull requests, and proactively preventing false claims of completion.

Why Use Code Review?

Implementing effective code review practices is fundamental for several reasons:

• Quality Assurance: Catching bugs, logical flaws, and architectural issues before code reaches production reduces future maintenance costs.
• Knowledge Sharing: Reviews provide a platform for team members to learn from each other, spread domain knowledge, and maintain consistent coding standards.
• Accountability: Evidence-based verification and systematic feedback ensure that changes are justified and traceable.
• Reduced Risk: By prioritizing technical correctness and requiring proof of completion, the process helps prevent regressions, security vulnerabilities, and incomplete features.

For example, consider a pull request introducing a new authentication system. Without thorough code review, a subtle logic error could allow unauthorized access. The Claude Code Review skill mandates that all feedback be technically justified and that completion is only claimed with demonstrable evidence—such as passing security test cases.

How to Get Started

To leverage the Claude Code skill “Code Review” in your workflow:

1. Integrate the Skill: Ensure the code-review skill is available in your development environment or automation pipeline, referencing the implementation at claudekit-skills/code-review.
2. Trigger on Feedback: Any time you receive code review comments—especially if they are unclear, technically questionable, or from reviewers lacking full context—invoke the skill’s evaluation protocols.
3. Request Reviews Systematically: Use the code-reviewer subagent to request peer or automated reviews for all significant changes or feature completions.
4. Establish Verification Gates: Before claiming a task or feature is complete, require concrete evidence (e.g., test results, demo output, or analysis reports) as per the skill’s verification gate protocols.

Example:

## Assume a function to calculate user discounts
def get_discount(user):
    if user.is_vip:
        return 0.2
    return 0.05

If a reviewer suggests changing the VIP discount rate, the skill would require:

• A technical justification for the change
• Evidence that test cases covering both VIP and non-VIP users have been updated and pass successfully

Key Features

The Claude Code Review skill introduces several key features to standardize and enhance code review:

• Technical Rigor in Feedback: All feedback must be supported by sound reasoning and, where possible, empirical evidence. Disagreements are resolved through technical discussion, not deference.
• Systematic Review Requests: Reviews can be delegated to a code-reviewer subagent, ensuring impartial and consistent evaluation across the codebase.
• Verification Gates: No code is marked as complete without explicit evidence—such as passing unit tests, code coverage metrics, or successful deployment artifacts.
• Prioritization and Clarification Protocols: When multiple or ambiguous review items arise, the skill provides structured methods to prioritize issues and clarify intent with reviewers.
• Conflict Resolution: If review suggestions contradict existing decisions or lack context, the skill prompts for further discussion and alignment before implementation.

Example:

## Verification gate:

Ensure test passes before merging
def test_get_discount_vip():
    user = User(is_vip=True)
    assert get_discount(user) == 0.2

Evidence of this test passing must be presented before the feature is considered complete.

Best Practices

To maximize the value of the Code Review skill, follow these best practices:

• Never Assume: Do not implement feedback without verifying its technical validity.
• Request Clarification: When review comments are unclear, ask for specific details or examples.
• Present Evidence: Attach relevant test results, code snippets, or logs to support claims of completion.
• Prioritize Issues: Address critical bugs and architectural concerns before minor stylistic suggestions.
• Document Decisions: Record the reasoning behind major changes and how review feedback was addressed.

Code Example:

## Responding to a review comment about edge cases
## Reviewer: "What happens if user is None?"
def get_discount(user):
    if user is None:
        raise ValueError("User cannot be None")
    if user.is_vip:
        return 0.2
    return 0.05
## Attach test evidence for user=None scenario

Important Notes

• Technical Correctness First: Social comfort or authority should never override technical rigor.
• Use the Skill Proactively: Apply the skill not only when receiving feedback, but also before making completion or success claims.
• Verification is Mandatory: No feature should be marked as done without concrete, reviewable evidence.
• Subagent Alignment: For teams using subagent-driven development, this skill is essential for ensuring reliable, traceable progress and preventing premature success claims.
• Continuous Improvement: Regularly update your code review protocols based on lessons learned and evolving project requirements.

By adhering to these guidelines and leveraging the Claude Code skill “Code Review,” teams can foster a culture of continuous improvement, technical excellence, and reliable software delivery.