Elamur Research⌕
☰
home / papers / 2024 / From Code to Correctness: Closing the Last Mile of Code Generation with Hierarchical Debugging

From Code to Correctness: Closing the Last Mile of Code Generation with Hierarchical Debugging

Paper · 2024 · Yuling Shi, Songsong Wang, Chengcheng Wan et al.

Summary

LLMs often write code that is almost right but fails tests because of small mistakes. Existing LLM-based repair loops usually look at the whole program at once, which makes bugs hard to locate. The authors propose MGDebugger, which needs no extra training and works in a zero-shot setting. First, an LLM restructures the faulty code into a tree of small helper functions. Next, unit tests for each helper are derived from the main function's public tests. Instead of a real debugger, an LLM simulates execution step by step and records key variable values to find where behaviour goes wrong. Repairs start at the leaves of the tree and propagate upward to the callers. Across open-source and commercial models, the method beats prior debuggers such as Self-Debugging, Reflexion and LDB on HumanEval and HumanEvalFix. It also transfers to human-written Java bugs in Defects4J. The work suggests that granular, structure-aware debugging is a practical way to make LLM code generation more reliable.

Key points

  • The pipeline has four stages: LLM-driven hierarchical decomposition, test generation for each subfunction, debugging with an LLM-simulated Python executor, and bottom-up propagation of fixes.
  • With DeepSeek-Coder-V2-Lite, CodeQwen1.5 and Codestral, HumanEval accuracy rose from 75.6% to 94.5% (up to +18.9% over seed generations), and HumanEvalFix reached a 97.6% repair success rate.
  • GPT-4o and Claude 3.5 Sonnet each gained 6.1% on HumanEval, reaching 96.3% and 95.7%.
  • In the ablation, removing the hierarchical strategy lowered the HumanEval repair success rate from 76.3% to 52.6%, making it the most important component.
  • On Defects4J, MGDebugger fixed 129 bugs in v1.2 and 64 in v2.0, beating state-of-the-art APR tools by 13.2% and 8.5%; code is available at github.com/YerbaPage/MGDebugger (ICSE '26).

Our summary of the paper, in our own words — not its text. The work belongs to its authors; read it at the links above.

 Institutions

🎓University of PennsylvaniaPhiladelphia · United States221 works · 63,234 citations🎓Shanghai Jiao Tong UniversityShanghai · China149 works · 16,161 citations🎓East China Normal UniversityShanghai · China50 works · 2,174 citations🎓University of California, DavisDavis · United States28 works · 41,916 citations

 Fields, topics and concepts

📚 Shelves 4The field of science this work belongs to (OpenAlex fields).Computer Science · 16,667 worksInformation Systems · 1,437 worksSoftware · 92 worksComputer Science Applications · 102 works

🧭 Topics 1Research subjects and languages the work is about.Code & programming languages · 129 works

Cite

Cite as Yuling Shi, Songsong Wang, Chengcheng Wan, Min Wang and Xiaodong Gu. 2024. From Code to Correctness: Closing the Last Mile of Code Generation with Hierarchical Debugging. arXiv:2410.01215.

The paper itself, not this page. BibTeX from the library's record of the work. DOI 10.48550/arxiv.2410.01215 · arXiv 2410.01215

@misc{shi2024code,
  title = {{From Code to Correctness: Closing the Last Mile of Code Generation with Hierarchical Debugging}},
  author = {Yuling Shi, Songsong Wang, Chengcheng Wan, Min Wang and Xiaodong Gu},
  year = {2024},
  doi = {10.48550/arxiv.2410.01215},
  eprint = {2410.01215},
  archivePrefix = {arXiv},
  url = {https://doi.org/10.48550/arxiv.2410.01215}
}

References

77 references, 16 of them with a card of ours. ↗ leads to the work, «find» searches for one we have no id for yet.

  1. DeepSeek AI. 2024. DeepSeek-Coder-V2: Breaking the Barrier of Closed-Source Models in Code Intelligence. arXiv:2406.11931
  2. Anthropic. 2024. Introducing Claude 3.5 Sonnet. https://www.anthropic.com/news/claude-3-5-sonnet. ↗
  3. Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, and Charles Sutton. 2021. Program Synthesis with Large Language Models. arXiv:2108.07732 [cs] doi:10.48550/arXiv.2108.07732
  4. Islem Bouzenia, Premkumar Devanbu, and Michael Pradel. 2024. RepairAgent: An Autonomous, LLM-Based Agent for Program Repair. arXiv:2403.17134 [cs] doi:10.48550/arXiv.2403.17134 — [doi:10.48550/arxiv.2403.17134](https://doi.org/10.48550/arxiv.2403.17134) find
  5. Collin Burns, Pavel Izmailov, Jan Hendrik Kirchner, Bowen Baker, Leo Gao, Leopold Aschenbrenner, Yining Chen, Adrien Ecoffet, Manas Joglekar, Jan Leike, Ilya Sutskever, and Jeff Wu. 2023. Weak-to-Strong Generalization: Eliciting Strong Capabilities With Weak Supervision. arXiv:2312.09390 doi:10.4855…
  6. Bei Chen, Fengji Zhang, Anh Nguyen, Daoguang Zan, Zeqi Lin, Jian-Guang Lou, and Weizhu Chen. 2022. CodeT: Code Generation with Generated Tests. In The Twelfth International Conference on Learning Representations. find
  7. Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhai… — Evaluating Large Language Models Trained on Code
  8. Xinyun Chen, Renat Aksitov, Uri Alon, Jie Ren, Kefan Xiao, Pengcheng Yin, Sushant Prakash, Charles Sutton, Xuezhi Wang, and Denny Zhou. 2023. Universal Self-Consistency for Large Language Model Generation. arXiv:2311.17311
  9. Xinyun Chen, Maxwell Lin, Nathanael Schärli, and Denny Zhou. 2023. Teaching Large Language Models to Self-Debug. In The Twelfth International Conference on Learning Representations. find
  10. Yangruibo Ding, Marcus J. Min, Gail Kaiser, and Baishakhi Ray. 2024. CYCLE: Learning to Self-Refine the Code Generation. Proc. ACM Program. Lang. 8, OOPSLA1 (April 2024), 108:392–108:418. doi:10.1145/3649825 — [doi:10.1145/3649825](https://doi.org/10.1145/3649825) find
  11. Yihong Dong, Xue Jiang, Zhi Jin, and Ge Li. 2024. Self-Collaboration Code Generation via ChatGPT. ACM Trans. Softw. Eng. Methodol. (June 2024). doi:10. 1145/3672459 find
  12. Shihan Dou, Haoxiang Jia, Shenxi Wu, Huiyuan Zheng, Weikang Zhou, Muling Wu, Mingxu Chai, Jessica Fan, Caishuang Huang, Yunbo Tao, Yan Liu, Enyu Zhou, Ming Zhang, Yuhao Zhou, Yueming Wu, Rui Zheng, Ming Wen, Rongxiang Weng, Jingang Wang, Xunliang Cai, Tao Gui, Xipeng Qiu, Qi Zhang, and Xuanjing Huan… — [arXiv:2407.06153](https://arxiv.org/abs/2407.06153) find
  13. Kavi Gupta, Peter Ebert Christensen, Xinyun Chen, and Dawn Song. 2020. Synthesize, Execute and Debug: Learning to Repair for Neural Program Synthesis. In Advances in Neural Information Processing Systems, Vol. 33. Curran Associates, Inc., 17685–17695. find
  14. Dan Hendrycks, Steven Basart, Saurav Kadavath, Mantas Mazeika, Akul Arora, Ethan Guo, Collin Burns, Samir Puranik, Horace He, Dawn Song, and Jacob Steinhardt. 2021. Measuring Coding Challenge Competence With APPS. In Thirty-Fifth Conference on Neural Information Processing Systems Datasets and Bench…
  15. Soneya Binta Hossain, Nan Jiang, Qiang Zhou, Xiaopeng Li, Wen-Hao Chiang, Yingjun Lyu, Hoan Nguyen, and Omer Tripp. 2024. A Deep Dive into Large Language Models for Automated Bug Localization and Repair. Proc. ACM Softw. Eng. 1, FSE (July 2024), 66:1471–66:1493. doi:10.1145/3660773 — [doi:10.1145/3660773](https://doi.org/10.1145/3660773) find
  16. Xueyu Hu, Kun Kuang, Jiankai Sun, Hongxia Yang, and Fei Wu. 2024. Leveraging Print Debugging to Improve Code Generation in Large Language Models. arXiv:2401.05319 — [arXiv:2401.05319](https://arxiv.org/abs/2401.05319) find
  17. Dong Huang, Qingwen Bu, Jie M. Zhang, Michael Luck, and Heming Cui. 2023. AgentCoder: Multi-Agent-based Code Generation with Iterative Testing and Optimisation. arXiv:2312.13010 doi:10.48550/arXiv.2312.13010 find
  18. Kai Huang, Xiangxin Meng, Jian Zhang, Yang Liu, Wenjie Wang, Shuhao Li, and Yuqing Zhang. 2023. An Empirical Study on Fine-Tuning Large Language Models of Code for Automated Program Repair. In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, Luxembourg, Luxe… — [doi:10.1109/ase56229.2023.00181](https://doi.org/10.1109/ase56229.2023.00181) find
  19. Ayaz Isazadeh, Habib Izadkhah, and Islam Elgedawy. 2017. Source Code Modularization. Springer International Publishing, Cham. doi:10.1007/978-3-319-63346-6 — [doi:10.1007/978-3-319-63346-6](https://doi.org/10.1007/978-3-319-63346-6) find
  20. Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Armando Solar-Lezama, Koushik Sen, and Ion Stoica. 2025. Live-CodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code. In The Thirteenth International Conference on Learning Representati… find
  21. Naman Jain, Tianjun Zhang, Wei-Lin Chiang, Joseph E. Gonzalez, Koushik Sen, and Ion Stoica. 2023. LLM-Assisted Code Cleaning For Training Accurate Code Generators. arXiv:2311.14904 doi:10.48550/arXiv.2311.14904 find
  22. Nan Jiang, Xiaopeng Li, Shiqi Wang, Qiang Zhou, Soneya Binta Hossain, Baishakhi Ray, Varun Kumar, Xiaofei Ma, and Anoop Deoras. 2024. Training LLMs to Better Self-Debug and Explain Code. In NeurIPS2024. find
  23. Nan Jiang, Thibaud Lutellier, Yiling Lou, Lin Tan, Dan Goldwasser, and Xiangyu Zhang. 2023. KNOD: Domain Knowledge Distilled Tree Decoder for Automated Program Repair. In Proceedings of the 45th International Conference on Software Engineering (ICSE ’23). IEEE Press, Melbourne, Victoria, Australia,… — [doi:10.1109/icse48619.2023.00111](https://doi.org/10.1109/icse48619.2023.00111) find
  24. Shuyang Jiang, Yuhao Wang, and Yu Wang. 2023. SelfEvolve: A Code Evolution Framework via Large Language Models. arXiv:2306.02907 [cs] doi:10.48550/arXiv. 2306.02907 — [doi:10.48550/arxiv](https://doi.org/10.48550/arxiv) find
  25. René Just, Darioush Jalali, and Michael D. Ernst. 2014. Defects4J: A Database of Existing Faults to Enable Controlled Testing Studies for Java Programs. In Proceedings of the 2014 International Symposium on Software Testing and Analysis (ISSTA 2014). Association for Computing Machinery, New York, NY… find
  26. YoungJae Kim, Yechan Park, Seungheon Han, and Jooyong Yi. 2024. Enhancing the Efficiency of Automated Program Repair via Greybox Analysis. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering (ASE ’24). Association for Computing Machinery, New York, NY, USA,… — [doi:10.1145/3691620.3695602](https://doi.org/10.1145/3691620.3695602) find
  27. Jiaolong Kong, Xiaofei Xie, Mingfei Cheng, Shangqing Liu, Xiaoning Du, and Qi Guo. 2025. ContrastRepair: Enhancing Conversation-Based Automated Program Repair via Contrastive Test Case Pairs. ACM Trans. Softw. Eng. Methodol. (March 2025). doi:10.1145/3719345 — [doi:10.1145/3719345](https://doi.org/10.1145/3719345) find
  28. Aviral Kumar, Vincent Zhuang, Rishabh Agarwal, Yi Su, John D. Co-Reyes, Avi Singh, Kate Baumli, Shariq Iqbal, Colton Bishop, Rebecca Roelofs, Lei M. Zhang, Kay McKinney, Disha Shrivastava, Cosmin Paduraru, George Tucker, Doina Precup, Feryal Behbahani, and Aleksandra Faust. 2024. Training Language M…
  29. Emanuele La Malfa, Christoph Weinhuber, Orazio Torre, Fangru Lin, Samuele Marro, Anthony Cohn, Nigel Shadbolt, and Michael Wooldridge. 2024. Code simulation challenges for large language models. arXiv preprint arXiv:2401.09074 (2024). — [arXiv:2401.09074](https://arxiv.org/abs/2401.09074) find
  30. Xuan-Bach D. Le, Duc-Hiep Chu, David Lo, Claire Le Goues, and Willem Visser. 2017. S3: Syntax- and Semantic-Guided Repair Synthesis via Programming by Examples. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2017). Association for Computing Machinery,… — [doi:10.1145/3106237.3106309](https://doi.org/10.1145/3106237.3106309) find
  31. Claire Le Goues, ThanhVu Nguyen, Stephanie Forrest, and Westley Weimer. 2012. GenProg: A Generic Method for Automatic Software Repair. IEEE Trans. Softw. Eng. 38, 1 (Jan. 2012), 54–72. doi:10.1109/TSE.2011.104 find
  32. Cheryl Lee, Chunqiu Steven Xia, Jen-tse Huang, Zhouruixin Zhu, Lingming Zhang, and Michael R. Lyu. 2024. A Unified Debugging Approach via LLM-Based Multi-Agent Synergy. arXiv:2404.17153 — [arXiv:2404.17153](https://arxiv.org/abs/2404.17153) find
  33. Chengshu Li, Jacky Liang, Andy Zeng, Xinyun Chen, Karol Hausman, Dorsa Sadigh, Sergey Levine, Li Fei-Fei, Fei Xia, and Brian Ichter. 2023. Chain of Code: Reasoning with a Language Model-Augmented Code Emulator. arXiv:2312.04474 — [arXiv:2312.04474](https://arxiv.org/abs/2312.04474) find
  34. Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, Thomas Hubert, Peter Choy, Cyprien de Masson d’Autume, Igor Babuschkin, Xinyun Chen, Po-Sen Huang, Johannes Welbl, Sven Gowal, Alexey Cherepanov, James M… — Competition-Level Code Generation with AlphaCode
  35. Yi Li, Shaohua Wang, and Tien N. Nguyen. 2020. DLFix: Context-Based Code Transformation Learning for Automated Program Repair. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (ICSE ’20). Association for Computing Machinery, New York, NY, USA, 602–614. doi:10.1145… — [doi:10.1145/3377811.3380345](https://doi.org/10.1145/3377811.3380345) find
  36. Bo Lin, Shangwen Wang, Ming Wen, Liqian Chen, and Xiaoguang Mao. 2024. One Size Does Not Fit All: Multi-granularity Patch Generation for Better Automated Program Repair. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA 2024). Association for Comp… — [doi:10.1145/3650212.3680381](https://doi.org/10.1145/3650212.3680381) find
  37. Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, and Lingming Zhang. 2023. Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation. arXiv:2305.01210 [cs] doi:10.48550/arXiv. 2305.01210
  38. Jiate Liu, Yiqin Zhu, Kaiwen Xiao, Qiang Fu, Xiao Han, Yang Wei, and Deheng Ye. 2023. RLTF: Reinforcement Learning from Unit Test Feedback. Transactions on Machine Learning Research (July 2023). find
  39. Kui Liu, Anil Koyuncu, Dongsun Kim, and Tegawende F. Bissyandè. 2019. AVATAR: Fixing Semantic Bugs with Fix Patterns of Static Analysis Violations. In 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE Computer Society, 1–12. doi:10.1109/SANER.201… — [doi:10.1109/saner.2019.8667970](https://doi.org/10.1109/saner.2019.8667970) find
  40. Thibaud Lutellier, Hung Viet Pham, Lawrence Pang, Yitong Li, Moshi Wei, and Lin Tan. 2020. CoCoNuT: Combining Context-Aware Neural Translation Models Using Ensemble for Program Repair. In Proceedings of the 29th ACM SIGSOFT International Symposium on Software Testing and Analysis (IS-STA 2020). Asso… — [doi:10.1145/3395363.3397369](https://doi.org/10.1145/3395363.3397369) find
  41. Sergey Mechtaev, Jooyong Yi, and Abhik Roychoudhury. 2016. Angelix: Scalable Multiline Program Patch Synthesis via Symbolic Analysis. In Proceedings of the 38th International Conference on Software Engineering (ICSE ’16). Association for Computing Machinery, New York, NY, USA, 691–701. doi:10.1145/2… — [doi:10.1145/2884781](https://doi.org/10.1145/2884781) find
  42. Mistral AI team. 2024. Codestral: Hello, World! https://mistral.ai/news/codestral/. ↗
  43. Seungjun Moon, Hyungjoo Chae, Yongho Song, Taeyoon Kwon, Dongjin Kang, Kai Tzu-iunn Ong, Seung-won Hwang, and Jinyoung Yeo. 2024. Coffee: Boost Your Code LLMs by Fixing Bugs with Feedback. arXiv:2311.07215 [cs] — [arXiv:2311.07215](https://arxiv.org/abs/2311.07215) find
  44. Niklas Muennighoff, Qian Liu, Armel Randy Zebaze, Qinkai Zheng, Binyuan Hui, Terry Yue Zhuo, Swayam Singh, Xiangru Tang, Leandro Von Werra, and Shayne Longpre. 2023. OctoPack: Instruction Tuning Code Large Language Models. In The Twelfth International Conference on Learning Representations. find
  45. Ansong Ni, Miltiadis Allamanis, Arman Cohan, Yinlin Deng, Kensen Shi, Charles Sutton, and Pengcheng Yin. 2024. NExT: Teaching Large Language Models to Reason about Code Execution. arXiv:2404.14662 find
  46. Ansong Ni, Srini Iyer, Dragomir Radev, Ves Stoyanov, Wen-tau Yih, Sida I. Wang, and Xi Victoria Lin. 2023. LEVER: Learning to Verify Language-to-Code Generation with Execution. arXiv:2302.08468 doi:10.48550/arXiv.2302.08468
  47. Theo X. Olausson, Jeevana Priya Inala, Chenglong Wang, Jianfeng Gao, and Armando Solar-Lezama. 2023. Is Self-Repair a Silver Bullet for Code Generation?. In The Twelfth International Conference on Learning Representations. find
  48. OpenAI. 2023. GPT-4 Technical Report. arXiv:2303.08774 [cs] doi:10.48550/arXiv. 2303.08774
  49. Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D. Manning, Stefano Ermon, and Chelsea Finn. 2023. Direct Preference Optimization: Your Language Model Is Secretly a Reward Model. In Thirty-Seventh Conference on Neural Information Processing Systems.
  50. Max Schäfer, Sarah Nadi, Aryaz Eghbali, and Frank Tip. 2024. An Empirical Evaluation of Using Large Language Models for Automated Unit Test Generation. IEEE Transactions on Software Engineering 50, 1 (Jan. 2024), 85–105. doi:10.1109/ TSE.2023.3334955 find
  51. Yuchen Shao, Yuheng Huang, Jiawei Shen, Lei Ma, Ting Su, and Chengcheng Wan. 2025. Are LLMs Correctly Integrated into Software Systems?. In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE, 1178–1190. find
  52. Yuling Shi, Hongyu Zhang, Chengcheng Wan, and Xiaodong Gu. 2024. Between Lines of Code: Unraveling the Distinct Patterns of Machine and Human Programmers. In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE Computer Society (2024), 51–62. find
  53. Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik R. Narasimhan, and Shunyu Yao. 2023. Reflexion: Language Agents with Verbal Reinforcement Learning. In Thirty-Seventh Conference on Neural Information Processing Systems.
  54. Qwen Team. 2023. Qwen Technical Report. arXiv:2309.16609 [cs] doi:10.48550/ arXiv.2309.16609
  55. Runchu Tian, Yining Ye, Yujia Qin, Xin Cong, Yankai Lin, Yinxu Pan, Yesai Wu, Zhiyuan Liu, and Maosong Sun. 2024. DebugBench: Evaluating Debugging Capability of Large Language Models. arXiv:2401.04621 doi:10.48550/arXiv.2401. 04621 find
  56. Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, Aurelien Rodriguez, Armand Joulin, Edouard Grave, and Guillaume Lample. 2023. LLaMA: Open and Efficient Foundation Language Models. arXiv:23…
  57. Changjie Wang, Mariano Scazzariello, Anoud Alshnakat, Roberto Guanciale, Dejan Kostić, and Marco Chiesa. 2025. Dissect-and-Restore: AI-based Code Verification with Transient Refactoring. arXiv preprint arXiv:2510.25406 (2025). — [arXiv:2510.25406](https://arxiv.org/abs/2510.25406) find
  58. Song Wang, Nishtha Shrestha, Abarna Kucheri Subburaman, Junjie Wang, Moshi Wei, and Nachiappan Nagappan. 2021. Automatic Unit Test Generation for Machine Learning Libraries: How Far Are We?. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE). 1548–1560. doi:10.1109/ICSE439… — [doi:10.1109/icse43902](https://doi.org/10.1109/icse43902) find
  59. Jiaxin Wen, Ruiqi Zhong, Pei Ke, Zhihong Shao, Hongning Wang, and Minlie Huang. 2024. Learning Task Decomposition to Assist Humans in Competitive Programming. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Lun-Wei Ku, Andre Martins… find
  60. S. N. Woodfield, H. E. Dunsmore, and V. Y. Shen. 1981. The Effect of Modularization and Comments on Program Comprehension. In Proceedings of the 5th International Conference on Software Engineering (ICSE ’81). IEEE Press, San Diego, California, USA, 215–223. find
  61. Chunqiu Steven Xia, Yuxiang Wei, and Lingming Zhang. 2023. Automated Program Repair in the Era of Large Pre-trained Language Models. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 1482– 1494. doi:10.1109/ICSE48619.2023.00129 — [doi:10.1109/icse48619.2023.00129](https://doi.org/10.1109/icse48619.2023.00129) find
  62. Chunqiu Steven Xia and Lingming Zhang. 2024. Automated Program Repair via Conversation: Fixing 162 out of 337 Bugs for $0.42 Each Using ChatGPT. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. ACM, Vienna Austria, 819–831. doi:10.1145/3650212.3680323 — [doi:10.1145/3650212.3680323](https://doi.org/10.1145/3650212.3680323) find
  63. Qi Xin, Haojun Wu, Jinran Tang, Xinyu Liu, Steven P. Reiss, and Jifeng Xuan. 2024. Detecting, Creating, Repairing, and Understanding Indivisible Multi-Hunk Bugs. Reproduction Package for Article Detecting, Creating, Repairing, and Understanding Indivisible Multi-Hunk Bugs 1, FSE (July 2024), 121:274… find
  64. Michihiro Yasunaga and Percy Liang. 2021. Break-It-Fix-It: Unsupervised Learning for Program Repair. In Proceedings of the 38th International Conference on Machine Learning. PMLR, 11941–11952. find
  65. Xin Yin, Chao Ni, Shaohua Wang, Zhenhao Li, Limin Zeng, and Xiaohu Yang. 2024. ThinkRepair: Self-Directed Automated Program Repair. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA 2024). Association for Computing Machinery, New York, NY, USA, 12… — [doi:10.1145/3650212.3680359](https://doi.org/10.1145/3650212.3680359) find
  66. Eric Zelikman, Qian Huang, Gabriel Poesia, Noah Goodman, and Nick Haber. 2023. Parsel: Algorithmic Reasoning with Language Models by Composing Decompositions. In Thirty-Seventh Conference on Neural Information Processing Systems. find
  67. Andreas Zeller. 2009. Why Programs Fail: A Guide to Systematic Debugging. Morgan Kaufmann. find
  68. Kechi Zhang, Jia Li, Ge Li, Xianjie Shi, and Zhi Jin. 2024. CodeAgent: Enhancing Code Generation with Tool-Integrated Agent Systems for Real-World Repo-level Coding Challenges. arXiv:2401.07339
  69. Kechi Zhang, Zhuo Li, Jia Li, Ge Li, and Zhi Jin. 2023. Self-Edit: Fault-Aware Code Editor for Code Generation. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, Toronto, Canada, 769–787. doi… find
  70. Quanjun Zhang, Chunrong Fang, Tongke Zhang, Bowen Yu, Weisong Sun, and Zhenyu Chen. 2024. Gamma: Revisiting Template-based Automated Program Repair via Mask Prediction. In Proceedings of the 38th IEEE/ACM International Conference on Automated Software Engineering (ASE ’23). IEEE Press, Echternach, L… — [doi:10.1109/ase56229.2023.00063](https://doi.org/10.1109/ase56229.2023.00063) find
  71. Shun Zhang, Zhenfang Chen, Yikang Shen, Mingyu Ding, Joshua B. Tenenbaum, and Chuang Gan. 2022. Planning with Large Language Models for Code Generation. In The Eleventh International Conference on Learning Representations. find
  72. Yuwei Zhang, Zhi Jin, Ying Xing, Ge Li, Fang Liu, Jiaxin Zhu, Wensheng Dou, and Jun Wei. 2025. PATCH: Empowering Large Language Model with Programmer-Intent Guidance and Collaborative-Behavior Simulation for Automatic Bug Fixing. ACM Trans. Softw. Eng. Methodol. (Feb. 2025). doi:10.1145/3718739 — [doi:10.1145/3718739](https://doi.org/10.1145/3718739) find
  73. Tianyu Zheng, Ge Zhang, Tianhao Shen, Xueling Liu, Bill Yuchen Lin, Jie Fu, Wenhu Chen, and Xiang Yue. 2024. OpenCodeInterpreter: Integrating Code Generation with Execution and Refinement. arXiv:2402.14658 doi:10.48550/arXiv. 2402.14658 find
  74. Wenqing Zheng, S. P. Sharan, Ajay Kumar Jaiswal, Kevin Wang, Yihan Xi, Dejia Xu, and Zhangyang Wang. 2023. Outline, Then Details: Syntactically Guided Coarse-To-Fine Code Generation. In Proceedings of the 40th International Conference on Machine Learning. PMLR, 42403–42419. find
  75. Li Zhong, Zilong Wang, and Jingbo Shang. 2024. Debug like a Human: A Large Language Model Debugger via Verifying Runtime Execution Step by Step. In Findings of the Association for Computational Linguistics ACL 2024, Lun-Wei Ku, Andre Martins, and Vivek Srikumar (Eds.). Association for Computational… find
  76. Qihao Zhu, Zeyu Sun, Wenjie Zhang, Yingfei Xiong, and Lu Zhang. 2023. Tare: Type-Aware Neural Program Repair. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 1443–1455. doi:10.1109/ICSE48619.2023. 00126 — [doi:10.1109/icse48619.2023](https://doi.org/10.1109/icse48619.2023) find
  77. Daniel M. Ziegler, Nisan Stiennon, Jeffrey Wu, Tom B. Brown, Alec Radford, Dario Amodei, Paul Christiano, and Geoffrey Irving. 2020. Fine-Tuning Language Models from Human Preferences. arXiv:1909.08593 find

Updated

↑ back to top

This page in Markdown → https://md.research.elamur.ai/free/en/papers/shi-2024-code-correctness-closing-last-mile/