The study examines how large language models (LLMs) repair code after runtime or API migrations, revealing that many repaired procedures run without errors yet produce incorrect results. Across 73 tasks and 60 documented changes in CPython, Node.js, and SQLite, the authors found that typical test inputs allowed 41% of wrong repairs to pass, while targeted edge inputs reduced this to 6–7%. Even with additional hard distractors and blind model writers, a significant fraction of incorrect repairs still passed the preregistered tests.
After a runtime or API migration, an LLM-repaired procedure can run cleanly yet return wrong results, and a release check on typical test inputs ships it. We report a preregistered study of 73 tasks c...
The paper "Poison Valleys: Diagnosing Path-Dependent Failure in LLM Code Repair" investigates why large language model (LLM) code‑repair agents sometimes produce incorrect patches. By analyzing 1,844 model requests on two synthetic Python tasks—PersistQueue and Dijkstra—the authors trace how misconceptions in a model’s hypothesis or implementation plan lead to specific software obligation violations. They find that shifting a misconception from hypothesis to plan increases failure rates by roughly 30% for both tasks, revealing distinct, model‑dependent failure patterns linked to upstream misunderstandings.
arXiv:2609.05881v1 Announce Type: cross Abstract: Developers increasingly run large language models locally by pulling quantized GGUF artifacts from public registries, yet nothing in the distribution...
The paper investigates hallucination in large language model–based automated program repair (APR). It defines hallucination as producing patches or intermediate artifacts that are not grounded in available repair evidence, and analyzes it across final patches and intermediate tasks such as triggering test case identification, line coverage prediction, and additional test case generation. Experiments on 832 Defects4J bugs show that only 21.0%–55.9% of patches pass the developer test suite, with 72.7% of sampled repairs exhibiting hallucinations, often due to incorrect causal localization or repair strategies.
The paper reports a preregistered audit of language‑model judges used as measurement instruments, revealing that the assumption that a model’s responses remain stable over time is invalid. Across nearly 53,000 audited requests, repeat rankings and byte‑identical replays fell far below required reliability thresholds, with three identified mechanisms—label‑to‑meaning bias, candidate gaps below the noise floor, and input permutation noise—explaining the discrepancy. The study proposes a three‑level snapshot‑identity framework, eight design rules, and a reporting checklist to prevent such reliability failures in future evaluations.
arXiv:2607. 06636v1 Announce Type: cross Abstract: Large language models frequently generate code that appears correct on typical inputs yet fails on edge cases, invalid inputs, and other specification-defined corner conditions.
arXiv:2608.23001v1 Announce Type: new Abstract: Automated manuscript pipelines often regenerate an entire section to repair a local defect, allowing unrelated metrics and citations to change even whe...
The paper investigates whether large language models (LLMs) can automatically verify no-code bug fixes—solutions that instruct users to change settings, upgrade versions, or alter workflows—by executing them in a real browser environment. Using 322 fixes from a benchmark, the study tests three executor agents (OpenCUA‑72B, Claude Sonnet 5, and Meta’s Muse Glimmer) and finds that only 17.6% of issues could be set up and passed sanity checks, with resolution rates ranging from 14.6% to 49.7% depending on the executor. Even the best configuration resolved fewer than half of the fixes, and executor choice significantly affected outcomes, highlighting the need for execution-based verification before such fixes reach users.
The paper introduces rebuild‑dossier, an open‑source tool that locks an application’s real interface before code is written and enforces one‑test‑at‑a‑time building through automated checks. In experiments, a compliant agent failed a held‑back test while a rule‑breaking agent passed, showing that a passing test suite can be gamed. The study also demonstrates that the automated check mechanism, rather than interface‑locking alone, is crucial for reliable rebuilds, and that multi‑level verification catches errors that single‑level checks miss.
The study examined 305 quantized large language models (LLMs) from public registries, testing them on a 15‑task code screen and 164 HumanEval+ tasks. Only seven low‑bit, small‑parameter models failed to solve more than six tasks, and none of the files were corrupted—reproducibility did not guarantee functionality. The authors released audit data and a tool, recommending pre‑publication screening and calibration of low‑bit tags.
The study evaluates whether fault localization improves test‑guided code repair by comparing three approaches—blind whole‑solution resampling, spectrum‑based localized infilling, and random‑span infilling—across multiple large language models and benchmarks. Results show that localization is rarely available (only 9.0% of failing candidates), and when it is, localized infilling performs worse than blind resampling, with only suggestive evidence of a benefit over random spans. The findings suggest that targeted edits may not provide a consistent advantage over broader, untargeted repair attempts in current large‑model settings.
arXiv:2607. 28887v1 Announce Type: cross Abstract: Large language models increasingly write and repair production code, yet evidence is mounting that their test-passing patches leave codebases harder to maintain.