Technical Summary: Explaining Risk of Code Changes using LLM-Based Prediction Models

Problem Statement

In large-scale software development, Just-in-Time (JIT) defect prediction systems, such as the Diff Risk Score (DRS), are used to predict the likelihood of a code change (diff) causing a service outage. While traditional models like logistic regression offer some explainability through feature coefficients, they struggle to utilize the rich textual content of code changes. Conversely, Large Language Models (LLMs) have demonstrated superior accuracy in risk prediction but operate as "black boxes," providing only a risk score without actionable justification.

This lack of explainability creates significant barriers to adoption: engineers cannot easily determine why a diff is flagged, leading to reduced trust, skepticism, and difficulty in narrowing down inspection efforts. Without clear guidance, high-risk warnings are often ignored, or engineers are forced to manually scan entire diffs, compromising productivity. The core challenge is to make LLM-based risk predictions actionable by identifying specific portions of a code change that contribute most to the predicted risk, without introducing hallucinations or excessive latency.

Methodology

The authors propose a pragmatic approach to explainability that leverages the internal attention mechanisms of an LLM during standard inference. The methodology involves three primary stages:

1. LLM-Based Risk Prediction:

   • A pre-trained LLM (specifically Llama3-70B, instruction-fine-tuned on historical diffs) is used to classify whether a diff could cause an outage.
   • The model receives a prompt containing the diff content and is instructed to generate a single-token response (0 or 1).
   • The risk score is derived from the logits of this output token.

2. Attention Extraction and Aggregation:

   • During inference, the model generates an attention tensor representing the correlation between the output token and the input tokens.
   • These attention weights are pooled across attention heads to create a token-level importance vector.
   • The authors explicitly state they do not claim causal faithfulness between attention and reasoning; rather, attention serves as a practical proxy signal to highlight relevant code regions.

3. Hierarchical Token Grouping and Mapping:

   • To make token-level weights interpretable for developers, the system maps them back to standard code review units: Lines, Hunks (contiguous blocks of changes), and Files.
   • A four-level hierarchy is constructed:
     • Token Reconstitution: Subword tokens (e.g., from SentencePiece or Tiktoken) are merged back into whitespace-delimited tokens.
     • Structure Recovery: Newline tokens and unified-diff headers (@@ ... @@) are used to reconstruct the file and hunk structure.
     • Score Aggregation: Attention scores are aggregated bottom-up. For leaf tokens, scores are averaged. For interior nodes (lines, hunks, files), specific aggregation functions are applied. Notably, at the hunk level, a top-$k$ sum is used to capture concentrated signals while bounding the influence of large hunks.
   • Pruning: To reduce noise, token scores within test files (identified via regex patterns) are nullified, as test changes are rarely the root cause of outages.

4. Output:

   • The system presents the top-$K$ highest-scoring units (e.g., top-2 hunks) to the developer within the code review UI as a "review budget," directing attention to the most suspicious regions.

Key Contributions

• Pragmatic Highlighting Signal: The paper introduces a method to convert LLM attention weights into actionable code highlights (lines, hunks, files) without requiring additional model training or generating potentially hallucinated natural language explanations.
• Hierarchical Aggregation Framework: A novel pipeline that reconstitutes subword tokens and recursively aggregates attention scores across file, hunk, and line granularities, accommodating different tokenizer behaviors.
• Industrial Validation: The approach is evaluated in a large-scale industrial context (FAANGCompany) using a manually curated Outage Root Cause (O-RC) dataset, where domain experts identified the specific lines responsible for real-world outages.
• Scalability: Since attention is computed as a byproduct of standard inference, the method adds minimal latency and is feasible for high-throughput code review workflows.

Experimental Results

The study evaluated the effectiveness of the highlighting method using the O-RC dataset, measuring Coverage (the percentage of diffs where the highlighted units contain the actual root-cause lines) and Average Review Percent (ARP) (the percentage of total changed lines a developer must review).

• Granularity Trade-offs:
  • Line-level: Highlighting the top-30 lines achieved 53.85% coverage but required reviewing 22.8% of the diff.
  • File-level: Highlighting the top-3 files achieved 92.30% coverage but required reviewing 78.61% of the diff, which is often too coarse for actionable debugging.
  • Hunk-level: Highlighting the top-2 hunks achieved 53.85% coverage while requiring developers to review only 26.28% of the changed lines on average.
• Optimal Configuration: The authors conclude that hunk-level highlighting (top-2) offers the best balance between coverage and developer effort. It aligns with how engineers naturally review diffs (inspecting hunks) and avoids the context-switching overhead of scattered line highlights or the excessive volume of file-level highlights.
• User Feedback: Early qualitative feedback from 55 users (48 negative, 7 positive) highlighted specific failure modes, such as highlighting test files (despite filtering) and boilerplate code, or directional ambiguity where attention might indicate low risk rather than high risk.

Significance and Claims

The paper positions this work as a preliminary study aimed at bridging the gap between high-accuracy LLM predictions and the need for engineer trust and actionability.

• Actionability: The primary claim is that aggregated attention provides a low-latency, scalable signal that narrows inspection to a small number of code regions, making JIT defect predictions actionable for professional engineers.
• Improvement over Baseline: The approach measurably improves upon the current production baseline of "no highlighting," where engineers receive a risk score without context.
• Trust and Adoption: By providing a visual guide to where to look, the method aims to increase trust in the DRS model and help engineers mitigate risks associated with their changes.
• Modesty: The authors explicitly acknowledge limitations, including the potential for attention weights to be influenced by prompt structure rather than semantics, the incompleteness of test-file filtering, and the fact that the study represents a snapshot in time. They do not claim that attention equals causal reasoning, but rather that it serves as a useful heuristic for prioritizing human review.

The work demonstrates that in a high-stakes, large-scale environment, simple, attention-based highlighting can effectively support complex LLM-based risk models, enabling their broader deployment in industry settings.