Incremental Diff Ingestion

Incremental Git Diff Ingestion (Delta-Only Code Review)

Overview

When tasked with reviewing a Pull Request, auditing recent changes, or generating release notes ("Review the latest commit for potential security regressions"), unoptimized agents dump the full contents of all modified files into the prompt context.

If a developer changed 15 lines across 8 large backend files, ingesting the full files burns 35,000+ tokens on unchanged legacy code. The model’s attention becomes diluted across thousands of lines of irrelevant code rather than focusing sharply on the modified logic.

The Incremental Git Diff Ingestion Protocol feeds strictly the Unified Diff Delta (git diff -U3), exposing the exact additions (+) and deletions (-) with 3 lines of surrounding context - reducing context consumption by 90%.

Full-File Ingestion vs. Incremental Unified Diff

┌─────────────────────────────────────────────────────────────┐
│                 Code Review Token Economics                 │
│                                                             │
│  Full File Ingestion (8 Files - 32,000 Tokens):             │
│  • Reads all 8 full files (4,000 lines of unchanged code)   │
│  • High token cost, slow turn latency (12s)                 │
│  • Review gets distracted commenting on old untouched code  │
│                                                             │
│  Incremental Unified Diff (`git diff -U3` - 450 Tokens):    │
│  diff --git a/src/auth.ts b/src/auth.ts                     │
│  @@ -42,6 +42,7 @@ export function verifyToken(token: string) │
│     const payload = jwt.verify(token, SECRET);              │
│  +  if (await isRevoked(payload.jti)) return null;          │
│     return payload;                                         │
│  ↳ 450 clean tokens (98.6% Reduction!), 100% Focus on Delta │
└─────────────────────────────────────────────────────────────┘

The Master Git Diff Commands

Use these precise CLI commands in agent execution pipelines:

Production Python Diff-Review Pipeline

import subprocess
from pathlib import Path
from typing import Dict, Any

def get_compact_pr_diff(base_branch: str = "main", max_diff_lines: int = 500) -> str:
    """Extracts a high-density unified diff bounded to active changes."""
    # 1. First check the stat summary
    stat_res = subprocess.run(
        ["git", "diff", f"{base_branch}...HEAD", "--stat"],
        capture_output=True, text=True
    )
    
    # 2. Extract unified diff with 2 context lines (compact)
    diff_res = subprocess.run(
        ["git", "diff", f"{base_branch}...HEAD", "-U2", "--no-color"],
        capture_output=True, text=True
    )
    
    diff_lines = diff_res.stdout.splitlines()
    if len(diff_lines) > max_diff_lines:
        truncated_diff = "\n".join(diff_lines[:max_diff_lines])
        return (
            f"=== MODIFIED FILES STAT ===\n{stat_res.stdout.strip()}\n\n"
            f"=== UNIFIED DIFF (Truncated to {max_diff_lines} lines) ===\n{truncated_diff}\n"
            f"\n[... {len(diff_lines) - max_diff_lines} additional diff lines omitted ...]"
        )
        
    return f"=== MODIFIED FILES STAT ===\n{stat_res.stdout.strip()}\n\n=== UNIFIED DIFF ===\n{diff_res.stdout.strip()}"

Benchmark Comparison

Auditing a Pull Request modifying 25 lines across 6 enterprise service modules:

Agent Operational Directive

MANDATORY: For PR audits, commit reviews, and pre-merge validation, agents must ingest git diff -U2 or git diff -U3 rather than whole files. Inspect full files only if deep caller graph tracing is strictly necessary.