Tootfinder

Retrieval-Augmented Code Review Comment Generation
Hyunsun Hong, Jongmoon Baik
https://arxiv.org/abs/2506.11591 https://arxiv.org/pdf…

Retrieval-Augmented Code Review Comment Generation
Automated code review comment generation (RCG) aims to assist developers by automatically producing natural language feedback for code changes. Existing approaches are primarily either generation-based, using pretrained language models, or information retrieval-based (IR), reusing comments from similar past examples. While generation-based methods leverage code-specific pretraining on large code-natural language corpora to learn semantic relationships between code and natural language, they oft…

Some developers say GPT-5 excels at technical reasoning and planning coding tasks and is cost-effective, but Claude Opus and Sonnet still produce better code (Lauren Goode/Wired)
https://www.wired.com/story/gpt-5-coding-review-software-engineering/

Developers Say GPT-5 Is a Mixed Bag
Software engineers are finding that OpenAI’s new GPT-5 model is helping them think through coding problems—but isn’t much better at actual coding.

from my link log —
cargo-crev: A web-of-trust code review system for Rust.
https://github.com/crev-dev/cargo-crev
saved 2025-09-09 https://

GitHub - crev-dev/cargo-crev: A cryptographically verifiable code review system for the cargo (Rust) package manager.
A cryptographically verifiable code review system for the cargo (Rust) package manager. - crev-dev/cargo-crev

Tried GitHub Copilot code review, and it doesn’t understand the concept of future-dating blog posts. Worse, it suggests a random-ass date. This stuff sucks.

A Review of Cloud Computing in Seismology
Yiyu Ni, Marine A. Denolle, Jannes Munchmeyer, Yinzhi Wang, Kuan-Fu Feng, Carlos Garcia Jurado Suarez, Amanda M. Thomas, Chad Trabant, Alex Hamilton, David Mencin
https://arxiv.org/abs/2506.11307

A Review of Cloud Computing in Seismology
Seismology has entered the petabyte era, driven by decades of continuous recordings of broadband networks, the increase in nodal seismic experiments, and the recent emergence of Distributed Acoustic Sensing (DAS). This review explains how commercial clouds - AWS, Google Cloud, and Azure - by providing object storage, elastic compute, and managed databases, enable researchers to "bring the code to the data," thereby overcoming traditional HPC solutions' bandwidth and capacity limitations. After …

Quo Vadis, Code Review? Exploring the Future of Code Review
Michael Dorner, Andreas Bauer, Darja \v{S}mite, Lukas Thode, Daniel Mendez, Ricardo Britto, Stephan Lukasczyk, Ehsan Zabardast, Michael Kormann
https://arxiv.org/abs/2508.06879

Quo Vadis, Code Review? Exploring the Future of Code Review
Code review has long been a core practice in collaborative software engineering. In this research, we explore how practitioners reflect on code review today and what changes they anticipate in the near future. We then discuss the potential long-term risks of these anticipated changes for the evolution of code review and its role in collaborative software engineering.

Code-Switching in End-to-End Automatic Speech Recognition: A Systematic Literature Review
Maha Tufail Agro, Atharva Kulkarni, Karima Kadaoui, Zeerak Talat, Hanan Aldarmaki
https://arxiv.org/abs/2507.07741

Code-Switching in End-to-End Automatic Speech Recognition: A Systematic Literature Review
Motivated by a growing research interest into automatic speech recognition (ASR), and the growing body of work for languages in which code-switching (CS) often occurs, we present a systematic literature review of code-switching in end-to-end ASR models. We collect and manually annotate papers published in peer reviewed venues. We document the languages considered, datasets, metrics, model choices, and performance, and present a discussion of challenges in end-to-end ASR for code-switching. Our …

Vibe Coding for UX Design: Understanding UX Professionals' Perceptions of AI-Assisted Design and Development
Jie Li, Youyang Hou, Laura Lin, Ruihao Zhu, Hancheng Cao, Abdallah El Ali
https://arxiv.org/abs/2509.10652

Vibe Coding for UX Design: Understanding UX Professionals' Perceptions of AI-Assisted Design and Development
Generative AI is reshaping UX design practices through "vibe coding," where UX professionals express intent in natural language and AI translates it into functional prototypes and code. Despite rapid adoption, little research has examined how vibe coding reconfigures UX workflows and collaboration. Drawing on interviews with 20 UX professionals across enterprises, startups, and academia, we show how vibe coding follows a four-stage workflow of ideation, AI generation, debugging, and review. Thi…

@… @… that's something I do reviewing humans. I usually start review with the tests, and if the tests seem to have gaps, the code probably does too. If they seem sufficiently thorough, the code probably needs less focus on the logic a…

Probing Pre-trained Language Models on Code Changes: Insights from ReDef, a High-Confidence Just-in-Time Defect Prediction Dataset
Doha Nam, Taehyoun Kim, Duksan Ryu, Jongmoon Baik
https://arxiv.org/abs/2509.09192

Probing Pre-trained Language Models on Code Changes: Insights from ReDef, a High-Confidence Just-in-Time Defect Prediction Dataset
Just-in-Time software defect prediction (JIT-SDP) plays a critical role in prioritizing risky code changes during code review and continuous integration. However, existing datasets often suffer from noisy labels and low precision in identifying bug-inducing commits. To address this, we present ReDef (Revert-based Defect dataset), a high-confidence benchmark of function-level modifications curated from 22 large-scale C/C++ projects. Defective cases are anchored by revert commits, while clean cas…

From Provable Correctness to Probabilistic Generation: A Comparative Review of Program Synthesis Paradigms
Zurabi Kobaladze, Anna Arnania, Tamar Sanikidze
https://arxiv.org/abs/2508.00013

From Provable Correctness to Probabilistic Generation: A Comparative Review of Program Synthesis Paradigms
Program synthesis--the automated generation of executable code from high-level specifications--has been a central goal of computer science for over fifty years. This thesis provides a comparative literature review of the main paradigms that have shaped the field, tracing its evolution from formal logic based methods to recent advances using large scale neural models. We examine five key approaches: logic based (deductive) synthesis, inductive (example based) synthesis, sketch/schema based synth…

"the new review of the earlier assessment does not dispute the conclusion that Russia favored the election of Donald J. Trump." #GiftLink
C.I.A. Says Its Leaders Rushed Report on Russia Interference in 2016 Vote - The New York Times
https://www.nytimes.com/2025/07/02/us/politics/russia-trump-2016-election.html?unlocked_article_code=1.Tk8.1oh0.obRdrVnArZxp&smid=url-share

"Looks Good to Me"
https://www.manning.com/books/looks-good-to-me?utm_source=frankel&utm_medium=affiliate&utm_campaign=affiliate&a_aid=frankel

ByteDance's publishing imprint 8th Note Press began informing writers and agents in late May that it was closing and returning publication rights to authors (Alexandra Alter/New York Times)
https://www.

Buzzy Publisher Started by TikTok’s Owner Abruptly Shuts Down
8th Note Press informed writers and agents that it is abruptly shutting down and returning publication rights to authors.

@… @… SmartBear researched this in depth in 2015 and demonstrated, with data, what you’re saying.

Watching the frustratingly fruitless fights over the USEFULNESS of LLM-based coding helpers, I've come down to 3 points that explain why ppl seem to live in different realities:
Most programmers:
1) Write inconsequential remixes of trivial code that has been written many times before.
2) Lack the taste for good design & suck at code review in general (yours truly included).
3) Lack the judgement to differentiate between 1) & FOSS repos of nontrivial code, …

GitLab 18.1 supports Orcid identifiers in user profiles: https://about.gitlab.com/releases/2025/06/19/gitlab-18-1-released/#orcid-identifier-in-user-profile

GitLab 18.1 released with Maven virtual registry (beta) and Duo Code Review
GitLab 18.1 released with Maven virtual registry (beta), Duo Code Review, Compromised password detection, and SLSA level 1 with components!

ChatGPT for Code Refactoring: Analyzing Topics, Interaction, and Effective Prompts
Eman Abdullah AlOmar, Luo Xu, Sofia Martinez, Anthony Peruma, Mohamed Wiem Mkaouer, Christian D. Newman, Ali Ouni
https://arxiv.org/abs/2509.08090

ChatGPT for Code Refactoring: Analyzing Topics, Interaction, and Effective Prompts
Large Language Models (LLMs), such as ChatGPT, have become widely popular and widely used in various software engineering tasks such as refactoring, testing, code review, and program comprehension. Although recent studies have examined the effectiveness of LLMs in recommending and suggesting refactoring, there is a limited understanding of how developers express their refactoring needs when interacting with ChatGPT. In this paper, our goal is to explore interactions related to refactoring betwe…

Covid Vaccine Opponent Tapped to Lead Federal Review Team (Christina Jewett/New York Times)
https://www.nytimes.com/2025/08/22/health/covid-vaccines-rfk.html?unlocked_article_code=1.gE8.q-u0.YKJ7VwZQMZmg&smid=url-share
http://www.memeorandum.com/250822/p141#a250822p141

Beim #TagDerDigitalenFreiheit vom @… in #Tübingen am 26./27.07. gibts von mir einen Vortrag, wie man alles Mögliche mit :git:

Next up: principles of using AI for software dev.
For one, don't hand off code for review that you haven't reviewed yourself.
For another, exec expectations don't match current reality on what AI can('t) do.
#GophersUnite

Does AI Code Review Lead to Code Changes? A Case Study of GitHub Actions
Kexin Sun, Hongyu Kuang, Sebastian Baltes, Xin Zhou, He Zhang, Xiaoxing Ma, Guoping Rong, Dong Shao, Christoph Treude
https://arxiv.org/abs/2508.18771

Does AI Code Review Lead to Code Changes? A Case Study of GitHub Actions
AI-based code review tools automatically review and comment on pull requests to improve code quality. Despite their growing presence, little is known about their actual impact. We present a large-scale empirical study of 16 popular AI-based code review actions for GitHub workflows, analyzing more than 22,000 review comments in 178 repositories. We investigate (1) how these tools are adopted and configured, (2) whether their comments lead to code changes, and (3) which factors influence their ef…

Automating Thematic Review of Prevention of Future Deaths Reports: Replicating the ONS Child Suicide Study using Large Language Models
Sam Osian, Arpan Dutta, Sahil Bhandari, Iain E. Buchan, Dan W. Joyce
https://arxiv.org/abs/2507.20786

Automating Thematic Review of Prevention of Future Deaths Reports: Replicating the ONS Child Suicide Study using Large Language Models
Prevention of Future Deaths (PFD) reports, issued by coroners in England and Wales, flag systemic hazards that may lead to further loss of life. Analysis of these reports has previously been constrained by the manual effort required to identify and code relevant cases. In 2025, the Office for National Statistics (ONS) published a national thematic review of child-suicide PFD reports ($\leq$ 18 years), identifying 37 cases from January 2015 to November 2023 - a process based entirely on manual c…

Teaching Programming in the Age of Generative AI: Insights from Literature, Pedagogical Proposals, and Student Perspectives
Clemente Rubio-Manzano, Jazna Meza, Rodolfo Fernandez-Santibanez, Christian Vidal-Castro
https://arxiv.org/abs/2507.00108

Teaching Programming in the Age of Generative AI: Insights from Literature, Pedagogical Proposals, and Student Perspectives
Computer programming is undergoing a true transformation driven by powerful new tools for automatic source code generation based on large language models. This transformation is also manifesting in introductory programming courses at universities around the world, generating an in-depth debate about how programming content should be taught, learned, and assessed in the context of generative artificial intelligence. This article aims, on the one hand, to review the most relevant studies on thi…

Automated Code Review Using Large Language Models at Ericsson: An Experience Report
Shweta Ramesh, Joy Bose, Hamender Singh, A K Raghavan, Sujoy Roychowdhury, Giriprasad Sridhara, Nishrith Saini, Ricardo Britto
https://arxiv.org/abs/2507.19115

Automated Code Review Using Large Language Models at Ericsson: An Experience Report
Code review is one of the primary means of assuring the quality of released software along with testing and static analysis. However, code review requires experienced developers who may not always have the time to perform an in-depth review of code. Thus, automating code review can help alleviate the cognitive burden on experienced software developers allowing them to focus on their primary activities of writing code to add new features and fix bugs. In this paper, we describe our experience in…

“Developers on teams with high AI adoption complete 21% more tasks and merge 98% more pull requests, but PR review time increases 91%, revealing a critical bottleneck: human approval.“
Maybe it’s confirmation bias, but I can see that. You generate more, maybe harder to comprehend, code that still has to be double checked by people who weren’t involved in the process. That slows you down unless you ignore understanding by, you guessed it, moving fast and breaking things.

The AI Productivity Paradox Research Report | Faros AI
Key findings from the AI Productivity Paradox Report 2025. Research reveals AI coding assistants increase developer output, but not company productivity. Uncover strategies and enablers for a measurable return on investment.

Benchmarking and Studying the LLM-based Code Review
Zhengran Zeng, Ruikai Shi, Keke Han, Yixin Li, Kaicheng Sun, Yidong Wang, Zhuohao Yu, Rui Xie, Wei Ye, Shikun Zhang
https://arxiv.org/abs/2509.01494 …

Benchmarking and Studying the LLM-based Code Review
Automated Code Review (ACR) is crucial for software quality, yet existing benchmarks often fail to reflect real-world complexities, hindering the evaluation of modern Large Language Models (LLMs). Current benchmarks frequently focus on fine-grained code units, lack complete project context, and use inadequate evaluation metrics. To address these limitations, we introduce SWRBench , a new benchmark comprising 1000 manually verified Pull Requests (PRs) from GitHub, offering PR-centric review with…

LLM-Driven Collaborative Model for Untangling Commits via Explicit and Implicit Dependency Reasoning
Bo Hou, Xin Tan, Kai Zheng, Fang Liu, Yinghao Zhu, Li Zhang
https://arxiv.org/abs/2507.16395

LLM-Driven Collaborative Model for Untangling Commits via Explicit and Implicit Dependency Reasoning
Atomic commits, each of which addresses a single development concern, are a best practice in software development. However, developers frequently produce tangled commits that mix unrelated changes due to practical constraints or unclear boundaries, negatively impacting code review and maintenance. Although prior commit untangling approaches: rule-based, feature-based, or graph-based, have made progress, they often rely on shallow signals and fail to distinguish between explicit dependencies (e.…

Fine-Tuning Multilingual Language Models for Code Review: An Empirical Study on Industrial C# Projects
Igli Begolli, Meltem Aksoy, Daniel Neider
https://arxiv.org/abs/2507.19271

Fine-Tuning Multilingual Language Models for Code Review: An Empirical Study on Industrial C# Projects
Code review is essential for maintaining software quality but often time-consuming and cognitively demanding, especially in industrial environments. Recent advancements in language models (LMs) have opened new avenues for automating core review tasks. This study presents the empirical evaluation of monolingual fine-tuning on the performance of open-source LMs across three key automated code review tasks: Code Change Quality Estimation, Review Comment Generation, and Code Refinement. We fine-tun…

from my link log —
Why some of us like "interdiff" code review.
https://gist.github.com/thoughtpolice/9c45287550a56b2047c6311fbadebed2
saved 2025-08-20

Automatic Identification of Machine Learning-Specific Code Smells
Peter Hamfelt, Ricardo Britto, Lincoln Rocha, Camilo Almendra
https://arxiv.org/abs/2508.02541 https://

Automatic Identification of Machine Learning-Specific Code Smells
Machine learning (ML) has rapidly grown in popularity, becoming vital to many industries. Currently, the research on code smells in ML applications lacks tools and studies that address the identification and validity of ML-specific code smells. This work investigates suitable methods and tools to design and develop a static code analysis tool (MLpylint) based on code smell criteria. This research employed the Design Science Methodology. In the problem identification phase, a literature review w…

Metamorphic Testing of Deep Code Models: A Systematic Literature Review
Ali Asgari, Milan de Koning, Pouria Derakhshanfar, Annibale Panichella
https://arxiv.org/abs/2507.22610 h…

Metamorphic Testing of Deep Code Models: A Systematic Literature Review
Large language models and deep learning models designed for code intelligence have revolutionized the software engineering field due to their ability to perform various code-related tasks. These models can process source code and software artifacts with high accuracy in tasks such as code completion, defect detection, and code summarization; therefore, they can potentially become an integral part of modern software engineering practices. Despite these capabilities, robustness remains a critical…

Automated Code Review Using Large Language Models with Symbolic Reasoning
Busra Icoz, Goksel Biricik
https://arxiv.org/abs/2507.18476 https://arxiv.org/pdf…

Automated Code Review Using Large Language Models with Symbolic Reasoning
Code review is one of the key processes in the software development lifecycle and is essential to maintain code quality. However, manual code review is subjective and time consuming. Given its rule-based nature, code review is well suited for automation. In recent years, significant efforts have been made to automate this process with the help of artificial intelligence. Recent developments in Large Language Models (LLMs) have also emerged as a promising tool in this area, but these models ofte…

Measuring the effectiveness of code review comments in GitHub repositories: A machine learning approach
Shadikur Rahman, Umme Ayman Koana, Hasibul Karim Shanto, Mahmuda Akter, Chitra Roy, Aras M. Ismael
https://arxiv.org/abs/2508.16053

Measuring the effectiveness of code review comments in GitHub repositories: A machine learning approach
This paper illustrates an empirical study of the working efficiency of machine learning techniques in classifying code review text by semantic meaning. The code review comments from the source control repository in GitHub were extracted for development activity from the existing year for three open-source projects. Apart from that, programmers need to be aware of their code and point out their errors. In that case, it is a must to classify the sentiment polarity of the code review comments to a…

AI-Assisted Fixes to Code Review Comments at Scale
Chandra Maddila, Negar Ghorbani, James Saindon, Parth Thakkar, Vijayaraghavan Murali, Rui Abreu, Jingyue Shen, Brian Zhou, Nachiappan Nagappan, Peter C. Rigby
https://arxiv.org/abs/2507.13499

AI-Assisted Fixes to Code Review Comments at Scale
Aim. There are 10s of thousands of code review comments each week at Meta. We developed Metamate for Code Review (MetaMateCR) that provides AI-assisted fixes for reviewer comments in production at scale. Method. We developed an internal benchmark of 64k data points to fine-tune Llama models. Once our models achieve reasonable offline results, we roll them into production. To ensure that our AI-assisted fixes do not negatively impact the time it takes to do code reviews…

Previously on... Automating Code Review
Robert Heum\"uller, Frank Ortmeier
https://arxiv.org/abs/2508.18003 https://arxiv.org/pdf/2508.18003

Previously on... Automating Code Review
Modern Code Review (MCR) is a standard practice in software engineering, yet it demands substantial time and resource investments. Recent research has increasingly explored automating core review tasks using machine learning (ML) and deep learning (DL). As a result, there is substantial variability in task definitions, datasets, and evaluation procedures. This study provides the first comprehensive analysis of MCR automation research, aiming to characterize the field's evolution, formalize lear…

An Empirical Study on the Amount of Changes Required for Merge Request Acceptance
Samah Kansab, Mohammed Sayagh, Francis Bordeleau, Ali Tizghadam
https://arxiv.org/abs/2507.23640

An Empirical Study on the Amount of Changes Required for Merge Request Acceptance
Code review (CR) is essential to software development, helping ensure that new code is properly integrated. However, the CR process often involves significant effort, including code adjustments, responses to reviewers, and continued implementation. While past studies have examined CR delays and iteration counts, few have investigated the effort based on the volume of code changes required, especially in the context of GitLab Merge Requests (MRs), which remains underexplored. In this paper, we d…

Machine Learning Pipeline for Software Engineering: A Systematic Literature Review
Samah Kansab
https://arxiv.org/abs/2508.00045 https://arxiv.org/pdf/2508…

Machine Learning Pipeline for Software Engineering: A Systematic Literature Review
The rapid advancement of software development practices has introduced challenges in ensuring quality and efficiency across the software engineering (SE) lifecycle. As SE systems grow in complexity, traditional approaches often fail to scale, resulting in longer debugging times, inefficient defect detection, and resource-heavy development cycles. Machine Learning (ML) has emerged as a key solution, enabling automation in tasks such as defect prediction, code review, and release quality estimati…

Socio-Technical Smell Dynamics in Code Samples: A Multivocal Review on Emergence, Evolution, and Co-Occurrence
Arthur Bueno, Bruno Cafeo, Maria Cagnin, Awdren Font\~ao
https://arxiv.org/abs/2507.13481

Socio-Technical Smell Dynamics in Code Samples: A Multivocal Review on Emergence, Evolution, and Co-Occurrence
Code samples play a pivotal role in open-source ecosystems (OSSECO), serving as lightweight artifacts that support knowledge transfer, onboarding, and framework adoption. Despite their instructional relevance, these samples are often governed informally, with minimal review and unclear ownership, which increases their exposure to socio-technical degradation. In this context, the co-occurrence and longitudinal interplay of code smells (e.g., large classes, poor modularity) and community smells (…

Uncovering Systematic Failures of LLMs in Verifying Code Against Natural Language Specifications
Haolin Jin, Huaming Chen
https://arxiv.org/abs/2508.12358 https://

Uncovering Systematic Failures of LLMs in Verifying Code Against Natural Language Specifications
Large language models (LLMs) have become essential tools in software development, widely used for requirements engineering, code generation and review tasks. Software engineers often rely on LLMs to assess whether system code implementation satisfy task requirements, thereby enhancing code robustness and accuracy. However, it remains unclear whether LLMs can reliably determine whether the code complies fully with the given task descriptions, which is usually natural language specifications. In …

The Impact of Large Language Models (LLMs) on Code Review Process
Antonio Collante, Samuel Abedu, SayedHassan Khatoonabadi, Ahmad Abdellatif, Ebube Alor, Emad Shihab
https://arxiv.org/abs/2508.11034

The Impact of Large Language Models (LLMs) on Code Review Process
Large language models (LLMs) have recently gained prominence in the field of software development, significantly boosting productivity and simplifying teamwork. Although prior studies have examined task-specific applications, the phase-specific effects of LLM assistance on the efficiency of code review processes remain underexplored. This research investigates the effect of GPT on GitHub pull request (PR) workflows, with a focus on reducing resolution time, optimizing phase-specific performance…

Automated Validation of LLM-based Evaluators for Software Engineering Artifacts
Ora Nova Fandina, Eitan Farchi, Shmulik Froimovich, Rami Katan, Alice Podolsky, Orna Raz, Avi Ziv
https://arxiv.org/abs/2508.02827

Automated Validation of LLM-based Evaluators for Software Engineering Artifacts
Automation in software engineering increasingly relies on large language models (LLMs) to generate, review, and assess code artifacts. However, establishing LLMs as reliable evaluators remains an open challenge: human evaluations are costly, subjective and non scalable, while existing automated methods fail to discern fine grained variations in artifact quality. We introduce REFINE (Ranking Evaluators for FIne grained Nuanced Evaluation), an automated framework for benchmarking LLM based eval…

WIP: Leveraging LLMs for Enforcing Design Principles in Student Code: Analysis of Prompting Strategies and RAG
Dhruv Kolhatkar, Soubhagya Akkena, Edward F. Gehringer
https://arxiv.org/abs/2508.11717

WIP: Leveraging LLMs for Enforcing Design Principles in Student Code: Analysis of Prompting Strategies and RAG
This work-in-progress research-to-practice paper explores the integration of Large Language Models (LLMs) into the code-review process for open-source software projects developed in computer science and software engineering courses. The focus is on developing an automated feedback tool that evaluates student code for adherence to key object-oriented design principles, addressing the need for more effective and scalable methods to teach software design best practices. The innovative practice inv…

ChangePrism: Visualizing the Essence of Code Changes
Lei Chen, Michele Lanza, Shinpei Hayashi
https://arxiv.org/abs/2508.12649 https://arxiv.org/pdf/2508.1…

ChangePrism: Visualizing the Essence of Code Changes
Understanding the changes made by developers when they submit a pull request and/or perform a commit on a repository is a crucial activity in software maintenance and evolution. The common way to review changes relies on examining code diffs, where textual differences between two file versions are highlighted in red and green to indicate additions and deletions of lines. This can be cumbersome for developers, making it difficult to obtain a comprehensive overview of all changes in a commit. Mor…

LLMs in Coding and their Impact on the Commercial Software Engineering Landscape
Vladislav Belozerov, Peter J Barclay, Askhan Sami
https://arxiv.org/abs/2506.16653

LLMs in Coding and their Impact on the Commercial Software Engineering Landscape
Large-language-model coding tools are now mainstream in software engineering. But as these same tools move human effort up the development stack, they present fresh dangers: 10% of real prompts leak private data, 42% of generated snippets hide security flaws, and the models can even ``agree'' with wrong ideas, a trait called sycophancy. We argue that firms must tag and review every AI-generated line of code, keep prompts and outputs inside private or on-premises deployments, obey emerging safet…

Replaced article(s) found for cs.SE. https://arxiv.org/list/cs.SE/new
[1/1]:
- Knowledge-Guided Prompt Learning for Request Quality Assurance in Public Code Review
Lin Li, Xinchun Yu, Xinyu Chen, Peng Liang