When a large language model writes you a paragraph and gets one word slightly wrong, the paragraph is usually still fine. When an LLM writes you a Python function and gets one token wrong — a misplaced bracket, a flipped comparison, an off-by-one — the whole program can silently break or, worse, return a plausible-looking answer that's subtly incorrect. This is the problem the authors zero in on.

The field has a tool called uncertainty estimation (UE): ways of asking a model "how confident are you, really?" so a human or downstream system can decide whether to trust the output, ask a reviewer, or try again. The catch is that almost all existing UE techniques were designed for natural-language generation and were quietly carried over to code. The authors argue this is a category error, because code differs from prose in three important ways:

• Fragility: a single wrong token can break the entire program, so averaging confidence across all tokens dilutes the signal from the few that actually matter.
• Structure: code has rigid syntax (brackets, indentation, types). A model that's uncertain about a variable name is in very different trouble than one uncertain about a comparison operator.
• Verifiability: unlike prose, code can be parsed, type-checked, and executed. There are cheap oracles available that NL generation simply doesn't have.

Rather than treating a generated program as a flat sequence of tokens, the paper proposes weighting uncertainty by where it appears in the code's structure — uncertainty inside a critical logical expression matters more than uncertainty in a comment or variable name. They also lean on what the code itself can tell you (does it parse? does it type-check?) to calibrate the confidence score, instead of relying purely on the model's internal probabilities.

The practical upshot is selective prediction: a system that knows when to hand off to a human reviewer, when to retry, and when to just ship the answer. In agentic coding workflows — where one bad function call cascades into broken downstream tool use — this kind of triage is the difference between an assistant that's helpful and one that's quietly burning time and trust.