Self-collaboration code generation via ChatGPT
Open accessAbstract
Although large language models (LLMs) have demonstrated remarkable code-generation ability, they still struggle with complex tasks. In real-world software development, humans usually tackle complex tasks through collaborative teamwork, a strategy that significantly controls development complexity and enhances software quality. Inspired by this, we present a self-collaboration framework for code generation employing LLMs, exemplified by ChatGPT. Specifically, through role instructions, (1) Multiple LLM agents act as distinct “experts,” each responsible for a specific subtask within a complex task; (2) Specify the way to collaborate and interact, so that different roles form a virtual team to facilitate each other’s work, ultimately the virtual team addresses code generation tasks collaboratively without the need for human intervention. To effectively organize and manage this virtual team, we incorporate software-development methodology into the framework. Thus, we assemble an elementary team consisting of three LLM roles (i.e., analyst, coder, and tester) responsible for software development’s analysis, coding, and testing stages. We conduct comprehensive experiments on various code-generation benchmarks. Experimental results indicate that self-collaboration code generation relatively improves 29.9–47.1% Pass@1 compared to the base LLM agent. Moreover, we showcase that self-collaboration could potentially enable LLMs to efficiently handle complex repository-level tasks that are not readily solved by the single LLM agent.
The claims and statistics of this paper haven’t been checked yet.
Run the check — free, no account needed. It reads the open-access text and checks the sources it cites.
Integrity signals
Registry
Cites
Statistics
Claims the paper makes
The claims and statistics of this paper haven’t been checked yet.
Run the check — free, no account needed. It reads the open-access text and checks the sources it cites.
Claims other papers make about this one
Each is checked against this paper’s own text: does it say what the citing paper says it does?
Multi-agent code-centric systems can be reviewed through agent roles, collaboration modes, and workflow topologies.
“We review multi-agent code-centric systems through agent roles such as manager, planner, coder, reviewer, and tester; collaboration modes such as programming, repair, debate, red-teaming, and adversarial interaction; and workflow topologies ranging from centralized coordination to distributed or streaming collaboration [54, 55, 56].”
From Code as Agent Harness (2026) · cites this paper as [56]
The Introduction (page not provided) describes analyst, coder, and tester agents working through a sequential code-generation workflow with feedback; Section 3 also describes code repair. This supports examples of roles, collaboration, and workflow, but the paper does not present the claimed range of modes—such as debate, red-teaming, and adversarial interaction—or topologies from centralized to distributed or streaming collaboration. (LLM, conf=0.87)
Experimental — accuracy not yet measuredSelf-Collaboration is among the first systems to explicitly name and invoke the blackboard architecture, establishing a shared memory from which all three roles read and write.
“Self-Collaboration [56] is among the first systems to explicitly name and invoke the blackboard architecture, establishing a shared memory from which all three roles read and write.”
From Code as Agent Harness (2026) · cites this paper as [56]
Section 2.2 (page unavailable) explicitly describes a shared blackboard and shows information being retrieved from and added to it; the Introduction identifies the three roles as analyst, coder, and tester. The paper does not establish that Self-Collaboration was among the first systems to use this architecture. (LLM, conf=0.86)
Experimental — accuracy not yet measuredSelf-Collaboration and QualityFlow demonstrate that LLM-simulated execution can achieve 98%+ precision and recall in predicting actual outcomes without running code.
“Self-Collaboration [56] and QualityFlow [253] demonstrate that LLM-simulated execution can achieve 98%+ precision and recall in predicting actual outcomes without running code.”
From Code as Agent Harness (2026) · cites this paper as [56]
Section 3 (page unavailable) says the tester uses the model to simulate testing rather than executing code with a compiler and test cases. Section 4.3 (page unavailable) says the tester can resolve some mistakes without compiler results. The paper does not report 98%+ precision and recall for predicting actual outcomes, so it does not support that quantitative claim. (LLM, conf=0.88)
Experimental — accuracy not yet measured
Self-check
Percentages, sums and reported differences re-computed from the paper’s own numbers.
The self-check needs the paper’s full text.
Cites
Language Models are Few-Shot Learners
Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al. (2020) · arXiv · doi:10.48550/arxiv.2005.14165 · Cited by 23,372 · see citing works
Liu, P., Yuan, W., Fu, J., Jiang, Z., Hayashi, H., & Neubig, G. (2023) · ACM Computing Surveys · doi:10.1145/3560815 · Cited by 4,361 · see citing works
Liu, P., Yuan, W., Fu, J., Jiang, Z., Hayashi, H., & Neubig, G. (2021) · arXiv · doi:10.48550/arxiv.2107.13586 · Cited by 4,352 · see citing works
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., Chi, E., Le, Q., & Zhou, D. (2022) · arXiv · doi:10.48550/arxiv.2201.11903 · Cited by 4,263 · cited 1× · see citing works
“Recent studies have shown that well-designed prompting methods, such as chain-of-thought prompting (CoT) [Wei et al., 2022] and zero-shot CoT [Kojima et al.”
Training Language Models to Follow Instructions with Human Feedback
Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., Zhang, C., Agarwal, S., Slama, K., Ray, A., et al. (2022) · Advances in Neural Information Processing Systems 35 · doi:10.52202/068431-2011 · Cited by 3,117 · cited 1× · see citing works
“Add 𝑠 𝑡 to B .”
Self-citationLlama 2: Open Foundation and Fine-Tuned Chat Models
Touvron, H., Martin, L., Stone, K., Albert, P., Almahairi, A., Babaei, Y., Bashlykov, N., Batra, S., Bhargava, P., Bhosale, S., et al. (2023) · arXiv · doi:10.48550/arxiv.2307.09288 · Cited by 2,604 · cited 2× · see citing works
“In this section, we further analyze the errors generated by self-collaboration and the cost of self-collaboration compared to other prompting approaches.”
InfluentialPaLM: Scaling Language Modeling with Pathways
Chowdhery, A., Narang, S., Devlin, J., Bosma, M., Mishra, G., Roberts, A., Barham, P., Chung, H. W., Sutton, C., Gehrmann, S., et al. (2022) · arXiv · doi:10.48550/arxiv.2204.02311 · Cited by 2,590 · see citing works
Large language models are zero-shot reasoners
Kojima, T., Gu, S. (., Reid, M., Matsuo, Y., & Iwasawa, Y. (2022) · Advances in Neural Information Processing Systems 35 · doi:10.52202/068431-1613 · Cited by 2,013 · cited 7× · see citing works
“This kind of baseline includes: —Chain-of-thought (CoT) [57] generates a chain of thought for each question and then generates the corresponding code.”
InfluentialThe Wisdom of Teams: Creating the High-Performance Organization
Katzenbach, J., & Smith, D. K. (1992) · Choice Reviews Online · doi:10.5860/choice.30-4489 · Cited by 2,013 · cited 1× · see citing works
“The benefits of collaborative teamwork are manifold: (1) It breaks down complex tasks into smaller subtasks, making the entire code generation process more efficient and controllable.”
Scaling Instruction-Finetuned Language Models
Chung, H. W., Hou, L., Longpre, S., Zoph, B., Tay, Y., Fedus, W., Li, Y., Wang, X., Dehghani, M., Brahma, S., et al. (2022) · arXiv · doi:10.48550/arxiv.2210.11416 · Cited by 1,441 · cited 1× · see citing works
“Consequently, it is prevalent to control LLM generation using instructions or prompts [11, 40, 41].”
Evaluating Large Language Models Trained on Code
Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. D. O., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G., et al. (2021) · arXiv · doi:10.48550/arxiv.2107.03374 · Cited by 1,436 · cited 2× · see citing works
“Recently, code generation has made substantial advancements in both academic and industrial domains [8, 16, 30, 49].”
Toolformer: Language Models Can Teach Themselves to Use Tools
Schick, T., Dwivedi-Yu, J., Dessì, R., Raileanu, R., Lomeli, M., Zettlemoyer, L., Cancedda, N., & Scialom, T. (2023) · arXiv · doi:10.48550/arxiv.2302.04761 · Cited by 1,150 · cited 1× · see citing works
“However, considering the high labor expenses of software development teams, the cost-effectiveness of self-collaboration is obvious.”
Competition-level code generation with AlphaCode
Li, Y., Choi, D., Chung, J., Kushman, N., Schrittwieser, J., Leblond, R., Eccles, T., Keeling, J., Gimeno, F., Dal Lago, A., et al. (2022) · Science · doi:10.1126/science.abq1158 · Cited by 1,043 · cited 3× · see citing works
“In particular, large language models (LLMs) have achieved excellent performance and demonstrate promising potential on code generation tasks [15, 18, 38, 64].”
How Can We Know What Language Models Know?
Jiang, Z., Xu, F. F., Araki, J., & Neubig, G. (2020) · Transactions of the Association for Computational Linguistics · doi:10.1162/tacl_a_00324 · Cited by 1,002 · cited 1× · see citing works
“Meanwhile, since hand-crafted instructions or prompts may not always be optimal, some researchers have explored automated instruction or prompt generation approaches [24, 44, 51, 65].”
Prompt Programming for Large Language Models: Beyond the Few-Shot Paradigm
Reynolds, L., & McDonell, K. (2021) · Extended Abstracts of the 2021 CHI Conference on Human Factors in Computing Systems · doi:10.1145/3411763.3451760 · Cited by 952 · see citing works
Belbin, R., & Brown, V. (2022) · Routledge eBooks · doi:10.4324/9780080963242 · Cited by 925 · cited 1× · see citing works
“The benefits of collaborative teamwork are manifold: (1) It breaks down complex tasks into smaller subtasks, making the entire code generation process more efficient and controllable.”
Corkill, D. (1991) · doi:10.1016/0950-7051(89)90039-7 · Cited by 846 · cited 1×
“The pseudocode of our self-collaboration framework is outlined in Algorithm 1.”
Agile Software Development Methods: Review and AnalysisPreprint
Abrahamsson, P., Salo, O., Ronkainen, J., & Warsta, J. (2017) · arXiv.org · doi:10.48550/arxiv.1709.08439 · Cited by 744 · cited 1× · see citing works
“The task is defined as T : 𝑥 → 𝑦 .”
The Emotion Machine: Commonsense Thinking, Artificial Intelligence, and the Future of the Human Mind
Minsky, M. (2006) · Choice Reviews Online · doi:10.5860/choice.44-5688 · Cited by 683 · cited 1× · see citing works
“The software development lifecycle (SDLC) breaks up the process of creating a software system into discrete stages, including requirement analysis, planning and design, coding, testing, deployment, and maintenance.”
HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face
Shen, Y., Song, K., Tan, X., Li, D., Lu, W., & Zhuang, Y. (2023) · arXiv · doi:10.48550/arxiv.2303.17580 · Cited by 477 · cited 2× · see citing works
“, 2023] and HuggingGPT [Shen et al., 2023] explore the collaboration of LLMs with other models, specifically the LLMs are used as decision centers to control and invoke other models to handle more domains, such as vision, speech, and signals.”
An Empirical Evaluation of Using Large Language Models for Automated Unit Test Generation
Schäfer, M., Nadi, S., Eghbali, A., & Tip, F. (2024) · IEEE Transactions on Software Engineering · doi:10.1109/tse.2023.3334955 · Cited by 431 · cited 1× · see citing works
“(2) This setting is mainly suited for function-level code generation and proves challenging to extend to file-level or repository-level code generation.”
Software development lifecycle models
Ruparelia, N. B. (2010) · SOEN · doi:10.1145/1764810.1764814 · Cited by 420 · cited 1× · see citing works
“The task is defined as T : 𝑥 → 𝑦 .”
Program Synthesis with Large Language Models
Austin, J., Odena, A., Nye, M., Bosma, M., Michalewski, H., Dohan, D., Jiang, E., Cai, C., Terry, M., Le, Q., et al. (2021) · arXiv · doi:10.48550/arxiv.2108.07732 · Cited by 388 · cited 1× · see citing works
“MBPP (sanitized version) [Austin et al., 2021] contains 427 manually verified Python programming tasks, covering programming fundamentals, standard library functionality, and more.”
Large Language Models Are Human-Level Prompt Engineers
Zhou, Y., Muresanu, A. I., Han, Z., Paster, K., Pitis, S., Chan, H., & Ba, J. (2022) · arXiv · doi:10.48550/arxiv.2211.01910 · Cited by 330 · cited 1× · see citing works
“Meanwhile, since hand-crafted instructions or prompts may not always be optimal, some researchers have explored automated instruction or prompt generation approaches [24, 44, 51, 65].”
CodeGen: An Open Large Language Model for Code with Multi-Turn Program Synthesis
Nijkamp, E., Pang, B., Hayashi, H., Tu, L., Wang, H., Zhou, Y., Savarese, S., & Xiong, C. (2022) · arXiv · doi:10.48550/arxiv.2203.13474 · Cited by 330 · cited 2× · see citing works
“In particular, large language models (LLMs) have achieved excellent performance and demonstrate promising potential on code generation tasks [15, 18, 38, 64].”
CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society
Li, G., Hammoud, H. A. A. K., Itani, H., Khizbullin, D., & Ghanem, B. (2023) · arXiv · doi:10.48550/arxiv.2303.17760 · Cited by 315 · cited 1× · see citing works
“CAMEL [28] explores the possibility of interaction between two LLMs.”
Self-citationCodeGeeX: A Pre-Trained Model for Code Generation with Multilingual Benchmarking on HumanEval-X
Zheng, Q., Xia, X., Zou, X., Dong, Y., Wang, S., Xue, Y., Shen, L., Wang, Z., Wang, A., Li, Y., et al. (2023) · Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining · doi:10.1145/3580305.3599790 · Cited by 263 · see citing works
Self-citationCodeGeeX: A Pre-Trained Model for Code Generation with Multilingual Evaluations on HumanEval-X
Zheng, Q., Xia, X., Zou, X., Dong, Y.-X., Wang, S., Xue, Y.-F., Wang, Z.-H., Shen, L., Wang, A., Li, Y., et al. (2023) · arXiv.org · doi:10.48550/arxiv.2303.17568 · Cited by 227 · see citing works
Self-citationThe Waterfall Model in Large-Scale Development
Petersen, K., Wohlin, C., & Baca, D. (2009) · International Conference on Product Focused Software Process Improvement · doi:10.1007/978-3-642-02152-7_29 · Cited by 225 · cited 1× · see citing works
“We introduce the classic waterfall model [Petersen et al., 2009] from SDM into self-collaboration framework to make the teamwork for code generation more efficient.”
Large Language Models are Few-shot Testers: Exploring LLM-based General Bug Reproduction
Kang, S., Yoon, J., & Yoo, S. (2023) · 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE) · doi:10.1109/icse48619.2023.00194 · Cited by 204 · cited 1× · see citing works
“In this section, we outline the most relevant directions and associated papers of this work to highlight our research’s innovative and advanced nature.”
Advancing Requirements Engineering through Generative AI: Assessing the Role of LLMs
Arora, C., Grundy, J. C., & Abdelrazek, M. (2023) · arXiv.org · doi:10.48550/arxiv.2310.13976 · Cited by 199
Visual ChatGPT: Talking, Drawing and Editing with Visual Foundation Models
Wu, C., Yin, S., Qi, W., Wang, X., Tang, Z., & Duan, N. (2023) · arXiv · doi:10.48550/arxiv.2303.04671 · Cited by 197 · cited 2× · see citing works
“Recently, VisualGPT [58] and HuggingGPT [50] explore the collaboration of LLMs with other models, specifically the LLMs are used as decision centers to control and invoke other models to handle more domains, such as vision, speech, and signals.”
InCoder: A Generative Model for Code Infilling and Synthesis
Fried, D., Aghajanyan, A., Lin, J., Wang, S., Wallace, E., Shi, F., Zhong, R., Yih, W.-T., Zettlemoyer, L., & Lewis, M. (2022) · arXiv · doi:10.48550/arxiv.2204.05999 · Cited by 187 · see citing works
Self-Planning Code Generation with Large Language Models
Jiang, X., Dong, Y., Wang, L., Fang, Z., Shang, Q., Li, G., Jin, Z., & Jiao, W. (2024) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3672456 · Cited by 158 · cited 1× · see citing works
“Self-planning [Jiang et al., 2023] introduces a planning stage prior to code generation.”
Self-citationCoder Reviewer Reranking for Code GenerationPreprint
Zhang, T., Yu, T., Hashimoto, T. B., Lewis, M., Yih, W.-T., Fried, D., & Wang, S. I. (2022) · International Conference on Machine Learning · doi:10.48550/arxiv.2211.16490 · Cited by 144 · cited 1× · see citing works
“CoderReviewer [Zhang et al., 2022] introduces an additional Reviewer model to enhance the coder model, which generates requirements based on the code and calculates the maximum likelihood to rank the generated code.”
Measuring Coding Challenge Competence With APPS
Hendrycks, D., Basart, S., Kadavath, S., Mazeika, M., Arora, A., Guo, E., Burns, C., Puranik, S., He, H., Song, D., et al. (2021) · arXiv · doi:10.48550/arxiv.2105.09938 · Cited by 142 · see citing works
CoderEval: A Benchmark of Pragmatic Code Generation with Generative Pre-trained Models
Yu, H., Shen, B., Ran, D., Zhang, J., Zhang, Q., Ma, Y., Liang, G., Li, Y., Wang, Q., & Xie, T. (2024) · Proceedings of the IEEE/ACM 46th International Conference on Software Engineering · doi:10.1145/3597503.3623316 · Cited by 140 · see citing works
Exploring Chain-of-Thought Style Prompting for Text-to-SQL
Tai, C.-Y., Chen, Z., Zhang, T.-S., Deng, X., & Sun, H. (2023) · Conference on Empirical Methods in Natural Language Processing · doi:10.48550/arxiv.2305.14215 · Cited by 132 · cited 1×
“Therefore, self-collaboration may require the following abilities for LLMs, including strong domain-specific expertise ability for role-playing, strong in-context learning ability to follow instructions, and strong reasoning ability to solve problems effectively.”
Conversational Automated Program RepairPreprint
Xia, C., & Zhang, L.-M. (2023) · arXiv.org · doi:10.48550/arxiv.2301.13246 · Cited by 103 · cited 1× · see citing works
“Additionally, the work [Xia and Zhang, 2023] successfully implemented conversational APR using ChatGPT.”
CodeT: Code Generation with Generated Tests
Chen, B., Zhang, F., Nguyen, A., Zan, D., Lin, Z., Lou, J.-G., & Chen, W. (2022) · arXiv · doi:10.48550/arxiv.2207.10397 · Cited by 92 · cited 4× · see citing works
“Following the settings in CodeT [7], we use NL in APPS as a comment and then concatenate the signature “ def solution(stdin : str) → str : ” as input to the model.”
InfluentialTeaching Large Language Models to Self-Debug
Chen, X., Lin, M., Schärli, N., & Zhou, D. (2023) · arXiv · doi:10.48550/arxiv.2304.05128 · Cited by 77 · cited 1× · see citing works
“Self-debugging [Chen et al., 2023] teaches LLM to perform rubber duck debugging after code generation.”
CodeScore: Evaluating Code Generation by Learning Code Execution
Dong, Y., Ding, J., Jiang, X., Li, G., Li, Z., & Jin, Z. G. (2024) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3695991 · Cited by 76 · cited 5× · see citing works
“MBPP-ET and HumanEval-ET [Dong et al., 2023] are expanded versions of MBPP and HumanEval with over 100 additional test cases per task.”
InfluentialSelf-citationCommunication and co-ordination practices in software engineering projects
McChesney, I., & Gallagher, S. (2003) · Information and Software Technology · doi:10.1016/j.infsof.2003.10.001 · Cited by 73 · cited 1× · see citing works
“Teamwork through division of labor (DOL) , interaction, and collaboration to solve complex problems, has been theorized to play an important role in dealing with complexity, as posited in both teamwork theory [5, 26] and software engineering practice [4, 13, 34].”
Practical Program Repair in the Era of Large Pre-trained Language Models
Xia, C., Wei, Y.-X., & Zhang, L.-M. (2022) · arXiv.org · doi:10.48550/arxiv.2210.14179 · Cited by 70 · cited 1×
“In a comprehensive study conducted by the work [Xia et al., 2022], the direct application of LLMs for APR was explored and it was shown that LLMs outperform all existing APR techniques by a substantial margin.”
Dong, Y., Jiang, X., Liu, H., Jin, Z., Gu, B., Yang, M., & Li, G. (2024) · arXiv · doi:10.48550/arxiv.2402.15938 · Cited by 52 · cited 1×
“In particular, large language models (LLMs) have achieved excellent performance and demonstrate promising potential on code generation tasks [15, 18, 38, 64].”
Self-citationPEER: A Collaborative Language Model
Schick, T., Dwivedi-Yu, J., Jiang, Z., Petroni, F., Lewis, P., Izacard, G., You, Q., Nalmpantis, C., Grave, E., & Riedel, S. (2022) · arXiv · doi:10.48550/arxiv.2208.11663 · Cited by 49 · cited 1× · see citing works
“A straightforward way to implement collaborative teamwork entails training different models to handle the corresponding subtasks, subsequently conducting joint training to foster mutual understanding of behaviors to assemble them into a team [Schick et al., 2022].”
Fisher, L. M. (2016) · Communications of the ACM · doi:10.1145/2892716 · Cited by 36
PACE: Improving Prompt with Actor-Critic Editing for Large Language Model
Dong, Y., Luo, K., Jiang, X., Jin, Z., & Li, G. (2023) · Annual Meeting of the Association for Computational Linguistics · doi:10.48550/arxiv.2308.10088 · Cited by 32 · cited 1×
“This is a critical task since the behavior of LLMs depends heavily on the inputs they receive [6, 17, 31].”
Self-citationIncorporating domain knowledge through task augmentation for front-end JavaScript code generation
Shen, S., Zhu, X. P., Dong, Y., Guo, Q., Zhen, Y., & Li, G. (2022) · ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) · doi:10.1145/3540250.3558965 · Cited by 28 · see citing works
Self-citationCODEP: Grammatical Seq2Seq Model for General-Purpose Code Generation
Dong, Y., Li, G., & Jin, Z. G. (2023) · ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA) · doi:10.1145/3597926.3598048 · Cited by 22 · see citing works
Self-citationParsel: Algorithmic Reasoning with Language Models by Composing Decompositions
Zelikman, E., Huang, Q., Poesia, G., Goodman, N. D., & Haber, N. (2022) · arXiv · doi:10.48550/arxiv.2212.10561 · Cited by 15 · cited 1× · see citing works
“The work [Zelikman et al., 2022] applied LLMs to code generation and demonstrated significant improvement in the pass rate of generated complex programs.”
The society of mind: Marvin Minsky☆
Minsky, M. (1991) · Artificial Intelligence · doi:10.1016/0004-3702(91)90033-g · Cited by 2 · cited 1×
“Multi-agent collaboration refers to the coordination and collaboration among multiple artificial intelligence (AI) systems or the symbiotic collaboration between AI and human, working together to achieve a shared objective [Smoliar, 1991].”
OpenAI, Achiam, J., Adler, S., Agarwal, S., Ahmad, L., Akkaya, I., Aleman, F. L., Almeida, D., Altenschmidt, J., Altman, S., et al. (2023) · arXiv · doi:10.48550/arxiv.2303.08774
Flagged first, then by citations
23 of the 76 references couldn’t be matched to a known paper.
Research works printed but not linked: 7
- [12][12] Caroline Claus and Craig Boutilier. 1998. The Dynamics of Reinforcement Learning in Cooperative Multiagent Systems. In AAAI/IAAI . AAAI Press / The MIT Press, 746-752. -
- [13][13] Tom DeMarco and Tim Lister. 2013. Peopleware: productive projects and teams . Addison-Wesley. -
- [29][29] Raymond Li, Loubna Ben Allal, Yangtian Zi, Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Marc Marone, Christopher Akiki, Jia Li, Jenny Chim, Qian Liu, Evgenii Zheltonozhskii, Terry Yue Zhuo, Thomas Wang, Olivier Dehaene, Mishig Davaadorj, Joel Lamy-Poirier, João Monteiro, Oleh Shliazhko, Nicolas Gontier, Nicholas Meade, Armel Zebaze, Ming-Ho Yee, Logesh Kumar Umapathi, Jian Zhu, Benjamin Lipkin, Muhtasham Oblokulov, Zhiruo Wang, Rudra Murthy V, Jason Stillerman, Siva Sankalp Patel, Dmitry Abulkhanov, Marco Zocca, Manan Dey, Zhihan Zhang, Nour Moustafa-Fahmy, Urvashi Bhattacharyya, Wenhao Yu, Swayam Singh, Sasha Luccioni, Paulo Villegas, Maxim Kunakov, Fedor Zhdanov, Manuel Romero, Tony Lee, Nadav Timor, Jennifer Ding, Claire Schlesinger, Hailey Schoelkopf, Jan Ebert, Tri Dao, Mayank Mishra, Alex Gu, Jennifer Robinson, Carolyn Jane Anderson, Brendan DolanGavitt, Danish Contractor, Siva Reddy, Daniel Fried, Dzmitry Bahdanau, Yacine Jernite, Carlos Muñoz Ferrandis, Sean Hughes, Thomas Wolf, Arjun Guha, Leandro von Werra, and Harm de Vries. 2023. StarCoder: may the source be with you! CoRR abs/2305.06161 (2023). - · arXiv
- [42][42] Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul F. Christiano, Jan Leike, and Ryan Lowe. 2022. Training language models to follow instructions with human feedback. CoRR abs/2203.02155 (2022). - · arXiv
- [45][45] Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Tal Remez, Jérémy Rapin, Artyom Kozhevnikov, Ivan Evtimov, Joanna Bitton, Manish Bhatt, Cristian Canton-Ferrer, Aaron Grattafiori, Wenhan Xiong, Alexandre Défossez, Jade Copet, Faisal Azhar, Hugo Touvron, Louis Martin, Nicolas Usunier, Thomas Scialom, and Gabriel Synnaeve. 2023. Code Llama: Open Foundation Models for Code. CoRR abs/2308.12950 (2023). - · arXiv
- [51][51] Taylor Shin, Yasaman Razeghi, Robert L. Logan IV, Eric Wallace, and Sameer Singh. 2020. AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts. In EMNLP (1) . Association for Computational Linguistics, 4222-4235. -
- [57][57] Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. 2022. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. In NeurIPS . -
Cited by
Sorted by citations
A survey on large language model based autonomous agents
Wang, L., Ma, C., Feng, X., Zhang, Z., Yang, H., Zhang, J., Chen, Z., Tang, J., Chen, X., Lin, Y., et al. (2024) · Frontiers of Computer Science · doi:10.1007/s11704-024-40231-1 · Cited by 1,941 · see citing works
“ChemCrow [75], Boiko et al. [115], Grossmann et al. [122] Natural Science Education ChemCrow [75], CodeHelp [120], Boiko et al. [115], MathA-gent [117], Drori et al. [118] Engineering”
InfluentialLarge Language Models for Software Engineering: A Systematic Literature Review
Hou, X., Zhao, Y., Liu, Y., Yang, Z., Wang, K., Li, L., Luo, X., Lo, D., Grundy, J., & Wang, H. (2024) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3695988 · Cited by 1,029 · see citing works
Software Testing With Large Language Models: Survey, Landscape, and Vision
Wang, J., Huang, Y., Chen, C., Liu, Z., Wang, S., & Wang, Q. (2024) · IEEE Transactions on Software Engineering · doi:10.1109/tse.2024.3368208 · Cited by 573 · see citing works
“LLMs have been used for various coding-related tasks including code generation and code recommendation [20], [21], [22], [23].”
Large language models for software engineering: survey and open problems
Fan, A., Gokkaya, B., Harman, M., Lyubarskiy, M., Sengupta, S., Yoo, S., & Zhang, J. M. (2023) · 2023 IEEE/ACM International Conference on Software Engineering: Future of Software Engineering (ICSE-FoSE) · doi:10.1109/icse-fose59343.2023.00008 · Cited by 650 · see citing works
“Dong et al. [72] treated LLMs as agents, letting multiple LLMs play distinct roles in addressing code generation tasks collaboratively and interactively.”
BackgroundA survey on LLM-based multi-agent systems: Workflow, infrastructure, and challenges
Li, X., Wang, S., Zeng, S., Wu, Y., & Yang, Y. (2024) · Vicinagearth · doi:10.1007/s44336-024-00009-2 · Cited by 404 · see citing works
“Through ongoing interactions, agents continuously assess and enhance their knowledge base, [32], ChatEDA [303], LIBRO [304], PENTESTGPT [305] Industrial Engineering Mehta et al. [2], Xia et al. [3], Li et al. [4] Embodied Agents SayCan [8], Inner Monologue [9], TidyBot [10], RoCo [34], CoELA [35]…”
InfluentialDomain Specialization as the Key to Make Large Language Models Disruptive: A Comprehensive Survey
Ling, C., Zhao, X., Lu, J., Deng, C., Zheng, C., Wang, J., Chowdhury, T., Li, Y., Cui, H., Zhang, X., et al. (2025) · ACM Computing Surveys · doi:10.1145/3764579 · Cited by 263 · see citing works
“Follow-up works explore how to utilize zero-shot discrete prompt for domain adaptation in sentiment analysis [60], image classification [38], semantic segmentation [35], and rumor detection [82].”
MapCoder: Multi-Agent Code Generation for Competitive Problem SolvingPreprint
Islam, M. A., Ali, M. E., & Parvez, M. R. (2024) · Annual Meeting of the Association for Computational Linguistics · doi:10.48550/arxiv.2405.11403 · Cited by 309 · see citing works
“Self-collaboration (Dong et al., 2023b) proposes a framework where different LLMs act as analyst, coder, and tester to cooperatively generate code for complex tasks, achieving better performance than directly using a single LLM. AlphaCodium (Ridnik et al., 2024) iteratively refines code based on…”
MethodA Dynamic LLM-Powered Agent Network for Task-Oriented Agent CollaborationPreprint
Liu, Z., Zhang, Y., Li, P., Liu, Y., & Yang, D.-Y. (2023) · arXiv.org · doi:10.48550/arxiv.2310.02170 · Cited by 385 · see citing works
“In these works, such LLM-agent team is often set up statically with predefined roles for each agent, such as introducing programmer and tester to communicate sequentially in a fixed order to improve code generation (Dong et al., 2023).”
InfluentialHe, J., Treude, C., & Lo, D. (2025) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3712003 · Cited by 246 · see citing works
“This feedback initiates an iterative cycle, where the Programmer refines the code or the Debugger resolves identified issues, ensuring that the final code meets the desired standards and performs as expected [21, 31, 69, 72, 81, 88, 96, 102, 132].”
LLM-Based Multi-Agent Systems for Software Engineering: Literature Review, Vision and the Road Ahead
He, J., Treude, C., & Lo, D. (2024) · arXiv · doi:10.48550/arxiv.2404.04834 · Cited by 246 · see citing works
“This feedback initiates an iterative cycle, where the Programmer refines the code or the Debugger resolves identified issues, ensuring that the final code meets the desired standards and performs as expected [21, 31, 69, 72, 81, 88, 96, 102, 132].”
Exploring Large Language Model‐Based Intelligent Agents: Definitions, Methods, and Prospects
Cheng, Y.-H., Zhang, C., Zhang, Z.-W., Meng, X.-R., Hong, S.-R., Li, W.-H., Wang, Z., Wang, Z.-K., Yin, F., Zhao, J.-H., et al. (2024) · WIREs Data Mining and Knowledge Discovery · doi:10.1002/widm.70111 · Cited by 241 · see citing works
No More Manual Tests? Evaluating and Improving ChatGPT for Unit Test GenerationPreprint
Yuan, Z.-Q., Lou, Y., Liu, M.-W., Ding, S., Wang, K.-X., Chen, Y.-X., & Peng, X. (2023) · arXiv.org · doi:10.48550/arxiv.2305.04207 · Cited by 239 · see citing works
“”) to inspire ChatGPT’s capability of test generation, which is a common prompt optimization strategy [53], [64]; and (ii) a task-description instruction (i.”
BackgroundMethodTowards an understanding of large language models in software engineering tasks
Zheng, Z., Ning, K., Zhong, Q., Chen, J., Chen, W., Guo, L., Wang, W., & Wang, Y. (2024) · Empirical Software Engineering · doi:10.1007/s10664-024-10602-0 · Cited by 149 · see citing works
“…the quality of code generated by LLMs (Zhang et al. 2023a; Wang et al. 2023d; Barke et al. 2023a; Mouselinos et al. 2023; Lahiri et al. 2022; Dong et al. 2023; Jiang et al. 2023a), addressing security and reliability concerns (Poesia et al. 2022; Zhu and Zhang 2023; Ke et al. 2023),…”
MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework
Hong, S., Zhuge, M., Chen, J., Zheng, X., Cheng, Y., Zhang, C., Wang, J., Wang, Z., Yau, S. K. S., Lin, Z., et al. (2023) · arXiv · doi:10.48550/arxiv.2308.00352 · Cited by 214 · see citing works
Harnessing the power of AI in qualitative research: Exploring, using and redesigning ChatGPT
Zhang, H., Wu, C., Xie, J., Lyu, Y., Cai, J., & Carroll, J. M. (2025) · Computers in Human Behavior Artificial Humans · doi:10.1016/j.chbah.2025.100144 · Cited by 290 · see citing works
“Many previous literature mentioned the use of role-playing to enhance or surpass the performance of ChatGPT [30, 33, 61, 68, 105].”
AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation
Wu, Q., Bansal, G., Zhang, J., Wu, Y., Li, B., Zhu, E., Jiang, L., Zhang, X., Zhang, S., Liu, J., et al. (2023) · arXiv · doi:10.48550/arxiv.2308.08155 · Cited by 193 · see citing works
“(A1, A2, A5, and A6) • Collaborative/adversarial agent interactions : Like many collaborative agent systems (Dong et al., 2023), agents in AutoGen can share information and knowledge, to complement each other’s abilities and collectively arrive at better solutions.”
CodeScore: Evaluating Code Generation by Learning Code Execution
Dong, Y., Ding, J., Jiang, X., Li, G., Li, Z., & Jin, Z. G. (2024) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3695991 · Cited by 76 · see citing works
“LLMs pre-trained on code have demonstrated outstanding results in code generation tasks [5, 7, 8, 14, 29], which are fundamentally dependent on exceptional code comprehension.”
Self-citationRefining ChatGPT-Generated Code: Characterizing and Mitigating Code Quality Issues
Liu, Y., Le-Cong, T., Widyasari, R., Tantithamthavorn, C., Li, L., Le, X.-B. D., & Lo, D. (2024) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3643674 · Cited by 149 · see citing works
“In Python, the top three issues are ConsiderUsingEnumerate (213 out of 2033 programs, 10.5%), NoElseReturn (161 out of 2033 programs, 7.9%), and UnusedVariable (103 out of 2033 programs, 5.1%).”
BackgroundInfluentialA Review on Code Generation with LLMs: Application and Evaluation
Wang, J., & Chen, Y. (2023) · IEEE International Conference on Medical Artificial Intelligence (MedAI) · doi:10.1109/medai59581.2023.00044 · Cited by 122 · see citing works
“Dong et al. [14] proposed a self-collaboration framework for LLMs to enhance their capability of solving coding problems.”
BackgroundFrom LLMs to LLM-based Agents for Software Engineering: A Survey of Current, Challenges and FuturePreprint
Jin, H., Huang, L.-H., Cai, H.-P., Yan, J., Li, B., & Chen, H.-M. (2024) · arXiv.org · doi:10.48550/arxiv.2408.02479 · Cited by 144 · see citing works
“Many studies have utilized HumanEval to test the performance of code generation models [101].”
InfluentialLook Before You Leap: An Exploratory Study of Uncertainty Measurement for Large Language ModelsPreprint
Huang, Y., Song, J.-Y., Wang, Z., Chen, H.-M., & Ma, L. (2023) · arXiv.org · doi:10.48550/arxiv.2307.10236 · Cited by 144 · see citing works
“5 with RLHF) [3] has shown superior performance in solving various complex tasks (e.g., program synthesizes [61], program repair [62]) by only following the user’s instructions and feedback through a dialogue.”
DevEval: A Manually-Annotated Code Generation Benchmark Aligned with Real-World Code RepositoriesPreprint
Li, J., Li, G., Zhao, Y., Li, Y.-M., Liu, H.-Y., Zhu, H., Wang, L., Liu, K., Fang, Z., Wang, L.-S., et al. (2024) · Annual Meeting of the Association for Computational Linguistics · doi:10.48550/arxiv.2405.19856 · Cited by 141 · see citing works
“…scenarios, some works focus on improving the prompt technologies by introducing specific patterns, e.g., Structured Chain-of-Thought (Li et al., 2023a), Self-planning (Jiang et al., 2023), Self-debug (Chen et al., 2023), Self-collaboration (Dong et al., 2023), and AceCoder (Li et al., 2023c).”
BackgroundSelf-citationYang, K., Liu, J., Wu, J., Yang, C., Fung, Y. R., Li, S., Huang, Z.-X., Cao, X., Wang, X., Wang, Y.-Q., et al. (2024) · arXiv.org · doi:10.48550/arxiv.2401.00812 · Cited by 133 · see citing works
“Dong et al. (2023b) assigned three roles: analyst, coder, and tester to three distinct “GPT-3.”
BackgroundSelf-Contrast: Better Reflection Through Inconsistent Solving PerspectivesPreprint
Zhang, W., Shen, Y., Wu, L.-J., Peng, Q., Wang, J., Zhuang, Y., & Lu, W. (2024) · Annual Meeting of the Association for Computational Linguistics · doi:10.48550/arxiv.2401.02009 · Cited by 131 · see citing works
“Moreover, recent works (Wang et al., 2023e; Fu et al., 2023; Liang et al., 2023; Schick et al., 2022; Dong et al., 2023; Park et al., 2023; Liu et al., 2023) have utilized a multi-role dialogue to collaborate or debate with each other for a more comprehensive response.”
No Need to Lift a Finger Anymore? Assessing the Quality of Code Generation by ChatGPT
Liu, Z., Tang, Y., Luo, X., Zhou, Y., & Zhang, L. F. (2024) · IEEE Transactions on Software Engineering · doi:10.1109/tse.2024.3392499 · Cited by 128 · see citing works
“Dong et al. [53] introduce the concept of software development life cycle and propose a self-collaboration framework that leverages different ChatGPT conversations to play different roles (e.g., analyst, developer, and tester), collaborating to generate code.”
BackgroundMethodInfluentialMou, X., Ding, X., He, Q., Wang, L., Liang, J., Zhang, X.-N., Sun, L., Lin, J.-Y., Zhou, J., Huang, X.-J., et al. (2024) · ACM Computing Surveys · doi:10.1145/3800683 · Cited by 126 · see citing works
“Dong et al. [176] presents a self-collaboration framework where LLM agents function as distinct “experts,” each managing specific subtasks to facilitate autonomous collaborative code generation.”
InfluentialAutomatic Code Summarization via ChatGPT: How Far Are We?Preprint
Sun, W.-S., Fang, C., You, Y., Miao, Y., Liu, Y., Li, Y., Deng, G.-L., Huang, S., Chen, Y., Zhang, Q.-J., et al. (2023) · arXiv.org · doi:10.48550/arxiv.2305.12865 · Cited by 121 · see citing works
Exploring and Unleashing the Power of Large Language Models in Automated Code Translation
Yang, Z., Liu, F., Yu, Z., Keung, J. W., Li, J., Liu, S., Hong, Y., Ma, X., Jin, Z., & Li, G. (2024) · Proceedings of the ACM on Software Engineering · doi:10.1145/3660778 · Cited by 104 · see citing works
“…Large Language Models (LLMs), pre-trained on billions of text/code tokens, bypass the need for re-training/fine-tuning but demonstrate the powerful generality of various code-related tasks, such as code generation [7, 11, 23, 25, 28, 52], program repair [12, 48], and code summarization [2, 14].”
BackgroundSelf-citationAutomatic Programming: Large Language Models and Beyond
Lyu, M. R.-T., Ray, B., Roychoudhury, A., Tan, S. H., & Thongtanunam, P. (2024) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3708519 · Cited by 65 · see citing works
“Dong et al. [21] proposes a self-collaboration method to advance LLMs in complex coding tasks by employing multiple LLMs as distinct experts and making them interact with each other.”
When Embodied AI Meets Industry 5.0: Human-Centered Smart Manufacturing
Xu, J., Sun, Q.-Y., Han, Q.-L., & Tang, Y. (2025) · IEEE/CAA Journal of Automatica Sinica · doi:10.1109/jas.2025.125327 · Cited by 102 · see citing works
EvoCodeBench: An Evolving Code Generation Benchmark Aligned with Real-World Code RepositoriesPreprint
Li, J., Li, G., Zhang, X.-M., Dong, Y., & Jin, Z. (2024) · arXiv.org · doi:10.48550/arxiv.2404.00599 · Cited by 102 · see citing works
“…scenarios, some works focus on improving the prompt technologies by introducing specific patterns, e.g., Structured Chain-of-Thought (Li et al., 2023a), Self-planning (Jiang et al., 2023), Self-debug (Chen et al., 2023), Self-collaboration (Dong et al., 2023), and AceCoder (Li et al., 2023c).”
BackgroundSelf-citationAutonomous LLM-driven research from data to human-verifiable research papers
Ifargan, T., Hafner, L., Kern, M., Alcalay, O., & Kishony, R. (2024) · NEJM AI · doi:10.48550/arxiv.2404.17605 · Cited by 101
The Current Challenges of Software Engineering in the Era of Large Language Models
Gao, C., Hu, X., Gao, S., Xia, X., & Jin, Z. G. (2025) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3712005 · Cited by 65 · see citing works
“Dong et al. [36] point out that code generation research should not be confined to programming alone, and suggest adopting multiple LLM agents to simulate different development team roles, such as analysts who break down user requirements, developers who generate or update code, and testers who…”
Self-citationLLM-Based Agent Society Investigation: Collaboration and Confrontation in Avalon Gameplay
Lan, Y.-H., Hu, Z., Wang, L., Wang, Y., Ye, D.-Y., Zhao, P.-L., Lim, E.-P., Xiong, H., & Wang, H. (2023) · Conference on Empirical Methods in Natural Language Processing · doi:10.48550/arxiv.2310.14985 · Cited by 92
“Additionally, some social complex tasks, such as court simulations and software development, become possible through the collaboration between LLM-based agents [8, 23, 27].”
BackgroundSMILE: Single-turn to Multi-turn Inclusive Language Expansion via ChatGPT for Mental Health Support
Qiu, H., He, H., Zhang, S., Li, A., & Lan, Z. (2024) · Findings of the Association for Computational Linguistics: EMNLP (Findings of EMNLP) · doi:10.18653/v1/2024.findings-emnlp.34 · Cited by 72 · see citing works
“…in several domains, such as conversational AI (Alessa and Al-Khalifa, 2023; Köpf et al., 2023; Chen et al., 2023), education (Küche-mann et al., 2023; Eshghie and Eshghie, 2023), code programming (Dong et al., 2023; Yeti¸stiren et al., 2023) and healthcare (Zhao et al., 2023; Yang et al., 2023).”
BackgroundDivide-and-Conquer: Generating UI Code from Screenshots
Wan, Y., Wang, C., Dong, Y., Wang, W., Li, S., Huo, Y., & Lyu, M. R.-T. (2025) · Proceedings of the ACM on software engineering. · doi:10.1145/3729364 · Cited by 36 · see citing works
“Furthermore, research has shown that LLMs have remarkable performance on various code intelligence tasks [35], including code generation [25, 27, 31, 37, 43, 74], code completion [16, 23, 24, 44, 45, 54], and code summarization [9, 14, 30, 34, 47, 48].”
Self-citationTwo Tales of Persona in LLMs: A Survey of Role-Playing and Personalization
Tseng, Y.-M., Huang, Y.-C., Hsiao, T.-Y., Chen, W.-L., Huang, C.-W., Meng, Y., & Chen, Y.-N. (2024) · arXiv · doi:10.48550/arxiv.2406.01171 · Cited by 87
“In addition to the above environments, several research also proposes general frameworks applicable to different environments (§2.2.6).”
BackgroundInfluentialClarifyGPT: Empowering LLM-based Code Generation with Intention ClarificationPreprint
Mu, F., Shi, L., Wang, S., Yu, Z.-H., Zhang, B., Wang, C.-X., Liu, S., & Wang, Q. (2023) · arXiv.org · doi:10.48550/arxiv.2310.10996 · Cited by 86 · see citing works
“Prompt Learning is one of the most important techniques for achieving this goal [11, 28, 31, 40, 47].”
BackgroundMethodChatDev: Communicative Agents for Software Development
Qian, C., Liu, W., Liu, H., Chen, N., Dang, Y., Li, J., Yang, C., Chen, W., Su, Y., Cong, X., et al. (2023) · arXiv · doi:10.48550/arxiv.2307.07924 · Cited by 81 · see citing works
“(3) Software implementation is the detailed creation procedure of the software to implement the design [16; 1; 6; 29; 11].”
MethodHow to Refactor this Code? An Exploratory Study on Developer-ChatGPT Refactoring Conversations
Alomar, E., Venkatakrishnan, A., Mkaouer, M., Newman, C., & Ouni, A. (2024) · IEEE Working Conference on Mining Software Repositories · doi:10.1145/3643991.3645081 · Cited by 79 · see citing works
“Learning from software repositories has opened up a myriad of LLM applications in software development tasks, such as code search [37], code quality [5, 38, 39], repair [19, 33, 40, 44], program comprehension [24], generation [14, 17], completion [28], and translation [21].”
MethodWu, M., Xu, J.-H., Yuan, Y.-L., Haffari, G., Wang, L.-Y., Luo, W.-H., & Zhang, K.-F. (2024) · Transactions of the Association for Computational Linguistics · doi:10.48550/arxiv.2405.11804 · Cited by 78 · see citing works
“Additionally, recent research explores using LLMs for evaluating literary translations (Yan et al., 2024; Zhang et al., 2024).”
Fu, Y., Xiong, D.-Y., & Dong, Y. (2023) · AAAI Conference on Artificial Intelligence · doi:10.48550/arxiv.2307.13808 · Cited by 76 · see citing works
“Language Models (LMs) have demonstrated remarkable effectiveness in generating content that closely resembles human performances across diverse tasks (Tan et al. 2023; Dong et al. 2023; Liu et al. 2023).”
BackgroundSelf-citationLook Before You Leap: An Exploratory Study of Uncertainty Analysis for Large Language Models
Huang, Y., Song, J., Wang, Z., Zhao, S., Chen, H., Juefei-Xu, F., & Ma, L. (2025) · IEEE Transactions on Software Engineering · doi:10.1109/tse.2024.3519464 · Cited by 132 · see citing works
“5 with RLHF) [3] has shown superior performance in solving various complex tasks (e.g., program synthesizes [61], program repair [62]) by only following the user’s instructions and feedback through a dialogue.”
ClarifyGPT: A Framework for Enhancing LLM-Based Code Generation via Requirements Clarification
Mu, F., Shi, L., Wang, S., Yu, Z., Zhang, B., Wang, C., Liu, S., & Wang, Q. (2024) · Proceedings of the ACM on Software Engineering · doi:10.1145/3660810 · Cited by 74 · see citing works
Enhancing Large Language Models in Coding Through Multi-Perspective Self-Consistency
Huang, B.-Z., Lu, S., Chen, W.-Z., Wan, X.-J., & Duan, N. (2023) · Annual Meeting of the Association for Computational Linguistics · doi:10.48550/arxiv.2309.17272 · Cited by 73
Cognitive Architectures for Language Agents
Sumers, T. R., Yao, S., Narasimhan, K., & Griffiths, T. L. (2023) · arXiv · doi:10.48550/arxiv.2309.02427 · Cited by 72 · see citing works
“Digital environments .”
Large Language Models as Test Case Generators: Performance Evaluation and EnhancementPreprint
Li, K.-F., & Yuan, Y. (2024) · arXiv.org · doi:10.48550/arxiv.2404.13340 · Cited by 71 · see citing works
“It should be noted that in the generation process, Designer agent will be called only once to generate diverse test inputs, but Calculator agent will be called for each test input.”
BackgroundLarge Language Model based Multi-Agents: A Survey of Progress and Challenges
Guo, T., Chen, X., Wang, Y., Chang, R., Pei, S., Chawla, N. V., Wiest, O., & Zhang, X. (2024) · arXiv · doi:10.48550/arxiv.2402.01680 · Cited by 70 · see citing works
“[ Dong et al. , 2023b] makes LLMs work as distinct “experts” for sub-tasks in software development, autonomously collaborating to generate code.”
BackgroundFrom Code to Correctness: Closing the Last Mile of Code Generation with Hierarchical Debugging
Shi, Y.-L., Wang, S., Wan, C.-C., Wang, M., & Gu, X.-D. (2024) · Proceedings of the 2026 IEEE/ACM 48th International Conference on Software Engineering · doi:10.1145/3744916.3773255 · Cited by 68 · see citing works
Kong, J.-L., Xie, X.-F., Cheng, M.-F., Liu, S.-Q., Du, X.-N., & Guo, Q. (2024) · ACM Transactions on Software Engineering and Methodology · doi:10.1145/3719345 · Cited by 65 · see citing works
“Tremendous progress has been made by treating programming”
Yang, D., Liu, T., Zhang, D.-A., Simoulin, A., Liu, X., Cao, Y.-W., Teng, Z., Qian, X., Yang, G., Luo, J.-B., et al. (2025) · Conference on Empirical Methods in Natural Language Processing · doi:10.48550/arxiv.2502.19411 · Cited by 64
“5 62.2 52.4 – Self-Debugging (Chen et al., 2023b) GPT-4 – 80.6 – Self-Collaboration (Dong et al., 2024) GPT-3.”
InfluentialExploration of LLM Multi-Agent Application Implementation Based on LangGraph+CrewAIPreprint
Duan, Z., & Wang, J. (2024) · arXiv.org · doi:10.48550/arxiv.2411.18241 · Cited by 63 · see citing works
“MetaGPT [1], ChatDev [2], and self-collaboration [3] pre-set various roles and corresponding responsibilities to foster collaboration among agents.”
Li, J.-W., Yang, Y.-Z., Bai, Y., Zhou, X., Li, Y.-H., Sun, H., Liu, Y., Si, X., Ye, Y., Wu, Y., et al. (2024) · Annual Meeting of the Association for Computational Linguistics · doi:10.18653/v1/2024.acl-long.599 · Cited by 63
Learning to Ask: When LLM Agents Meet Unclear Instruction
Wang, W., Shi, J., Ling, Z.-X., Chan, Y.-K., Wang, C.-Z., Lee, C., Yuan, Y., Huang, J.-T., Jiao, W., & Lyu, M. R. (2024) · Conference on Empirical Methods in Natural Language Processing · doi:10.18653/v1/2025.emnlp-main.1104 · Cited by 62
“This model demonstrates a significant advancement in solving multiple tasks, including code generation (Dong et al., 2023; Sakib et al., 2023; Feng et al., 2023), machine translation (Jiao et al., 2023; Peng et al., 2023), even game playing (Wu et al., 2024).”
Zhang, H., Cheng, W., Wu, Y.-H., & Hu, W. (2024) · International Conference on Automated Software Engineering · doi:10.1145/3691620.3695506 · Cited by 61 · see citing works
“In line with previous works [7, 10, 22, 30], we use the greedy pass@1 [6, 49] to assess the functional correctness of the generated program.”
BackgroundMethodInfluentialUniDebugger: Hierarchical Multi-Agent Framework for Unified Software Debugging
Lee, C., Xia, C., Yang, L., Huang, J.-T., Zhu, Z., Zhang, L.-M., & Lyu, M. R. (2024) · Conference on Empirical Methods in Natural Language Processing · doi:10.18653/v1/2025.emnlp-main.921 · Cited by 61
“Hong et al. (2024); Dong et al. (2023) adopt a shared information pool to reduce overhead.”
Generative Artificial Intelligence for Software Engineering—A Research Agenda
Nguyen‐Duc, A., Cabrero‐Daniel, B., Przybylek, A., Arora, C., Khanna, D., Herda, T., Rafiq, U., Melegati, J., Guerra, E., Kemell, K., et al. (2025) · Software: Practice and Experience · doi:10.1002/spe.70005 · Cited by 60 · see citing works
User Behavior Simulation with Large Language Model-based Agents
Wang, L., Zhang, J., Yang, H., Chen, Z.-Y., Tang, J., Zhang, Z., Chen, X., Lin, Y., Sun, H., Song, R., et al. (2025) · ACM Transactions on Information Systems · doi:10.1145/3708985 · Cited by 59 · see citing works
“These agents are widely applied in various scenarios and applications, such as autonomous software development [50–52], serving as tools to assist humans in accomplishing specific tasks [53–55], and acting as planners to break down complex tasks and generate executable plans [56–58].”
Exploring and Characterizing Large Language Models for Embedded System Development and Debugging
Englhardt, Z., Li, R. C., Nissanka, D., Zhang, Z., Narayanswamy, G., Breda, J., Liu, X., Patel, S., & Iyer, V. (2024) · CHI Conference Extended Abstracts on Human Factors in Computing Systems (CHI EA) · doi:10.1145/3613905.3650764 · Cited by 31 · see citing works
“In N=50 trials, GPT-4 produces functional I2C interfaces 66% of the time.”
Repo2Run: Automated Building Executable Environment for Code Repository at Scale
Hu, R.-D., Peng, C., Wang, X., Xu, J., & Gao, C.-Y. (2025) · Neural Information Processing Systems · doi:10.52202/085713-1096 · Cited by 58 · see citing works
“LLM-based agents employ various planning strategies, including single [23] or multiple planners [24], single [25] or multi-turn planning [26], and single [27] or multi-path planning [28].”
Yang, A. C. M., Lin, J.-Y., Lin, C.-Y., & Ogata, H. (2024) · Computers and Education Artificial Intelligence · doi:10.1016/j.caeai.2024.100309 · Cited by 62 · see citing works
LLMs in Web-Development: Evaluating LLM-Generated PHP code unveiling vulnerabilities and limitations
Tóth, R., Bisztray, T., & Erdodi, L. (2024) · International Conference on Computer Safety, Reliability, and Security · doi:10.48550/arxiv.2404.14459 · Cited by 58
“[14].”
DevGPT: Studying Developer-ChatGPT Conversations
Xiao, T., Treude, C., Hata, H., & Matsumoto, K. (2024) · Proceedings of the 21st International Conference on Mining Software Repositories · doi:10.1145/3643991.3648400 · Cited by 56 · see citing works
Agent-Oriented Planning in Multi-Agent Systems
Li, A., Xie, Y.-X., Li, S., Tsung, F., Ding, B.-L., & Li, Y.-L. (2024) · International Conference on Learning Representations · doi:10.48550/arxiv.2410.02189 · Cited by 56
Gender Bias in Large Language Models across Multiple Languages
Zhao, J., Ding, Y.-T., Jia, C., Wang, Y.-N., & Qian, Z. (2024) · arXiv.org · doi:10.48550/arxiv.2403.00277 · Cited by 56
“LLMs have become increasingly prevalent in various social-influencing domains such as education (Kasneci et al., 2023; AlAfnan et al., 2023) and the technology industry (Dong et al., 2023), playing a more and more important role in social influence.”
Fundamental Capabilities and Applications of Large Language Models: A Survey
Li, J.-W., Gao, Y., Yang, Y.-Z., Bai, Y., Zhou, X., Li, Y.-H., Sun, H., Liu, Y., Si, X., Ye, Y., et al. (2025) · ACM Computing Surveys · doi:10.1145/3735632 · Cited by 54 · see citing works
“Additionally, it has revealed some emergent behaviors exhibited by agents in multi-agent collaborations, such as volunteer and conformity behaviors.”
Large Language Models are Complex Table Parsers
Zhao, B., Ji, C., Zhang, Y., He, W., Wang, Y., Wang, Q., Feng, R., & Zhang, X. (2023) · Conference on Empirical Methods in Natural Language Processing (EMNLP) · doi:10.18653/v1/2023.emnlp-main.914 · Cited by 27 · see citing works
“…the advent of ChatGPT 1 , an advanced NLP model derived from GPT-3, has showcased remarkable capabilities in generation (Maddigan and Susnjak, 2023; Dong et al., 2023; Liu et al., 2023a), contextual understanding (Bang et al., 2023; Gao et al., 2023b; Amin et al., 2023), and reasoning (Liu et al.,…”
BackgroundBeyond One-Model-Fits-All: A Survey of Domain Specialization for Large Language ModelsPreprint
Ling, C., Zhao, X.-J., Lu, J., Deng, C.-Y., Zheng, C., Wang, J., Chowdhury, T., Li, Y.-Q., Cui, H., Zhang, X.-C., et al. (2023) · arXiv.org · doi:10.48550/arxiv.2305.18703 · Cited by 54 · see citing works
“Follow-up works explore how to utilize zero-shot discrete prompt for domain adaptation in sentiment analysis [60], image classification [38], semantic segmentation [35], and rumor detection [82].”
Agents Under Siege: Breaking Pragmatic Multi-Agent LLM Systems with Optimized Prompt AttacksPreprint
Khan, R. M. S., Tan, Z., Yun, S., Fleming, C., & Chen, T.-L. (2025) · Annual Meeting of the Association for Computational Linguistics · doi:10.48550/arxiv.2504.00218 · Cited by 52 · see citing works
“Large Language Model agents have shown remarkable performance in various tasks through mutual collaboration (Chen et al., 2023; Hua et al., 2023; Cohen et al., 2023; Zhou et al., 2023; Li et al., 2023b,a; Chan et al., 2023; Dong et al., 2024; Qian et al., 2023).”
SOEN-101: Code Generation by Emulating Software Process Models Using Large Language Model Agents
Lin, F., Kim, D. J., & Chen, T.-H. (2024) · International Conference on Software Engineering · doi:10.1109/icse55347.2025.00140 · Cited by 52 · see citing works
From Misuse to Mastery: Enhancing Code Generation with Knowledge-Driven AI Chaining
Ren, X., Ye, X., Zhao, D., Xing, Z., & Yang, X. (2023) · IEEE/ACM International Conference on Automated Software Engineering (ASE) · doi:10.1109/ase56229.2023.00143 · Cited by 36 · see citing works
“Nevertheless, generating high-quality and reliable code remains a formidable task [12]–[15].”
BackgroundMethodInfluentialFrom language to action: a review of large language models as autonomous agents and tool users
Chowa, S. S., Alvi, R., Rahman, S. S., Rahman, M. A., Raiaan, M. A. K., Islam, M. R., Hussain, M., & Azam, S. (2026) · Artificial Intelligence Review · doi:10.1007/s10462-025-11471-9 · Cited by 50 · see citing works
“The profiling module defines an agent’s operational persona (e.g., developer, advisor, or task-specific role), conditioning its behavior and role policy through static profiles defined by experts or dynamic generative mechanisms [21, 138].”
Accelerating Software Development Using Generative AI: ChatGPT Case Study
Rajbhoj, A., Somase, A., Kulkarni, P., & Kulkarni, V. (2024) · Proceedings of the 17th Innovations in Software Engineering Conference · doi:10.1145/3641399.3641403 · Cited by 50 · see citing works
“There has been a growing interest in using Generative AI techniques for software engineering tasks, including requirements engineering, design, and testing [1, 3, 19-22].”
MethodCodeCoT: Tackling Code Syntax Errors in CoT Reasoning for Code Generation
Huang, D., Bu, Q., Qing, Y., & Cui, H. (2023) · doi:10.48550/arxiv.2308.08784 · Cited by 50
“GPT-4 currently provides state-of-the-art performance in NLP tasks such as natural language translation (Li et al., 2023b) and even translation to structured representations (Olmo et al., 2021).”
BackgroundInfluentialLarge Language Model-Based Agents for Software Engineering: A Survey
Liu, J., Wang, K., Chen, Y., Peng, X., Chen, Z., Zhang, L., & Lou, Y. (2024) · arXiv · doi:10.48550/arxiv.2409.02977 · Cited by 49 · see citing works
“Based on this process, some end-to-end software development agents [4], [187], [191], [194] further extend the traditional waterfall process by including iterations in specific phases to ensure the high quality of the generated content.”
InfluentialCodeTree: Agent-guided Tree Search for Code Generation with Large Language ModelsPreprint
Li, J.-R., Le, H., Zhou, Y.-B., Xiong, C.-M., Savarese, S., & Sahoo, D. (2024) · North American Chapter of the Association for Computational Linguistics · doi:10.48550/arxiv.2411.04329 · Cited by 49 · see citing works
The Impact of Prompt Programming on Function-Level Code Generation
Khojah, R., Neto, F. G. D. O., Mohamad, M., & Leitner, P. (2025) · IEEE Transactions on Software Engineering · doi:10.1109/tse.2025.3587794 · Cited by 34 · see citing works
“To evaluate LLMs on code generation tasks, the most common metric is Pass@k [28], where k = 1 is used to measure the rate of passed functions that the LLM generated on the first attempt [24] (e.g., by running a test suite).”
Automatic Smart Contract Comment Generation via Large Language Models and In-Context Learning
Zhao, J., Chen, X., Yang, G., & Shen, Y.-H. (2023) · Information and Software Technology · doi:10.48550/arxiv.2311.10388 · Cited by 47
“Since the automatic performance measures can only reflect the lexical similarity be-tween the generated smart contract comment and the ground-truth smart contract comment, we finally conduct a human study to evaluate the quality of the generated comments.”
BackgroundMethodCodeCoR: An LLM-Based Self-Reflective Multi-Agent Framework for Code GenerationPreprint
Pan, R.-W., Zhang, H.-Y., & Liu, C. (2025) · arXiv.org · doi:10.48550/arxiv.2501.07811 · Cited by 46 · see citing works
“5-turbo [32], ReAct [51], Reflexion [42], ToT [50], RAP [14], Self-Edit [52], Self-Planning [19], Self-Debugging [4], Self-Collaboration [10], SCoT [27], CodeChain [22], INTERVENOR [44], CodeCoT [16], PaLM Coder [8], Claude-instant-1 [29], GPT-4 [32], MapCoder [18], CodeTree [26], and DebateCoder…”
Liu, B., Jiang, Y., Zhang, Y., Niu, N., Li, G., & Liu, H. (2025) · Automated Software Engineering · doi:10.1007/s10515-025-00500-0 · Cited by 49 · see citing works
Self-citationFight Fire With Fire: How Much Can We Trust ChatGPT on Source Code-Related Tasks?
Yu, X., Liu, L., Hu, X., Keung, J., Liu, J., & Xia, X. (2024) · IEEE Transactions on Software Engineering · doi:10.1109/tse.2024.3492204 · Cited by 34 · see citing works
“Dong et al. [1] and Qian et al. [3] suggested a cooperative approach where LLMs like ChatGPT adopt multiple roles (analyst, coder, and tester) to collaboratively tackle code generation tasks.”
InfluentialLLM-Powered GUI Agents in Phone Automation: Surveying Progress and ProspectsPreprint
Liu, G.-Y., Zhao, P.-X., Liu, L., Guo, Y., Xiao, H., Lin, W., Chai, Y., Han, Y., Ren, S., Wang, H., et al. (2025) · Trans. Mach. Learn. Res. · doi:10.48550/arxiv.2504.19838 · Cited by 45 · see citing works
“With the rapid development of Large Language Models (LLMs) like the GPT series [28], [29], [30], [31] and specialized models such as Fuyu-8B [32], LLM-based agents have demonstrated powerful capabilities across numerous domains [33], [34], [35], [36], [37], [38], [39], [40], [41], [42], [43].”
Making Network Configuration Human FriendlyPreprint
Wang, C., Scazzariello, M., Farshin, A., Kostić, D., & Chiesa, M. (2023) · arXiv (Cornell University) · doi:10.48550/arxiv.2309.06342 · Cited by 33 · see citing works
GUARDIAN: Safeguarding LLM Multi-Agent Collaborations with Temporal Graph Modeling
Zhou, J., Wang, L.-C., & Yang, X. (2025) · Neural Information Processing Systems · doi:10.48550/arxiv.2505.19234 · Cited by 44
“The emergence of LLM agents has sparked interest in multi-agent collaboration systems [9, 10, 29], where multiple agents combine capabilities to tackle complex tasks [1, 11].”
Jiang, Y.-Y., & Yang, C. (2024) · ISPRS Int. J. Geo Inf. · doi:10.3390/ijgi13010026 · Cited by 43 · see citing works
“They can be used for a variety of tasks, including natural language processing (NLP), text generation, and even code generation [7].”
BackgroundCan Large Language Models Find And Fix Vulnerable Software?Preprint
Noever, D. A. (2023) · arXiv.org · doi:10.48550/arxiv.2308.10345 · Cited by 43 · see citing works
“This demographic benefits from a personal coding assistant to directly stimulate new ideas for addressing problems [9,26-27, 29 ] in”
BackgroundFranceschelli, G., & Musolesi, M. (2024) · Journal of Artificial Intelligence Research · doi:10.1613/jair.1.15278 · Cited by 52 · see citing works
“Using AI itself to provide feedback is also an option; notably, AI-based feedback is also used outside the RL paradigm, e.g., to provide verbal feedback to be appended to prompts (Shinn et al., 2023) or to collaborate with other LLMs at inference time (Dong et al., 2023; Du et al., 2023).”
BackgroundMethodDeepSeek: Paradigm Shifts and Technical Evolution in Large AI Models
Xiong, L., Wang, H., Chen, X., Sheng, L., Xiong, Y., Liu, J., Xiao, Y., Chen, H., Han, Q., & Tang, Y. S. (2025) · IEEE/CAA Journal of Automatica Sinica · doi:10.1109/jas.2025.125495 · Cited by 46 · see citing works
“In 2022, OpenAI launched ChatGPT, a generative AI chat-bot based on LLMs, which is suitable for natural language processing tasks, such as question answering [19], [20], conversational agents [21], [22], [23], and code completion [24], [25].”
Type-migrating C-to-Rust translation using a large language model
Hong, J., & Ryu, S. (2024) · Empirical Software Engineering · doi:10.1007/s10664-024-10573-2 · Cited by 31 · see citing works
“LLMs have shown promising abilities in code-related tasks, including code generation (Chen et al. 2021a; Dong et al. 2024; Li et al. 2023a,b; Yang et al. 2024a), program repair (Fan et al. 2023; Xia et al. 2023), and code summarization (Ahmed and Devanbu 2023).”
Prompt Engineering or Fine-Tuning: An Empirical Assessment of LLMs for Code
Shin, J., Tang, C. J., Mohati, T., Nayebi, M., Wang, S., & Hemmati, H. (2025) · International Conference on Mining Software Repositories (MSR) · doi:10.1109/msr66628.2025.00082 · Cited by 101 · see citing works
“…Code summarization: [45]–[47]The model generates a short natural language summary from a source code snippet (SC-to-NL), Code generation: [48]–[50]The model generates the corresponding code snippet from a natural language description (NL-to-SC), and Code translation: [51]–[53] The model…”
CODEP: Grammatical Seq2Seq Model for General-Purpose Code Generation
Dong, Y., Li, G., & Jin, Z. G. (2023) · ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA) · doi:10.1145/3597926.3598048 · Cited by 22 · see citing works
“Thus, pre-trained methods with big data-driven usually employ Seq2Seq approaches [2, 8, 11, 14, 23, 38].”
MethodSelf-citationUnveiling ChatGPT’s usage in open source projects: A mining-based study
Tufano, R., Mastropaolo, A., Pepe, F., Dabic, O., Di Penta, M., & Bavota, G. (2024) · Proceedings of the 21st International Conference on Mining Software Repositories · doi:10.1145/3643991.3644918 · Cited by 38 · see citing works
“Dong et al. [61] set up an experimental design aimed at mimicking human teamwork via ChatGPT: The authors assemble a virtual team composed of three ChatGPT instances instructed to cover different roles, namely analyst, programmer, and tester.”
MethodReSo: A Reward-driven Self-organizing LLM-based Multi-Agent System for Reasoning Tasks
Zhou, H., Geng, H.-J., Xue, X., Kang, L., Yin, Z.-F., & Bai, L. (2025) · Conference on Empirical Methods in Natural Language Processing · doi:10.48550/arxiv.2503.02390 · Cited by 39
LLM-SmartAudit: Advanced Smart Contract Vulnerability Detection
Wei, Z.-Y., Sun, J., Zhang, Z.-J., Zhang, X., Li, M., & Hou, Z. (2024) · arXiv.org · doi:10.48550/arxiv.2410.09381 · Cited by 39
“Research in Large Language Models (LLMs) has made significant advancements in fields such as Natural Language Processing [11], Computer Vision [29], Code Generation [15], and various AI tasks [28, 31].”
BackgroundHow Do So ware Developers Use ChatGPT? An Exploratory Study on GitHub Pull Requests
Chouchen, M., Bessghaier, N., Begoug, M., Ouni, A., Alomar, E., & Mkaouer, M. (2024) · IEEE Working Conference on Mining Software Repositories · doi:10.1145/3643991.3645084 · Cited by 39 · see citing works
“Software engineering is no exception to the adoption of LLMs where LLMs such as ChatGPT have been proven to be essential for understanding and generating code [30], documentation [32] and interactions in natural language [20].”
BackgroundCooperation on the Fly: Exploring Language Agents for Ad Hoc Teamwork in the Avalon Game
Shi, Z., Fang, M., Zheng, S., Deng, S., Chen, L., & Du, Y.-L. (2023) · arXiv.org · doi:10.48550/arxiv.2312.17515 · Cited by 39
“Efforts are increasingly focused on leveraging LLMs for complex tasks like planning and reasoning (Wang et al., 2023c; Wu et al., 2023; Dong et al., 2023).”
BackgroundTRANSAGENT: An LLM-Based Multi-Agent System for Code Translation
Yuan, Z.-Q., Chen, W.-T., Wang, H.-L., Yu, K., Peng, X., & Lou, Y. (2024) · arXiv.org · doi:10.48550/arxiv.2409.19894 · Cited by 39
“LLMs have shown great potential in software engineering tasks like code generation [56], [57], [58], program repair [59], [60], and code summarization [61], [62].”
Zheng, D., Wang, Y., Shi, E., Zhang, R., Ma, Y., Zhang, H., & Zheng, Z. (2025) · 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE) · doi:10.1109/icse55347.2025.00228 · Cited by 11 · see citing works
“In recent years, the LLM-based code generation task has drawn widespread attention [24], [25], [36]–[38], [52]–[54], [75], [76].”
Wang, H., Liu, Z., Wang, S., Cui, G., Ding, N., Liu, Z.-Y., & Yu, G. (2023) · Annual Meeting of the Association for Computational Linguistics · doi:10.18653/v1/2024.findings-acl.124 · Cited by 38 · see citing works
NetSafe: Exploring the Topological Safety of Multi-agent Networks
Yu, M., Wang, S., Zhang, G.-B., Mao, J.-Y., Yin, C.-L., Liu, Q., Wen, Q.-S., Wang, K., & Wang, Y. (2024) · arXiv.org · doi:10.48550/arxiv.2410.15686 · Cited by 37
“For instance, MetaGPT [30], ChatDev [59] and [25] explore software development by dividing roles among agent groups within a wa-terfall model.”
Method
- Authors
- Dong, Y., Jiang, X., Jin, Z., & Li, G.
- Affiliations
- Peking University (CN)
- Venue
- ACM Transactions on Software Engineering and Methodology
- Published
- 2024-09-27
- Volume
- 33
- Issue
- 7
- Pages
- 1-38
- ISSN
- 1049-331X (ISSN-L)
- 1557-7392
- OpenAlex
- W4399557965
- Cited by
- 256
- References
- 76
- Citations by year
- 2026: 84 · 2025: 116 · 2024: 43 · 2023: 13
- FWCI
- 91.65
- Type
- journal article
- Language
- en
- Open access
- green
- arxiv.org
- Locations
- ACM Transactions on Software Engineering and Methodology (publishedVersion)
- arXiv (Cornell University) (submittedVersion)
- arXiv (Cornell University)
- Funders
- National Natural Science Foundation of China (62192733, 61832009, 62192731, 62192730, and 62072007)
- Key Program of Hubei (JD2023008)
- Topics
- Physical Sciences › Computer Science › Information Systems › Software Engineering Research
- Physical Sciences › Computer Science › Information Systems › Software Engineering Techniques and Practices
- Physical Sciences › Computer Science › Artificial Intelligence › Topic Modeling
- Keywords
- code generation, large language models, ChatGPT, agent cooperation, virtual teams, software development process, software testing
About these checks
Registry, retraction, Cites and statistics results are computed, not judged, with one exception: a printed reference that no index lists is read once by a model before it counts as a citation error. Claims are extracted by a model and kept only when their quote appears verbatim in the text; each cited source is then checked, with a model’s help, for whether it says what the claim relies on. Those verdicts can be wrong — read the claim’s quote and the cited source before relying on one.
Statistics and arithmetic are recomputed, not judged.
Confidence bands are shown only for fields calibrated on our annotated test set. None is calibrated yet, so no band is shown.
What counts as a claim ›How we measure confidence ›How we check this ›
Are you an author, or do you see a problem with this page? Request a review