pith. machine review for the scientific record. sign in

arxiv: 2604.16198 · v1 · submitted 2026-04-17 · 💻 cs.SE

Recognition: unknown

Bridging the Gap between User Intent and LLM: A Requirement Alignment Approach for Code Generation

Jia Li , Ruiqi Bai , Yangkang Luo , Yiran Zhang , Wentao Yang , Zeyu Sun , Tiankuo Zhao , Dongming Jin
show 2 more authors
Lei Li Zhi Jin
Authors on Pith no claims yet

Pith reviewed 2026-05-10 08:10 UTC · model grok-4.3

classification 💻 cs.SE
keywords code generationrequirement alignmentlarge language modelsLLM code generationsoftware engineeringiterative refinementAI programming assistants
0
0 comments X

The pith

Aligning user requirements to LLMs improves the correctness of generated code.

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

LLMs sometimes misinterpret user requirements when asked to write code, even when the requirements are clearly stated. REA-Coder detects sections of the requirement that are likely to cause such misalignment, rewrites them into a form the model handles better, generates code from the revised version, and then checks whether the output matches the original intent. If the check fails, the process repeats with further alignment until the code is correct or a limit is reached. This input-side fix produces higher success rates than prior reasoning or refinement strategies across several models and benchmarks. The work shows that the gap between stated intent and model understanding can be narrowed without retraining or replacing the underlying LLM.

Core claim

REA-Coder first identifies the requirement content that does not align with LLMs and aligns the requirements. Then, based on the aligned requirements, LLMs generate code and further verify whether the generated code aligns with the requirements, iterating this process of requirement alignment and code generation until generating correct code or achieving the maximum number of iterations.

What carries the argument

The iterative requirement alignment process that detects and rewrites mismatched parts of the user specification before code generation and after verification.

Load-bearing premise

That misaligned requirement content can be identified and rewritten reliably enough to raise final code correctness rather than adding new errors.

What would settle it

Running the full alignment-plus-generation loop on a set of requirements that are already perfectly matched to the LLM's understanding and finding no gain or a loss in correctness would show the alignment step is not the source of improvement.

Figures

Figures reproduced from arXiv: 2604.16198 by Dongming Jin, Jia Li, Lei Li, Ruiqi Bai, Tiankuo Zhao, Wentao Yang, Yangkang Luo, Yiran Zhang, Zeyu Sun, Zhi Jin.

Figure 1
Figure 1. Figure 1: An example of how requirement alignment im [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Overview of REA-Coder [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Core requirement dimensions in REA-Coder. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Pass@1 across iterations for REA-Coder and iterative baselines. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Case Study of REA-Coder: An example of requirement alignment corrects an edge-case misunderstanding. [PITH_FULL_IMAGE:figures/full_fig_p009_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Effectiveness of requirement dimension. code generation pipeline, rather than relying primarily on execution feedback after code has already been produced. Compared with methods that correct errors only after observing failed executions, REA-Coder enhances the requirement before the code generation, allowing the model to generate code on an aligned requirement. 6.2 Influence of Dimension To better understa… view at source ↗
Figure 7
Figure 7. Figure 7: Case Study of REA-Coder: An example of requirement alignment verification corrects output-order misalignment. [PITH_FULL_IMAGE:figures/full_fig_p011_7.png] view at source ↗
read the original abstract

Code generation refers to automatically producing executable programs from user requirements. Recently, researchers have explored approaches to enhance the correctness of generated code with advanced large language models. Although achieving improvements, existing approaches focus on designing reasoning strategies or post-refinement methods to enhance code generation performance. Despite their differences, all these methods share a common assumption: the LLM can correctly understand the given requirement. However, this assumption does not always hold. To fill this gap, we propose REA-Coder, a requirement alignment approach to enhance the code generation performance of LLMs. REA-Coder involves first identifying the requirement content that does not align with LLMs and aligning the requirements. Then, based on the aligned requirements, LLMs generate code and further verify whether the generated code aligns with the requirements, iterating this process of requirement alignment and code generation until generating correct code or achieving the maximum number of iterations. Experimental results show that REA-Coder outperforms all advanced baselines on four LLMs across five programming benchmarks. Concretely, REA-Coder achieves average improvements of 7.93%, 30.25%, 26.75%, 8.59%, and 8.64% on the five benchmark datasets, demonstrating the effectiveness of requirement alignment for improving the code generation performance of LLMs.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

3 major / 1 minor

Summary. The manuscript presents REA-Coder, a requirement alignment approach for LLM-based code generation. It identifies misaligned requirement content, aligns it, generates code, verifies alignment with requirements, and iterates this process until correct code is obtained or the maximum number of iterations is reached. The paper claims that this method outperforms advanced baselines across four LLMs and five programming benchmarks, with specific average improvements of 7.93%, 30.25%, 26.75%, 8.59%, and 8.64% on the respective datasets.

Significance. If the central mechanism of reliable requirement alignment holds without circularity or introduced errors, the work could be significant in shifting focus from post-generation refinement to pre-generation requirement understanding in code generation tasks. The multi-LLM, multi-benchmark evaluation provides a broad empirical basis, though the lack of detailed validation for the alignment step limits the strength of the conclusions.

major comments (3)
  1. [The REA-Coder Approach] The requirement alignment identification step (described in the proposed approach) relies on prompting the target LLM to detect and rewrite misaligned content. This risks circularity, as the same model that misunderstands the original requirement may miss real misalignments or introduce spurious ones, making it unclear whether reported gains arise from genuine alignment or simply from additional prompting and verification rounds.
  2. [Experimental Results] The experimental results report average improvements of 7.93%, 30.25%, 26.75%, 8.59%, and 8.64% but provide no statistical significance tests, details on baseline implementations or reproductions, or typical iteration counts needed for success. This undermines assessment of whether the gains are robust across the five benchmarks and four LLMs.
  3. [Verification and Iteration Process] The iterative verification step assumes an effective check for code-requirement alignment, yet the manuscript does not specify the verification mechanism (e.g., test execution, LLM judgment, or human review) or how false positives/negatives in verification are handled, which is load-bearing for the claim of producing correct code.
minor comments (1)
  1. [Abstract] The abstract would benefit from naming the five specific benchmarks to contextualize the percentage improvements for readers.

Simulated Author's Rebuttal

3 responses · 0 unresolved

We thank the referee for the constructive and detailed comments. We address each major comment point by point below, indicating the revisions we will make to strengthen the manuscript.

read point-by-point responses

  1. Referee: [The REA-Coder Approach] The requirement alignment identification step (described in the proposed approach) relies on prompting the target LLM to detect and rewrite misaligned content. This risks circularity, as the same model that misunderstands the original requirement may miss real misalignments or introduce spurious ones, making it unclear whether reported gains arise from genuine alignment or simply from additional prompting and verification rounds.

    Authors: We acknowledge the risk of circularity when the same LLM performs alignment. The design intent is that explicit rewriting surfaces implicit misunderstandings for subsequent verification to catch. To demonstrate that gains stem from alignment rather than extra rounds, we will add an ablation study isolating the alignment component and a case analysis of potential introduced errors in the revised manuscript. revision: partial

  2. Referee: [Experimental Results] The experimental results report average improvements of 7.93%, 30.25%, 26.75%, 8.59%, and 8.64% but provide no statistical significance tests, details on baseline implementations or reproductions, or typical iteration counts needed for success. This undermines assessment of whether the gains are robust across the five benchmarks and four LLMs.

    Authors: We agree these elements are needed for robust evaluation. In the revision we will add statistical significance tests (paired t-tests) for all reported improvements, expand the baseline implementation details with reproduction notes and hyperparameters, and include average iteration counts plus distributions per benchmark and LLM. revision: yes

  3. Referee: [Verification and Iteration Process] The iterative verification step assumes an effective check for code-requirement alignment, yet the manuscript does not specify the verification mechanism (e.g., test execution, LLM judgment, or human review) or how false positives/negatives in verification are handled, which is load-bearing for the claim of producing correct code.

    Authors: The current manuscript describes verification at a high level. We will revise Section 3 to specify the exact mechanism (LLM judgment against the aligned requirement plus execution tests on benchmarks providing them), include the prompt templates in an appendix, and add analysis of false-positive/negative handling via multi-query consensus and iteration limits. revision: yes

Circularity Check

0 steps flagged

Empirical engineering method with no derivation chain or self-referential reductions

full rationale

The paper describes REA-Coder as an iterative engineering procedure: identify misaligned requirement content, rewrite it, generate code from the aligned version, and verify/iterate. No equations, fitted parameters, or first-principles predictions appear in the provided text. Reported gains are measured against external benchmarks and baselines rather than being forced by internal definitions or self-citations. The approach is self-contained as an empirical intervention whose validity rests on experimental outcomes, not on any step that reduces by construction to its own inputs.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

The paper is an empirical engineering contribution. It introduces no new mathematical axioms, free parameters, or postulated entities beyond the standard assumption that LLMs can be prompted to rewrite text.

pith-pipeline@v0.9.0 · 5560 in / 1177 out tokens · 21589 ms · 2026-05-10T08:10:02.955703+00:00 · methodology

discussion (0)

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

Reference graph

Works this paper leans on

49 extracted references · 19 canonical work pages · 7 internal anchors

  1. [1]

    Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. 2021. Program synthesis with large language models.arXiv preprint arXiv:2108.07732(2021)

    work page internal anchor Pith review Pith/arXiv arXiv 2021

  2. [2]

    Ruisheng Cao, Mouxiang Chen, Jiawei Chen, Zeyu Cui, Yunlong Feng, Binyuan Hui, Yuheng Jing, Kaixin Li, Mingze Li, Junyang Lin, et al. 2026. Qwen3-Coder- Next Technical Report.arXiv preprint arXiv:2603.00729(2026)

    work page arXiv 2026

  3. [3]

    Bei Chen, Fengji Zhang, Anh Nguyen, Daoguang Zan, Zeqi Lin, Jian-Guang Lou, and Weizhu Chen. 2022. Codet: Code generation with generated tests.arXiv preprint arXiv:2207.10397(2022)

    work page arXiv 2022

  4. [4]

    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)

    work page internal anchor Pith review Pith/arXiv arXiv 2021

  5. [5]

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

    work page internal anchor Pith review arXiv 2023

  6. [6]

    Xiancai Chen, Zhengwei Tao, Kechi Zhang, Changzhi Zhou, Xinyu Zhang, Wanli Gu, Yuanpeng He, Mengdi Zhang, Xunliang Cai, Haiyan Zhao, and Zhi Jin

  7. [7]

    Revisit Self-Debugging with Self-Generated Tests for Code Generation. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Mohammad Taher Pilehvar (Eds.). Association for Computational Linguistics, Vienna, Austria, 18003–18023. doi:10.18653/v1...

    work page doi:10.18653/v1/2025.acl-long.881 2025

  8. [8]

    2011.Recommended Practice for Software Requirements Specifications (IEEE Std 830-1998)

    John Doe. 2011.Recommended Practice for Software Requirements Specifications (IEEE Std 830-1998). IEEE, New York

    2011

  9. [9]

    Yihong Dong, Xue Jiang, Zhi Jin, and Ge Li. 2024. Self-collaboration code genera- tion via chatgpt.ACM Transactions on Software Engineering and Methodology33, 7 (2024), 1–38

    2024

  10. [10]

    Tulsee Doshi and Gemini Team. 2025. Gemini 3 Flash: frontier intelligence built for speed. https://blog.google/products-and-platforms/products/gemini/gemini- 3-flash. Google Blog Post

    2025

  11. [11]

    Shihan Dou, Yan Liu, Haoxiang Jia, Enyu Zhou, Limao Xiong, Junjie Shan, Caishuang Huang, Xiao Wang, Xiaoran Fan, Zhiheng Xi, et al. 2024. Stepcoder: improving code generation with reinforcement learning from compiler feedback. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 4571–4585

    2024

  12. [12]

    Martin Glinz. 2000. Problems and deficiencies of UML as a requirements specifi- cation language. InTenth International Workshop on Software Specification and Design (IWSSD-10). IEEE, 11–22

    2000

  13. [13]

    Sol Greenspan, John Mylopoulos, and Alex Borgida. 1994. On formal requirements modeling languages: RML revisited. InProceedings of 16th International Conference on Software Engineering. IEEE, 135–147

    1994

  14. [14]

    Dejan Grubisic, Chris Cummins, Volker Seeker, and Hugh Leather. 2024. Compiler generated feedback for large language models.arXiv preprint arXiv:2403.14714 (2024)

    work page arXiv 2024

  15. [15]

    Yewei Han and Chen Lyu. 2025. Multi-stage guided code generation for large language models.Engineering Applications of Artificial Intelligence139 (2025), 109491

    2025

  16. [16]

    Dan Hendrycks, Steven Basart, Saurav Kadavath, Mantas Mazeika, Akul Arora, Ethan Guo, Collin Burns, Samir Puranik, Horace He, Dawn Song, et al . 2021. Measuring coding challenge competence with apps (2021).URL https://arxiv. org/abs/2105.099387 (2021)

    work page internal anchor Pith review arXiv 2021

  17. [17]

    Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, et al

  18. [18]

    InThe twelfth international conference on learning representations

    MetaGPT: Meta programming for a multi-agent collaborative framework. InThe twelfth international conference on learning representations

  19. [19]

    Dong Huang, Qingwen Bu, Yuhao Qing, and Heming Cui. 2023. Codecot: Tack- ling code syntax errors in cot reasoning for code generation.arXiv preprint arXiv:2308.08784(2023)

    work page arXiv 2023

  20. [20]

    Dong Huang, Jie M Zhang, Michael Luck, Qingwen Bu, Yuhao Qing, and Heming Cui. [n. d.]. Agentcoder: Multi-agent-based code generation with iterative testing and optimisation, 2024.URL https://arxiv. org/abs/2312.13010([n. d.])

    work page internal anchor Pith review arXiv 2024

  21. [21]

    Md Ashraful Islam, Mohammed Eunus Ali, and Md Rizwan Parvez. 2025. Codesim: Multi-agent code generation and problem solving through simulation-driven planning and debugging. InFindings of the Association for Computational Lin- guistics: NAACL 2025. 5113–5139

    2025

  22. [22]

    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. InThe Thirteenth International Conference on Learning Repre- sentations. https://openreview.net/forum?id=chfJJYC3iL

    2025

  23. [23]

    Haoxiang Jia, Robbie Morris, He Ye, Federica Sarro, and Sergey Mechtaev. 2025. Automated Repair of Ambiguous Problem Descriptions for LLM-Based Code Generation.arXiv preprint arXiv:2505.07270(2025)

    work page arXiv 2025

  24. [24]

    Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sunghun Kim. 2026. A survey on large language models for code generation.ACM Transactions on Software Engineering and Methodology35, 2 (2026), 1–72

    2026

  25. [25]

    Xue Jiang, Yihong Dong, Lecheng Wang, Zheng Fang, Qiwei Shang, Ge Li, Zhi Jin, and Wenpin Jiao. 2024. Self-planning code generation with large language models.ACM Transactions on Software Engineering and Methodology33, 7 (2024), 1–30

    2024

  26. [26]

    Mohammad Abdullah Matin Khan, M Saiful Bari, Xuan Long Do, Weishi Wang, Md Rizwan Parvez, and Shafiq Joty. 2024. Xcodeeval: An execution-based large scale multilingual multitask benchmark for code understanding, generation, trans- lation and retrieval. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Lon...

    2024

  27. [27]

    Hung Le, Yue Wang, Akhilesh Deepak Gotmare, Silvio Savarese, and Steven Chu Hong Hoi. 2022. Coderl: Mastering code generation through pretrained Conference acronym ’XX, June 03–05, 2018, Woodstock, NY Trovato et al. models and deep reinforcement learning.Advances in Neural Information Pro- cessing Systems35 (2022), 21314–21328

    2022

  28. [28]

    Jia Li, Ge Li, Yongmin Li, and Zhi Jin. 2025. Structured chain-of-thought prompt- ing for code generation.ACM Transactions on Software Engineering and Method- ology34, 2 (2025), 1–23

    2025

  29. [29]

    Jia Li, Ge Li, Zhuo Li, Zhi Jin, Xing Hu, Kechi Zhang, and Zhiyi Fu. 2023. Codeed- itor: Learning to edit source code with pre-trained models.ACM Transactions on Software Engineering and Methodology32, 6 (2023), 1–22

    2023

  30. [30]

    Shen Li, Li Huang, Shaoxiong Zhan, Weifeng Sun, Tao Yin, Zhongxin Liu, and Meng Yan. 2025. Intention Chain-of-Thought Prompting with Dynamic Routing for Code Generation.arXiv preprint arXiv:2512.14048(2025)

    work page arXiv 2025

  31. [31]

    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.Science378, 6624 (2022), 1092–1097

    2022

  32. [32]

    Aixin Liu, Aoxue Mei, Bangcai Lin, Bing Xue, Bingxuan Wang, Bingzheng Xu, Bochao Wu, Bowei Zhang, Chaofan Lin, Chen Dong, et al . 2025. Deepseek- v3. 2: Pushing the frontier of open large language models.arXiv preprint arXiv:2512.02556(2025)

    work page internal anchor Pith review arXiv 2025

  33. [33]

    Kehao Mao, Baokun Hu, Ruixin Lin, Zewen Li, Guanyu Lu, and Zhengyu Zhang

  34. [34]

    Blueprint2Code: a multi-agent pipeline for reliable code generation via blueprint planning and repair.Frontiers in Artificial Intelligence8 (2025), 1660912

    2025

  35. [35]

    Fangwen Mu, Lin Shi, Song Wang, Zhuohao Yu, Binquan Zhang, Chenxue Wang, Shichao Liu, and Qing Wang. 2023. Clarifygpt: Empowering llm-based code generation with intention clarification.arXiv preprint arXiv:2310.10996(2023)

    work page arXiv 2023

  36. [36]

    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)

    work page arXiv 2023

  37. [37]

    Yun Peng, Akhilesh Deepak Gotmare, Michael R Lyu, Caiming Xiong, Silvio Savarese, and Doyen Sahoo. 2025. Perfcodegen: Improving performance of llm generated code with execution feedback. In2025 IEEE/ACM Second International Conference on AI Foundation Models and Software Engineering (Forge). IEEE, 1–13

    2025

  38. [38]

    Chen Qian, Wei Liu, Hongzhang Liu, Nuo Chen, Yufan Dang, Jiahao Li, Cheng Yang, Weize Chen, Yusheng Su, Xin Cong, et al. 2024. Chatdev: Communicative agents for software development. InProceedings of the 62nd annual meeting of the association for computational linguistics (volume 1: Long papers). 15174–15186

    2024

  39. [39]

    Aaditya Singh, Adam Fry, Adam Perelman, Adam Tart, Adi Ganesh, Ahmed El-Kishky, Aidan McLaughlin, Aiden Low, AJ Ostrow, Akhila Ananthram, et al

  40. [40]

    Openai gpt-5 system card.arXiv preprint arXiv:2601.03267(2025)

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  41. [41]

    Zhao Tian and Junjie Chen. 2025. Aligning Requirement for Large Language Model’s Code Generation.arXiv preprint arXiv:2509.01313(2025)

    work page arXiv 2025

  42. [42]

    Zhao Tian, Junjie Chen, and Xiangyu Zhang. 2025. Fixing Large Language Models’ Specification Misunderstanding for Better Code Generation. In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE).IEEE Computer Society(2025), 645–645

    2025

  43. [43]

    Xin Wang, Yasheng Wang, Yao Wan, Fei Mi, Yitong Li, Pingyi Zhou, Jin Liu, Hao Wu, Xin Jiang, and Qun Liu. 2022. Compilable Neural Code Generation with Compiler Feedback. InFindings of the Association for Computational Linguistics: ACL 2022, Smaranda Muresan, Preslav Nakov, and Aline Villavicencio (Eds.). Association for Computational Linguistics, Dublin, ...

    2022

  44. [44]

    Huan Zhang, Wei Cheng, Yuhan Wu, and Wei Hu. 2024. A pair programming framework for code generation via multi-plan exploration and feedback-driven refinement. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering. 1319–1331

    2024

  45. [45]

    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. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 13643–13658

    2024

  46. [46]

    Kechi Zhang, Zhuo Li, Jia Li, Ge Li, and Zhi Jin. 2023. Self-edit: Fault-aware code editor for code generation. InProceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 769–787

    2023

  47. [47]

    Shun Zhang, Zhenfang Chen, Yikang Shen, Mingyu Ding, Joshua B Tenenbaum, and Chuang Gan. 2023. Planning with large language models for code generation. arXiv preprint arXiv:2303.05510(2023)

    work page arXiv 2023

  48. [48]

    Tianyu Zheng, Ge Zhang, Tianhao Shen, Xueling Liu, Bill Yuchen Lin, Jie Fu, Wenhu Chen, and Xiang Yue. 2024. Opencodeinterpreter: Integrating code gen- eration with execution and refinement. InFindings of the Association for Compu- tational Linguistics: ACL 2024. 12834–12859

    2024

  49. [49]

    Changzhi Zhou, Xinyu Zhang, Dandan Song, Xiancai Chen, Wanli Gu, Huipeng Ma, Yuhang Tian, Mengdi Zhang, and Linmei Hu. 2025. Refinecoder: Iterative improving of large language models via adaptive critique refinement for code generation.arXiv preprint arXiv:2502.09183(2025). Received 20 February 2007; revised 12 March 2009; accepted 5 June 2009

    work page arXiv 2025