Hidden states help spot errors in ai generated code reliably
Introspective Uncertainty Estimation for LLM-Based Code Generation
Software EngineeringMachine Learning
Summary
Large language models can write code but often make subtle mistakes that look correct but cause errors. The authors studied whether the models’ own internal data—called hidden states—can signal if the code is likely right or wrong. They found that these hidden states do contain useful clues that help identify errors across different coding tasks and languages, especially when judging entire code responses. Pinpointing errors in specific lines is harder, but still possible when the overall code is known to be faulty. This could help developers focus on risky code and find bugs faster.
What this means in practice
- •For software developers: Identify risky generated code snippets for quicker manual review in coding workflows.
- •For quality assurance engineers: Prioritize lines likely to contain faults within faulty AI-generated code for targeted debugging.
Authors
Thomas Klassert
Abstract
Large Language Models (LLMs) are increasingly used for code generation but can produce fluent yet functionally incorrect outputs, which limits trust in their usage for practical software engineering workflows. This thesis investigates whether Introspective Uncertainty Estimation (IUE), based on internal hidden-state representations of LLMs, can reliably indicate correctness at the response and line levels for code generation tasks. The objective is to determine the extent to which hidden states encode information about functional code correctness and how this can be leveraged for practical risk assessment and fault localization. Methodologically, this thesis combines response-level evaluation on LiveCodeBench (LCB) and BigCodeBench (BCB) with an augmentation pipeline that derives token- and line-level labels from incorrect programs. In this setup, it compares static and dynamic response-level features, evaluates generalization across tasks, programming domains, and token positions, and studies line-level fault localization. The results show that hidden states contain a strong response-level correctness signal. Static single-token probes perform best, while more elaborate dynamic strategies yield no consistent gains. While generalization across tasks, domains, and token positions is feasible, setting-dependent degradation largely remains for real-world software projects. At a fine granularity, line-level prediction is substantially harder than response-level estimation. However, in a conditional localization setup with known-incorrect programs, Top-K point-of-failure ranking remains effective. Overall, the findings suggest that hidden states are a robust and informative resource for estimating functional code correctness, supporting a two-stage workflow that combines response-level risk screening with targeted line-level prioritization.