Pith. sign in

REVIEW 4 major objections 4 minor 3 cited by

Algorithm-matched examples fix code in half the LLM calls

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

ReCode improves LLM-based code repair by combining algorithm-type prediction with dual-encoder retrieval of authentic bug-fix pairs, and introduces RACodeBench for evaluation.

T0 review reviewed 2026-08-05 challenge →

load-bearing objection Plausible RAG-for-repair framework with a useful new benchmark, but the algorithm-aware retrieval is never directly validated and the cost claims are muddled; needs major revision before I'd trust the headline. the 4 major comments →

arxiv 2509.02330 v1 pith:GEQ7SXKY submitted 2025-09-02 cs.SE cs.AI

ReCode: Improving LLM-based Code Repair with Fine-Grained Retrieval-Augmented Generation

Yicong Zhao , Shisong Chen , Jiacheng Zhang , Zhixu Li This is my paper
classification cs.SE cs.AI
keywords code repairretrieval-augmented generationin-context learningautomated program repairalgorithm-aware retrievaldual-encoderbenchmarklarge language models
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

ReCode aims to show that code repair can be made both more accurate and cheaper by retrieving repair exemplars that match the underlying algorithm of the buggy program, rather than relying on broad code-text similarity or on repeated sampling and self-repair. The paper argues that existing retrieval-augmented approaches lose information by encoding the problem statement and the source code as a single blob, and that splitting them into separate text and code representations improves retrieval quality. It further narrows the search space by having the LLM predict one or more algorithm types for the buggy code and retrieving only from the corresponding sub-corpus. On a new benchmark built from real user submissions, plus six out-of-distribution competitive programming datasets, ReCode reports consistently higher test-pass rates and strict accuracy than the best-of-N and self-repair baselines while using fewer inference calls. If correct, this makes retrieval-augmented in-context learning a practical, training-free alternative to expensive repair strategies.

Core claim

At the center of ReCode is a two-part retrieval design. First, an algorithm-aware module asks the LLM to classify the buggy snippet into multiple algorithm categories, pruning the knowledge base to algorithm-specific partitions. Second, a dual-view encoder represents the natural-language problem description and the defective code with separate specialized encoders, one for text and one for code, then fuses the two vectors for retrieval. The paper's central claim is that this fine-grained, algorithm-conditioned retrieval supplies repair examples that are structurally and semantically aligned with the target bug, so the downstream LLM produces a correct fix in fewer attempts. Across all six ev

What carries the argument

The load-bearing mechanism is algorithm-aware hybrid retrieval combined with dual-view encoding. The LLM first produces multi-label algorithm predictions for the buggy code, which select sub-corpora of a hierarchically organized knowledge base built from historical problem submissions. Separately, a text encoder and a code encoder embed the query's two modalities, and their fused vector retrieves exemplars within the selected algorithm partitions. The retrieved buggy-fixed pairs are then prepended as in-context examples to the prompt for the repair model. This design lets the retrieval match algorithmic intent as well as surface form.

Load-bearing premise

The whole scheme rests on the assumption that the model's algorithm-type prediction is accurate enough that restricting retrieval to the predicted sub-corpus does not exclude the best repair exemplar; the paper does not report this classification accuracy.

What would settle it

Take the retrieval pipeline and replace the predicted algorithm labels with random labels, keeping everything else identical. If the test-pass rate and strict accuracy do not drop below the reported ReCode results, the algorithm-aware narrowing is not the cause of the gains.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • Repair accuracy can be improved without fine-tuning, by organizing external repair knowledge by algorithm type and retrieving from it.
  • Retrieval-augmented models benefit more from scale-up than pure generative baselines: in the paper, scaling from a 9B to a 27B model improved ReCode by 14.42 percent versus 6.94 percent for best-of-N.
  • Models with weaker pretraining on code gain the most from retrieved exemplars, suggesting retrieval can partially compensate for missing code knowledge.
  • Under a fixed inference budget, targeted retrieval reaches a given accuracy with roughly half to one-third the LLM calls of sampling or self-repair.
  • Algorithm-conditioned retrieval generalizes out-of-distribution: examples retrieved from one competitive programming source transfer to six other datasets.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same two-part design could transfer to other structured repair domains, such as SQL, configuration files, or shell scripts, whenever a stable taxonomy of problem types can be defined.
  • A stricter test of the algorithm-aware claim would be to randomize the predicted algorithm labels; if repair accuracy does not drop, the benefit may come from the dual-encoder alone.
  • Because the paper does not report algorithm-classification accuracy, a natural extension is to measure how classifier errors propagate into retrieval precision and repair success.
  • The modular encoding suggests that code-structural signals beyond token embeddings, such as abstract syntax tree or data-flow features, could further sharpen retrieval.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper proposes ReCode, a retrieval-augmented in-context learning framework for code repair. ReCode first uses an LLM to predict multi-label algorithm types for a buggy program, then performs retrieval from algorithm-specific sub-knowledge bases using a dual-encoder architecture that separately encodes natural-language descriptions and code. The authors also introduce RACodeBench, a benchmark built from Codeforces user submissions, and evaluate ReCode against best-of-N and self-repair baselines on RACodeBench and six additional competitive-programming datasets. The central claims are that ReCode achieves higher repair accuracy than the baselines and does so with significantly lower inference cost.

Significance. If the central claims hold, ReCode is a practical, training-free alternative to sampling-based and iterative self-repair: it couples inexpensive retrieval with a single or few generation calls and sidesteps fine-tuning. The construction of RACodeBench with strict partitioning between the benchmark and the retrieval knowledge base is a positive methodological step, and the paper is transparent about using off-the-shelf encoders (OASIS-code-1.3B and bge-m3). The main risk is that the distinctively novel component—algorithm-aware retrieval—is not directly validated, and the inference-cost comparison is internally inconsistent. These issues are load-bearing for both the accuracy and efficiency claims, so the paper needs a substantive revision rather than minor polishing.

major comments (4)
  1. [§4.4, Table 3] The inference budget is inconsistently specified. Table 2 states that all methods use N=8 inference calls, and the metrics in Eq. (4)–(5) take the best of N candidate solutions. However, §4.4 says that “ReCode generates a high-quality repair in a single pass using context exemplars” and then describes cost curves at N=1,2,4,8, saying ReCode performs worse at N=1 “due to its initial algorithm type identification step.” This implies the classification call is counted inside N for ReCode but the generation is single-pass, which is incompatible with taking a max over N generated candidates. If ReCode receives additional generation calls beyond the classification call while baselines count all calls in N, the comparison is unfair; if ReCode truly makes one generation call, then the Table 2 metrics should not use max-over-N for ReCode. Please specify exactly how the N-call budget is split (cla
  2. [§3.3] The algorithm-aware retrieval step is never directly validated. No experiment reports the accuracy of the LLM’s multi-label algorithm predictions, nor any failure cases or confidence information. The only ablation, Figure 5, compares examples retrieved by ReCode’s pipeline against randomly sampled examples, but this does not isolate the effect of restricting retrieval to the predicted algorithm sub-knowledge base: it conflates the dual-encoder relevance ranking with the algorithm-filtering step. An incorrect algorithm prediction could exclude the most useful repair exemplar, making ReCode worse than the same system retrieving from the full knowledge base. I request: (a) classification accuracy of the algorithm predictor (per model), (b) an ablation comparing full-KB retrieval with predicted-sub-KB retrieval, and (c) an analysis of cases where the predicted label set is wrong but repair s
  3. [§4.2] The out-of-distribution claim is overstated. The retrieval knowledge base is constructed exclusively from Codeforces, and the OOD test sets are all competitive-programming datasets (AtCoder, CodeChef, HackerRank, etc.). These share the same problem format, input/output conventions, and algorithmic tag distribution as Codeforces. The paper uses “out-of-distribution” to mean different platforms, not a genuine distribution shift away from contest-style programming. This does not invalidate the in-distribution results, but it should be acknowledged as a limitation: generalization to real-world non-competition code repositories is not demonstrated, and the current framing in §1 and §4.2 as “real-world code repair scenarios” goes beyond the evidence.
  4. [§4.4] The efficiency analysis lacks quantitative detail for the claimed “halving inference cost” results. The text states that at N=4 ReCode matches other methods at N=8 and reaches their upper bound by N=5, but no table or figure with these in-distribution cost curves is provided (Figure 6 is referenced but not present in the text). Only the AtCoder threshold table (Table 3) gives concrete numbers. Please include the data behind the in-distribution cost claims, or soften the conclusion to what Table 3 supports.
minor comments (4)
  1. [Throughout] The manuscript contains PDF-extraction artifacts (e.g., sequences of /gid tokens in Figures 1, 2, and 7) and ACM template placeholders (“Conference’17”, “July 2017”). These should be cleaned before submission.
  2. [§3.4] The semi-automated annotation pipeline is described only at a high level. Since RACodeBench is a contribution, please report annotation statistics (number of instances, error-type distribution, inter-annotator agreement or verification rate on the manually checked subset).
  3. [§4.1] The baseline descriptions are underspecified. For self-repair, please state exactly how the N calls are split between feedback generation and code revision, and whether the feedback is generated with or without execution results.
  4. [§4.1] Eq. (1) denotes the retrieval result as a single example, but the method retrieves multiple exemplars. Minor notation mismatch.

Circularity Check

0 steps flagged

No significant circularity: ReCode is an empirical method evaluated by test-pass rates against baselines, with OOD results on independent datasets; the only self-referential element (RACodeBench and KB both from Codeforces) is a validity concern, not a circular derivation.

full rationale

The paper makes no claim that reduces by construction to its inputs. The retrieval function R and generation objective are defined independently of the evaluation data; no parameter is fitted to RACodeBench, and no equation equates the reported repair gains with the benchmark's construction or with the algorithm-prediction module. The algorithm-aware module's accuracy is never reported, so the central mechanism is under-validated; but that is an empirical-support gap, not circularity, because the pipeline's objective (passing test cases) does not presuppose the predicted labels. The in-distribution evaluation shares the Codeforces source with the knowledge base, creating a distribution-overlap threat to internal validity; however, the paper's OOD results on AtCoder, CodeChef, HackerRank, HackerEarth, GeeksforGeeks, and Aizu are external and not derived from the same benchmark construction. Figure 5's ablation shows relevant examples beat random examples but does not isolate the algorithm-narrowing step; this is an attribution weakness, not a circle. The reference list contains no load-bearing self-citations, and no uniqueness theorem or ansatz is imported from the authors' prior work.

Axiom & Free-Parameter Ledger

3 free parameters · 4 axioms · 0 invented entities

No invented physical or mathematical entities. The new benchmark and knowledge base are datasets, not entities of the kind this ledger tracks. The central empirical claims rest on hand-chosen, unreported hyperparameters and on assumptions about the quality of the semi-automated annotations and the algorithm classifier.

free parameters (3)
  • Number of retrieved exemplars k
    Paper never states how many examples are placed in the prompt; a value must be chosen by hand and it directly affects repair accuracy and inference cost.
  • Feature fusion weight between text and code encoders
    The fused representation combines two encoders, but no fusion formula or weights are given; this is a hand-tuned design choice.
  • Algorithm classification label set and prompting template
    The multi-label algorithm categories and the prompt used to obtain predictions are not specified; performance depends on this choice.
axioms (4)
  • domain assumption Codeforces user submissions and problem tags provide a representative source of real-world bugs and algorithm categories.
    Used to construct both RACodeBench and the knowledge base (Section 3.4). If Codeforces submissions are not representative of general code repair, the benchmark and retrieval corpus are less valid.
  • domain assumption The semi-automated differential analysis pipeline correctly identifies bug-fix pairs and error types.
    Section 3.4 says annotations are generated via a semi-automated pipeline with manual verification only on a 'representative subset'. Annotation errors would corrupt both metrics and retrieval.
  • ad hoc to paper The LLM's algorithm-type predictions are sufficiently accurate to narrow retrieval without excluding relevant examples.
    Section 3.3 relies on this without reporting classification accuracy. If the predicted labels are wrong, retrieval operates on a wrong sub-corpus.
  • domain assumption Strict partitioning fully prevents overlap between RACodeBench and the retrieval knowledge base.
    Section 3.4 claims strict partitioning but gives no method for detecting duplicate or near-duplicate submissions across problems.

reviewed 2026-08-05 · how reviews work

0 comments
Cite this review

Pith. "Pith review of ReCode: Improving LLM-based Code Repair with Fine-Grained Retrieval-Augmented Generation." pith.science (2026). https://pith.science/paper/GEQ7SXKY

@misc{pith2026250902330,
  author       = {Pith},
  title        = {Pith review of: ReCode: Improving LLM-based Code Repair with Fine-Grained Retrieval-Augmented Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/GEQ7SXKY}},
  note         = {Machine review of arXiv:2509.02330}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Recent advances in large language models (LLMs) have demonstrated impressive capabilities in code-related tasks, such as code generation and automated program repair. Despite their promising performance, most existing approaches for code repair suffer from high training costs or computationally expensive inference. Retrieval-augmented generation (RAG), with its efficient in-context learning paradigm, offers a more scalable alternative. However, conventional retrieval strategies, which are often based on holistic code-text embeddings, fail to capture the structural intricacies of code, resulting in suboptimal retrieval quality. To address the above limitations, we propose ReCode, a fine-grained retrieval-augmented in-context learning framework designed for accurate and efficient code repair. Specifically, ReCode introduces two key innovations: (1) an algorithm-aware retrieval strategy that narrows the search space using preliminary algorithm type predictions; and (2) a modular dual-encoder architecture that separately processes code and textual inputs, enabling fine-grained semantic matching between input and retrieved contexts. Furthermore, we propose RACodeBench, a new benchmark constructed from real-world user-submitted buggy code, which addresses the limitations of synthetic benchmarks and supports realistic evaluation. Experimental results on RACodeBench and competitive programming datasets demonstrate that ReCode achieves higher repair accuracy with significantly reduced inference cost, highlighting its practical value for real-world code repair scenarios.

Figures

Figures reproduced from arXiv: 2509.02330 by Jiacheng Zhang, Shisong Chen, Yicong Zhao, Zhixu Li.

Figure 1
Figure 1. Figure 1: An example of our proposed ReCode Method. For [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Overview of our proposed ReCode Method. Given a user query, the model predicts multiple algorithm type labels [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Test pass rates on out-of-distribution code repair. With [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Strict accuracy on out-of-distribution code repair. With [PITH_FULL_IMAGE:figures/full_fig_p007_4.png] view at source ↗
Figure 6
Figure 6. Figure 6: Comparative Analysis of Repair Performance and [PITH_FULL_IMAGE:figures/full_fig_p008_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Qualitative Results of the ReCode method on our RACodeBench Benchmark. [PITH_FULL_IMAGE:figures/full_fig_p009_7.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 3 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. BLAgent: Agentic RAG for File-Level Bug Localization

    cs.SE 2026-05 unverdicted novelty 6.0

    BLAgent achieves over 78% Top-1 accuracy on SWE-bench Lite for file-level bug localization using agentic RAG, at 18x lower cost than baselines, and boosts end-to-end APR success by over 20%.

  2. BLAgent: Agentic RAG for File-Level Bug Localization

    cs.SE 2026-05 unverdicted novelty 6.0

    BLAgent achieves over 78% top-1 file-level bug localization accuracy on SWE-bench-Lite with open-source models and over 86% with closed-source models while being over 18x cheaper than the strongest baseline.

  3. MemRepair: Hierarchical Memory for Agentic Repository-Level Vulnerability Repair

    cs.SE 2026-05 conditional novelty 6.0

    MemRepair is a hierarchical memory-augmented agent framework that raises repository-level vulnerability repair rates to 58.0-58.2% on Python/Go/JS benchmarks and 30.58% on C++ by combining history, pattern, and refine...

Reference graph

Works this paper leans on

51 extracted references · 17 canonical work pages · cited by 2 Pith papers · 3 internal anchors

  1. [1]

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Floren- cia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

    Pith/arXiv arXiv 2023

  2. [2]

    Rishabh Agarwal, Avi Singh, Lei Zhang, Bernd Bohnet, Luis Rosias, Stephanie Chan, Biao Zhang, Ankesh Anand, Zaheer Abbas, Azade Nova, et al. 2024. Many- shot in-context learning. Advances in Neural Information Processing Systems 37 (2024), 76930–76966

    2024

  3. [3]

    Ekin Akyürek, Dale Schuurmans, Jacob Andreas, Tengyu Ma, and Denny Zhou

  4. [4]

    Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020. Language models are few-shot learners. Advances in neural information processing systems 33 (2020), 1877–1901

    2020

  5. [5]

    Collin Burns, Pavel Izmailov, Jan Hendrik Kirchner, Bowen Baker, Leo Gao, Leopold Aschenbrenner, Yining Chen, Adrien Ecoffet, Manas Joglekar, Jan Leike, et al. 2023. Weak-to-strong generalization: Eliciting strong capabilities with weak supervision. arXiv preprint arXiv:2312.09390 (2023)

    Pith/arXiv arXiv 2023

  6. [6]

    Saikat Chakraborty, Yangruibo Ding, Miltiadis Allamanis, and Baishakhi Ray

    work page

  7. [7]

    Angelica Chen, Jérémy Scheurer, Tomasz Korbak, Jon Ander Campos, Jun Shern Chan, Samuel R Bowman, Kyunghyun Cho, and Ethan Perez. 2023. Improving code generation by training with natural language feedback. arXiv preprint arXiv:2303.16749 (2023)

    Pith/arXiv arXiv 2023

  8. [8]

    Jianlv Chen, Shitao Xiao, Peitian Zhang, Kun Luo, Defu Lian, and Zheng Liu. 2024. Bge m3-embedding: Multi-lingual, multi-functionality, multi-granularity text embeddings through self-knowledge distillation. arXiv preprint arXiv:2402.03216 (2024)

    Pith/arXiv arXiv 2024

  9. [9]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 (2021)

    Pith/arXiv arXiv 2021

  10. [10]

    Xinyun Chen, Maxwell Lin, Nathanael Schärli, and Denny Zhou. 2023. Teaching large language models to self-debug. arXiv preprint arXiv:2304.05128 (2023)

    Pith/arXiv arXiv 2023

  11. [11]

    Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Se- bastian Gehrmann, et al. 2023. Palm: Scaling language modeling with pathways. Journal of Machine Learning Research 24, 240 (2023), 1–113

    2023

  12. [12]

    Daniel Fried, Armen Aghajanyan, Jessy Lin, Sida Wang, Eric Wallace, Freda Shi, Ruiqi Zhong, Wen-tau Yih, Luke Zettlemoyer, and Mike Lewis. 2022. Incoder: A generative model for code infilling and synthesis. arXiv preprint arXiv:2204.05999 (2022)

    Pith/arXiv arXiv 2022

  13. [13]

    Cheng Fu, Huili Chen, Haolan Liu, Xinyun Chen, Yuandong Tian, Farinaz Koushanfar, and Jishen Zhao. 2019. Coda: An end-to-end neural program decom- piler. Advances in Neural Information Processing Systems 32 (2019)

    work page 2019

  14. [14]

    Zuchen Gao, Zizheng Zhan, Xianming Li, Erxin Yu, Haotian Zhang, Bin Chen, Yuqun Zhang, and Jing Li. 2025. OASIS: Order-Augmented Strategy for Improved Code Search. arXiv preprint arXiv:2503.08161 (2025)

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  15. [15]

    Ali Ghanbari, Samuel Benton, and Lingming Zhang. 2019. Practical program re- pair via bytecode mutation. In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis . 19–30

    work page 2019

  16. [16]

    Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al . 2025. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948 (2025)

    Pith/arXiv arXiv 2025

  17. [17]

    Kavi Gupta, Peter Ebert Christensen, Xinyun Chen, and Dawn Song. 2020. Syn- thesize, execute and debug: Learning to repair for neural program synthesis. Advances in Neural Information Processing Systems 33 (2020), 17685–17695

    work page 2020

  18. [18]

    Dan Hendrycks, Steven Basart, Saurav Kadavath, Mantas Mazeika, Akul Arora, Ethan Guo, Collin Burns, Samir Puranik, Horace He, Dawn Song, et al. 2021. Mea- suring coding challenge competence with apps. arXiv preprint arXiv:2105.09938 (2021)

    Pith/arXiv arXiv 2021

  19. [19]

    Yaojie Hu, Xingjian Shi, Qiang Zhou, and Lee Pike. 2022. Fix bugs with trans- former through a neural-symbolic edit grammar. arXiv preprint arXiv:2204.06643 (2022)

    work page internal anchor Pith review Pith/arXiv arXiv 2022

  20. [20]

    Kai Huang, Zhengzi Xu, Su Yang, Hongyu Sun, Xuejun Li, Zheng Yan, and Yuqing Zhang. 2023. A survey on automated program repair techniques. arXiv preprint arXiv:2303.18184 (2023)

    Pith/arXiv arXiv 2023

  21. [21]

    Jiajun Jiang, Yingfei Xiong, Hongyu Zhang, Qing Gao, and Xiangqun Chen

  22. [22]

    Nan Jiang, Thibaud Lutellier, and Lin Tan. 2021. Cure: Code-aware neural machine translation for automatic program repair. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE) . IEEE, 1161–1173

    2021

  23. [23]

    Hung Le, Yue Wang, Akhilesh Deepak Gotmare, Silvio Savarese, and Steven Chu Hong Hoi. 2022. Coderl: Mastering code generation through pretrained models and deep reinforcement learning. Advances in Neural Information Pro- cessing Systems 35 (2022), 21314–21328

    work page 2022

  24. [24]

    Raymond Li, Loubna Ben Allal, Yangtian Zi, Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Marc Marone, Christopher Akiki, Jia Li, Jenny Chim, et al. 2023. Starcoder: may the source be with you! arXiv preprint arXiv:2305.06161 (2023)

    Pith/arXiv arXiv 2023

  25. [25]

    Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, et al. 2022. Competition-level code generation with alphacode. Science 378, 6624 (2022), 1092–1097

    2022

  26. [26]

    Aixin Liu, Bei Feng, Bin Wang, Bingxuan Wang, Bo Liu, Chenggang Zhao, Chengqi Dengr, Chong Ruan, Damai Dai, Daya Guo, et al . 2024. Deepseek- v2: A strong, economical, and efficient mixture-of-experts language model. arXiv preprint arXiv:2405.04434 (2024)

    Pith/arXiv arXiv 2024

  27. [27]

    Fei Liu et al. 2020. Learning to summarize from human feedback. InProceedings of the 58th Annual Meeting of the Association for Computational Linguistics. 583–592

    work page 2020

  28. [28]

    Yun Luo, Zhen Yang, Fandong Meng, Yafu Li, Jie Zhou, and Yue Zhang. 2023. An empirical study of catastrophic forgetting in large language models during continual fine-tuning. arXiv preprint arXiv:2308.08747 (2023)

    Pith/arXiv arXiv 2023

  29. [29]

    Aditi Mavalankar, Hassan Mansoor, Zita Marinho, Masha Samsikova, and Tom Schaul. 2025. AuPair: Golden Example Pairs for Code Repair. arXiv preprint arXiv:2502.18487 (2025)

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  30. [30]

    Theo X Olausson, Jeevana Priya Inala, Chenglong Wang, Jianfeng Gao, and Armando Solar-Lezama. 2023. Is self-repair a silver bullet for code generation? arXiv preprint arXiv:2306.09896 (2023)

    Pith/arXiv arXiv 2023

  31. [31]

    Yun Peng, Shuzheng Gao, Cuiyun Gao, Yintong Huo, and Michael Lyu. 2024. Domain knowledge matters: Improving prompts with fix templates for repairing python type errors. In Proceedings of the 46th ieee/acm international conference on software engineering. 1–13

    work page 2024

  32. [32]

    Matthew Renze. 2024. The effect of sampling temperature on problem solving in large language models. InFindings of the Association for Computational Linguistics: EMNLP 2024. 7346–7356

    2024

  33. [33]

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiao- qing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. 2023. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950 (2023)

    Pith/arXiv arXiv 2023

  34. [34]

    Yuling Shi, Songsong Wang, Chengcheng Wan, and Xiaodong Gu. 2024. From code to correctness: Closing the last mile of code generation with hierarchical debugging. arXiv preprint arXiv:2410.01215 (2024)

    arXiv 2024

  35. [35]

    Noah Shinn, Federico Cassano, Beck Labash, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. 2023. Reflexion: Language agents with verbal reinforcement learning, 2023. URL https://arxiv. org/abs/2303.11366 (2023)

    Pith/arXiv arXiv 2023

  36. [36]

    Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhupatiraju, Léonard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ramé, et al. 2024. Gemma 2: Improving open language models at a practical size. arXiv preprint arXiv:2408.00118 (2024)

    Pith/arXiv arXiv 2024

  37. [37]

    Johannes Von Oswald, Eyvind Niklasson, Ettore Randazzo, João Sacramento, Alexander Mordvintsev, Andrey Zhmoginov, and Max Vladymyrov. 2023. Trans- formers learn in-context by gradient descent. In International Conference on Machine Learning. PMLR, 35151–35174

    work page 2023

  38. [38]

    Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2022. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171 (2022)

    Pith/arXiv arXiv 2022

  39. [39]

    Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2022. Self-instruct: Aligning language mod- els with self-generated instructions. arXiv preprint arXiv:2212.10560 (2022)

    Pith/arXiv arXiv 2022

  40. [40]

    Deheng Yang, Xiaoguang Mao, Liqian Chen, Xuezheng Xu, Yan Lei, David Lo, and Jiayu He. 2022. Transplantfix: Graph differencing-based code transplantation for automated program repair. In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering . 1–13

    work page 2022

  41. [41]

    Xin Yin, Chao Ni, Shaohua Wang, Zhenhao Li, Limin Zeng, and Xiaohu Yang

  42. [42]

    Kechi Zhang, Zhuo Li, Jia Li, Ge Li, and Zhi Jin. 2023. Self-edit: Fault-aware code editor for code generation. arXiv preprint arXiv:2305.04087 (2023). ReCode: Improving LLM-based Code Repair with Fine-Grained Retrieval-Augmented Generation Conference’17, July 2017, Washington, DC, USA

    Pith/arXiv arXiv 2023

  43. [43]

    Quanjun Zhang, Chunrong Fang, Yuxiang Ma, Weisong Sun, and Zhenyu Chen

  44. [44]

    Li Zhong, Zilong Wang, and Jingbo Shang. 2024. Debug like a human: A large language model debugger via verifying runtime execution step-by-step. arXiv preprint arXiv:2402.16906 (2024)

    Pith/arXiv arXiv 2024

  45. [45]

    Wenkang Zhong, Chuanyi Li, Jidong Ge, and Bin Luo. 2022. Neural program repair: Systems, challenges and solutions. In Proceedings of the 13th Asia-Pacific symposium on internetware. 96–106

    work page 2022

  46. [46]

    Qihao Zhu, Daya Guo, Zhihong Shao, Dejian Yang, Peiyi Wang, Runxin Xu, Y Wu, Yukun Li, Huazuo Gao, Shirong Ma, et al . 2024. Deepseek-coder-v2: Breaking the barrier of closed-source models in code intelligence. arXiv preprint arXiv:2406.11931 (2024)

    Pith/arXiv arXiv 2024

  47. [2018]

    In Proceedings of the 27th ACM SIGSOFT international symposium on software testing and analysis

    Shaping program repair space with existing patches and similar code. In Proceedings of the 27th ACM SIGSOFT international symposium on software testing and analysis. 298–309

    work page

  48. [2020]

    IEEE Transactions on Software Engineering 48, 4 (2020), 1385–1399

    Codit: Code editing with tree-based neural models. IEEE Transactions on Software Engineering 48, 4 (2020), 1385–1399

    work page 2020

  49. [2022]

    arXiv preprint arXiv:2211.15661 (2022)

    What learning algorithm is in-context learning? investigations with linear models. arXiv preprint arXiv:2211.15661 (2022)

    Pith/arXiv arXiv 2022

  50. [2023]

    ACM Transactions on Software Engineering and Methodology 33, 2 (2023), 1–69

    A survey of learning-based automated program repair. ACM Transactions on Software Engineering and Methodology 33, 2 (2023), 1–69

    work page 2023

  51. [2024]

    In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis

    Thinkrepair: Self-directed automated program repair. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis . 1274–1286

    work page

This paper was first reviewed by deepseek-v4-flash on August 5, 2026.