Differential Review

Differential Review is a community skill for conducting structured code reviews on diffs and changesets, covering diff parsing, automated code quality checks, review comment generation, change risk assessment, and review workflow integration for pull request quality assurance.

What Is This?

Overview

Differential Review provides patterns for analyzing code changes systematically. It covers diff parsing that extracts added, modified, and deleted lines from unified diff format with file and function context, automated quality checks that apply linting rules, complexity metrics, and pattern detection to changed lines only, review comment generation that produces specific actionable feedback on potential issues in the changeset, change risk assessment that scores the likelihood of a change introducing bugs based on file history and complexity, and workflow integration that posts review findings as pull request comments with inline annotations. The skill enables teams to catch quality issues before code reaches the main branch.

Who Should Use This

This skill serves senior engineers conducting code reviews on large changesets, engineering teams establishing automated review quality gates, and DevOps teams integrating review automation into CI pipelines.

Why Use It?

Problems It Solves

Large diffs overwhelm reviewers causing them to miss issues in the volume of changes. Manual review quality varies depending on reviewer familiarity with the codebase and available time. Repetitive issues like style violations and missing null checks consume reviewer attention that should focus on logic. Risk assessment of changes is subjective without data on file change history and complexity.

Core Highlights

Diff parser extracts changed lines with surrounding context and function boundaries. Quality checker applies rules to changed code only avoiding noise from existing issues. Risk scorer evaluates change impact based on file history and cyclomatic complexity. Comment formatter produces inline review comments with severity and suggestion.

How to Use It?

Basic Usage

import re
from dataclasses\
  import dataclass

@dataclass
class DiffHunk:
  file: str
  start_line: int
  added_lines:\
    list[str]
  removed_lines:\
    list[str]

class DiffParser:
  def parse(
    self,
    diff_text: str
  ) -> list[DiffHunk]:
    hunks = []
    current_file = ''
    for line in diff_text\
        .split('\n'):
      if line.startswith(
          '+++ b/'):
        current_file =\
          line[6:]
      elif line.startswith(
          '@@ '):
        match = re.search(
          r'\+(\d+)',
          line)
        start = int(
          match.group(1))\
            if match else 1
        hunks.append(
          DiffHunk(
            file=\
              current_file,
            start_line=\
              start,
            added_lines=[],
            removed_lines=\
              []))
      elif hunks:
        if line\
            .startswith('+'):
          hunks[-1]\
            .added_lines\
            .append(
              line[1:])
        elif line\
            .startswith('-'):
          hunks[-1]\
            .removed_lines\
            .append(
              line[1:])
    return hunks

Real-World Examples

class RiskScorer:
  def __init__(self):
    self.weights = {
      'lines_changed':
        0.3,
      'files_changed':
        0.2,
      'complexity': 0.3,
      'test_coverage':
        0.2}

  def score(
    self,
    hunks:\
      list[DiffHunk],
    file_history: dict
  ) -> dict:
    total_added = sum(
      len(h.added_lines)
      for h in hunks)
    files = set(
      h.file
      for h in hunks)
    line_risk = min(
      total_added
      / 100, 1.0)
    file_risk = min(
      len(files)
      / 10, 1.0)
    risk = (
      line_risk * self
        .weights[
          'lines_changed']
      + file_risk * self
        .weights[
          'files_changed'])
    level = (
      'high' if
        risk > 0.7
      else 'medium' if
        risk > 0.4
      else 'low')
    return {
      'score':
        round(risk, 2),
      'level': level,
      'files_changed':
        len(files),
      'lines_added':
        total_added}

Advanced Tips

Focus automated checks on changed lines only rather than the entire file to avoid generating noise from pre-existing issues that are not part of the current review. Weight risk scores using file change frequency from version control history since files changed often are more likely to contain bugs. Group review comments by severity so reviewers can address critical issues first.

When to Use It?

Use Cases

Automate code quality checks on pull request diffs to catch issues before human review. Score change risk for large pull requests to prioritize reviewer attention on high-risk areas. Generate structured review comments with inline annotations for CI pipeline integration.

Related Topics

Code review, diff analysis, static analysis, pull requests, change risk, and CI integration.

Important Notes

Requirements

Git or compatible version control system for diff generation. Python or equivalent runtime for diff parsing and analysis logic. CI platform integration for automated comment posting on pull requests.

Usage Recommendations

Do: scope automated checks to changed lines to keep feedback relevant and actionable. Include file change history in risk assessment since frequently modified files correlate with higher defect rates. Separate style issues from logic issues in review output for clearer prioritization.

Don't: block merges on style-only findings which frustrates developers and slows delivery. Generate review comments without clear remediation guidance which leaves authors unsure how to fix the issue. Run full repository analysis on every pull request which wastes compute and produces irrelevant findings.

Limitations

Automated diff analysis detects surface-level patterns but cannot evaluate business logic correctness or architectural appropriateness. Risk scoring models depend on historical data quality and may not reflect current codebase risk accurately. Review comment generation cannot replace human judgement for complex design decisions and trade-off evaluations.