SmellCC: A Tool for Automated Code Smells Remediation

SmellCC: A Tool for Automated Code Smells Remediation Xiaoting Zhang

Zhejiang University, Hangzhou High-Tech Zone (Binjiang) Institute of Blockchain and Data Security HangZhou, China xiaotingzhang@zju.edu.cn

Yujie Zhang

Zhejiang University, Hangzhou High-Tech Zone (Binjiang) Institute of Blockchain and Data Security HangZhou, China zhang.yujie@zju.edu.cn

Xing Hu

arXiv:2608.09477v1 [cs.SE] 10 Aug 2026

Zhejiang University, Hangzhou High-Tech Zone (Binjiang) Institute of Blockchain and Data Security HangZhou, China xinghu@zju.edu.cn

Zhipeng Gao∗

Zhejiang University, Hangzhou High-Tech Zone (Binjiang) Institute of Blockchain and Data Security Hangzhou, China zhipeng.gao@zju.edu.cn

Xin Xia

Zhejiang University, Hangzhou High-Tech Zone (Binjiang) Institute of Blockchain and Data Security HangZhou, China xin.xia@acm.org

Abstract

CCS Concepts

Code smells significantly threaten software maintainability by accumulating technical debt, yet developers often lack the resources to manually address these flaws under tight release schedules. While static analysis tools like SonarQube provide precise detection, they function largely as passive alert systems, leaving the burden of refactoring on developers. To bridge this gap, we present a novel cleaning tool, namely SmellCC (Smell Code Cleaner), a Visual Studio Code extension that augments SonarQube with an LLMbased pipeline to automatically detect and refactor Python code smells. By employing Chain-of-Thought (CoT) and few-shot learning, SmellCC provides in-place, one-click remediation for the top-10 most frequent smells, effectively preventing the accumulation of technical debt during development. Our quantitative evaluation demonstrates that our SmellCC is promising in helping developers effectively eliminate code smells (96.8% cleaning rate) with high accuracy (i.e., 91.3%), ensuring that the refactored code remains syntactically correct and behavior-preserving, thereby significantly improving long-term software maintainability. The full paper underlying this tool has been published in ACM Transactions on Software Engineering and Methodology [18], where SmellCC was introduced and evaluated as an offline pipeline for large-scale code corpus cleaning. Extending this prior work, the present paper focuses on an IDE-native implementation of SmellCC that translates SonarQube for IDE diagnostics into interactive, in-place refactoring actions within Visual Studio Code. Demo Video: https://www.youtube.com/watch?v=X5BXBqTfmWk Plugin download: https://github.com/Tdcq14/vscode-smellcc.git

• Software and its engineering → Software maintenance tools.

∗ Corresponding author.

This work is licensed under a Creative Commons Attribution 4.0 International License. ASE ’26, Munich, Germany © 2026 Copyright held by the owner/author(s). ACM ISBN 979-8-4007-2882-2/2026/10 https://doi.org/10.1145/3832783.3834611

Keywords Code Smell, Code Refactoring, Software Maintainability ACM Reference Format: Xiaoting Zhang, Yujie Zhang, Zhipeng Gao, Xing Hu, and Xin Xia. 2026. SmellCC: A Tool for Automated Code Smells Remediation. In Proceedings of the 41st IEEE/ACM International Conference on Automated Software Engineering (ASE ’26), October 12–16, 2026, Munich, Germany. ACM, New York, NY, USA, 5 pages. https://doi.org/10.1145/3832783.3834611

1

INTRODUCTION

In modern software development, code smells—often manifested as suboptimal design choices like long methods or dead code—represent a silent but significant threat to software maintainability. While they do not alter program correctness, these violations of design fundamentals accumulate as technical debt, progressively degrading code quality [4–6, 16, 19]. Developers in practice are often constrained by tight release schedules and/or limited resources, forcing them to prioritize feature delivery over code hygiene. This leaves developers with little bandwidth to manually identify and sanitize these design flaws. Consequently, code smells often remain in the codebase, leading to a steady erosion of software quality and an increase in maintenance costs over time. In light of these practical limitations, researchers have proposed automated tools for software maintenance. RefactorInsight [7], for instance, analyzes change history to identify “hotspots”, effectively prioritizing when to refactor but offering no mechanism to execute the changes. Similarly, static analysis plugins of SonarQube [12], while they integrate seamlessly into the IDE to identify issues with high precision, they function largely as passive alert systems. They excel at pointing out “where” the problem is but lack the capability to resolve “how” to fix it, especially for complex logic, thereby leaving the burden of refactoring entirely on the developer. To address this gap, early automated tools such as Rope [11] for Python, CppRefactory [2] for C++, and JDeodorant [13] for Java, pioneered

ASE ’26, October 12–16, 2026, Munich, Germany

Xiaoting Zhang, Yujie Zhang, Zhipeng Gao, Xing Hu, and Xin Xia

Stage 1: Detection & Context Extraction

Stage 2: LLM-based Refactoring Core Prompt Engineering Pipeline

VS Code IDE

Role Designation (e.g., Expert Software Engineer)

SmellCC Plugin Host

Text & Code Block

Smelly Code Snippet Diagnostic Interceptor

Few-Shot Prompt Palette (SmellSpecific Examples)

Function Scope + Metadata Editor State

Context Slicer

Direct Remediation

Raw LLM Response

VS Code IDE

SonarQube Engine

Stage 3: Response Parsing & Application

Dynamic Prompt Builder Engine

Code Extractor Clean Code Snippet

LLM One-Click Apply

Chain-of-Thought (CoT) Strategy Injector

Composite Structured Prompt

Update Source File

Figure 1: The Overall Framework of Our Approach rule-based refactoring. However, their reliance on predefined rules often limits them to specific crafted patterns, lacking the semantic understanding to address semantic issues. Recently, research has pivoted toward deep learning to overcome these limitations: Ma et al. [8] employed CodeT5 to target Feature Envy, Tufano et al. [14] treated refactoring as a neural translation task, and EMAssist [15] leveraged LLMs specifically for Long Parameter Lists. While these studies validated the feasibility of LLM-based refactoring, they remain restricted in scope, targeting singular smell types or functioning as empirical explorations. Consequently, there is currently no unified tool that organically combines the precision of industry-standard detection with a capability to automatically refactor diverse code smells. To bridge this gap, we present SmellCC, a Visual Studio Code plugin designed to automatically refactor Python code smells. Fundamentally, our SmellCC is engineered to augment and complete the capability of SonarQube by triggering automated refactoring after a smell is detected. Our approach leverages an LLM-based pipeline employing Chain-of-Thought and few-shot learning techniques to ensure that the refactored code is not only clean but also context-aware and behavior-preserving. SmellCC specifically targets the ten most frequent code smells identified in our prior study [18]—ranging from syntactic issues like Dead Code to semantic challenges like High Cognitive Complexity—and provides in-place, one-click refactoring. This allows developers to instantly sanitize their codebase without context switching, effectively preventing the accumulation of technical debt during development.

2

APPROACH

Fig. 1 illustrates the overall framework of SmellCC, which consists of three interconnected phases: the detection and context extraction

phase, the LLM-based refactoring core phase, and the response parsing and application phase. It implements a closed-loop refactoring pipeline integrated directly into VS Code.

2.1

Smell Detection and Context Extraction

To ensure high-precision identification without redundant computation, SmellCC functions as an intelligent downstream consumer of the SonarQube engine. The process begins with the Diagnostic Interceptor, which continuously monitors the IDE’s diagnostic collection and selectively captures telemetry data—including rule keys and cursor coordinates—for the targeted top-10 smell types. Subsequently, the Context Slicer performs a structural analysis of the Abstract Syntax Tree (AST) to expand the selection from the error location to its enclosing semantic scope (e.g., the full function body), which ensures that we extract the complete code context necessary for the LLM to understand the logic and perform a valid refactoring.

2.2

LLM-based Code Smell Refactoring

The underlying approach of SmellCC is prompt engineering, i.e., using natural language to guide LLMs to complete specific tasks. Since LLMs are not designed for refactoring purposes, we leverage prompt role designation, chain-of-thought reasoning, and few-shot learning techniques, which are widely utilized and verified in previous studies [3, 9, 10, 17], to harness the LLMs’ knowledge for automated code smell refactoring. Prompt Role Designation. In prompt engineering, role designation is a method where LLMs are designated a role for solving a specific task. Assigning a role to the LLM provides it with the problem context and leads to more accurate and relevant responses. In this study, we design the role of the LLM as “an expert software engineer”. After assigning the role, we inform the LLM with our task

SmellCC: A Tool for Automated Code Smells Remediation

as follows: “Your task is to refactor code to eliminate code smell while keeping the code functionality.” This can elicit the programming knowledge of the LLM for performing refactoring task. Chain-of-Thought Reasoning. Chain-of-Thought reasoning is an important strategy for prompt engineering. It enables LLMs to split a complicated task into several relatively simple steps and generate a series of intermediate outputs that lead to a reasonable result. Our task of cleaning different code smells requires logical thinking to understand the code and a coherent series of intermediate steps to clean smells. In order to construct a reasonable CoT, we invite two developers, with over 6 and 9 years of Python programming experience, to manually fix the 10 different code smells respectively and write down their core steps as their chain-of-thought reasoning steps. Afterwards, the first author discussed with the two developers to summarize the final steps for each code smell. We take the Collapsible If Statements smell as an example to show the chain-of-thought reasoning process: (1) Step1: Understanding the task requirement; (2) Step2: Analyze the content of two conditions; (3) Step3: Determine the conjunction; (4) Combine the conditions. Overall, this step-by-step thinking guides the LLM to clean smells in a manner similar to a developer. The detailed CoT for other code smells can be found in our replication package [1]. Few-shot Learning. With the increasing ability of LLMs, incontext learning has been widely adopted as zero-shot learning and few-shot learning. Few-shot learning is utilized to augment the context with a few examples of desired inputs and outputs, which helps the model elicit specific knowledge and abstractions needed to complete the task. Regarding the Collapsible If Statements smell, we give an example of the code smell input (e.g., if condition1: if condition2: #code) and the expected code smell output (e.g., if condition1 and condition2: #code). With the help of these representative examples, the LLM can enhance its understanding of the target code smell and its effectiveness for refactoring. Prompt Assembly and Inference. Finally, the Dynamic Prompt Builder Engine synthesizes these strategic components with the detected code context to construct a Composite Structured Prompt. This unified instruction drives the LLM to generate a response comprising both the step-by-step rationale and the refactored code block, ready for extraction in the next stage.

2.3

Response Parsing and Application

In the final stage, the Code Extractor isolates the refactored logic from the LLM’s conversational output to produce a Clean Code Snippet. This snippet is queued for the One-Click Apply mechanism, which allows the developer to instantly inject the optimized code into the editor, physically replacing the detected smell and resolving the technical debt in situ.

3

IMPLEMENTATION DETAILS

We implement SmellCC in the form of a Visual Studio Code plugin. Tool Architecture. SmellCC comprises a diagnostic interceptor, a context slicer, a dynamic prompt builder engine, an LLM client, a response parser, and an edit provider. For each code smell, the diagnostic interceptor first consumes the rule identifier and source range published by SonarQube for IDE and determines whether the issue belongs to one of the ten supported smell categories. Then the

ASE ’26, October 12–16, 2026, Munich, Germany

Figure 2: Real-time detection and tooltip explanation of a code smell in VS Code

Figure 3: The interactive Quick Fix menu allowing developers to trigger SmellCC for in-situ refactoring

context slicer expands the reported location to its enclosing function scope. After that, the dynamic prompt builder engine selects the corresponding smell-specific template inherited from our prior work [18] and instantiates it with the extracted code and diagnostic metadata. After asynchronous LLM inference, the response parser further extracts the generated code, and the edit provider applies it to the original source range through the VS Code editing API. Configuration and Deployment. SmellCC is distributed as a VS Code extension package through GitHub Releases and requires SonarQube for IDE, JRE 17+, and Internet access to an LLM service. Through the VS Code settings interface, developers provide an API key and may configure the API endpoint and model, with DeepSeek-Coder used by default. For LLM, we chose the DeepSeekCoder model, which has proven to have excellent abilities in coding tasks [20], achieving a close and comparable performance with GPT4o. Moreover, the DeepSeek-Coder model is rather cost-effective, compared with GPT-4o, the input token costs just 2.8% and the output token costs just 1.9% of the GPT-4o. Considering the high volume of requests anticipated in a daily coding workflow, we chose DeepSeek-Coder for its powerful code generation capabilities and affordability, making it a sustainable choice for continuous automated refactoring. When using LLMs, the parameter of temperature is a pivotal setting that governs the randomness of the model’s output. In this study, we set the temperature at 0 by a series of pilot experiments. According to the DeepSeek documentation, the max_tokens can reach 8,192. In this study, when handling code smells such as Long Parameter List, we set the max_tokens to 8,192 to deal with the large number of tokens. For other cases, it was set to 2,048 to save time and resources. User Interface. Fig. 2 and Fig. 3 showcase the user interface of SmellCC. To initiate the workflow, developers need to install the SmellCC extension alongside the prerequisite SonarQube for IDE plugin first. The subsequent usage cycle consists of two primary steps: detection and interactive remediation. Once these extensions are installed, the detection mechanism operates automatically in the

ASE ’26, October 12–16, 2026, Munich, Germany

Xiaoting Zhang, Yujie Zhang, Zhipeng Gao, Xing Hu, and Xin Xia

Table 1: Code Smell Refactoring and Code Correctness Testing of 50 projects Code Smell Type

Code Smell Refactoring #After

#Cleaning(%)

#Before

#After

#Accuracy(%)

Naming Convention High Cognitive Complexity Commented Code Long Parameter List Collapsible if Statements Empty Nested Code Blocks Dead Code Self-assigned Variables Identical Expressions Return and Yield

11,579 1,840 1,100 655 648 109 37 13 8 5

62 174 0 256 0 16 0 0 0 0

99.5 90.5 100.0 60.9 100.0 85.3 100.0 100.0 100.0 100.0

11,579 1,840 1,100 655 648 109 37 13 8 5

10,578 1,627 1,100 474 648 107 37 13 8 5

91.4 88.4 100.0 72.4 100.0 98.2 100.0 100.0 100.0 100.0

All

15,994

508

96.8

15,994

14,597

91.3

background. When a code smell is identified—such as the Collapsible If Statements shown in Fig. 2—the editor highlights the problematic code with a diagnostic underline. Hovering over this indicator reveals a detailed tooltip that specifies the smell type and explains the underlying issue. To eliminate the identified smell, the developer simply engages the standard “Quick Fix” mechanism. As illustrated in Fig. 3, this action summons a menu featuring the specific remediation command: “Refactor: [Smell Type] (SMELLCC)”. Selecting this option triggers the refactoring pipeline, which automatically replaces the smelly code snippet with a clean version in situ. In this process, SmellCC invokes the LLM asynchronously, allowing the editor to remain responsive while the request is processed. Once a valid response is received, SmellCC parses the generated code and applies it to the target code for immediate inspection. The edit is recorded as a single editor operation and can be reverted using VS Code’s standard Undo command. If the request or response parsing fails, the extension would report the error and leave the source code unchanged.

4

Code Correctness Testing

#Before

EVALUATION

We evaluate the performance of SmellCC through a quantitative analysis centered on two aspects: the success rate of code smell refactoring (Effectiveness) and the pass rate of regression tests on the refactored code (Correctness). Data Collection. We manually curated a dataset of 50 projects from CodeSearchNet-Python. To ensure diverse code smell coverage, we prioritized projects with high function counts. Each candidate underwent strict manual verification of its testing infrastructure (e.g., presence of test*.py or PyTest); only projects with successfully executable test suites were retained. The final dataset consists of 50 fully configured, verifiable projects ready for evaluation. Experiment Setup. First, to assess refactoring effectiveness, we employed SonarQube to quantify the reduction in the top-10 code smell types across the dataset before and after remediation. Then, to verify functional correctness, we executed regression tests on the refactored code, calculating the success rate to ensure that the original program behavior was strictly preserved. Experiment Result. Table 1 presents the results of code smell elimination and functional correctness testing of 50 projects. The experimental results show that SonarQube detected 15,994 code

smells from the above projects, and SmellCC successfully removed 96.8% of them (15,486 out of 15,994). By running unit tests, we found that 91.3% (14,597 out of 15,994) of the refactored code maintained the same functionality as the original one. This high success rate validates the efficacy of our SmellCC in handling diverse technical debts. From the perspective of different code smell types, several points stand out: m Perfect Refactoring Cases: From the table, we can see that SmellCC shows perfect (i.e., 100%) effectiveness and correctness for six smells: Commented Code, Collapsible if Statements, Dead Code, Self-assigned Variables, Identical Expressions, and Return and Yield. These code smells are relatively straightforward to detect and refactor by syntactic patterns or pre-defined rules; the perfect performance in these cases highlights SmellCC ’s strong capability in handling structurally simple yet common syntactic code issues. m High-Performance Cases: SmellCC is highly effective for cleaning the following three code smells: Naming Convention (99.5% effectiveness and 91.4% correctness), High Cognitive Complexity (90.5% effectiveness and 88.4% correctness), and Empty Nested Code Blocks (85.3% effectiveness and 98.2% correctness). These smell types require a deeper understanding of code semantics and developer’s intent, which goes beyond the surface-level pattern matching. For instance, addressing High Cognitive Complexity requires the model to recognize logical structures, abstract control flow, and restructure the code while preserving its behavior. The success of SmellCC on these cases demonstrates its effectiveness in capturing code context and adhering to structural constraints. It is able to identify complex syntactic patterns and generate standard-compliant edits. l Challenging Cases: The Long Parameter List code smell demonstrates the lowest refactoring effectiveness among all ten categories, achieving only a 60.9% cleaning rate with 72.4% correctness. This relatively poor performance reveals the limitation of SmellCC in handling smells that require more context information and global reasoning, suggesting future improvements through providing more dependency information, extending the context window and employing multi-agent collaboration across multiple functions and files. Implications for Reliable Refactoring. The experimental results show that SmellCC is more reliable for localized, syntaxoriented smells than for refactorings involving broader dependencies, such as High Cognitive Complexity and Long Parameter List.

SmellCC: A Tool for Automated Code Smells Remediation

This suggests that improving reliability requires both stronger behavioral constraints and richer program context. Future versions could incorporate dependency-aware context, reasoning steps that examine call sites and side effects, and few-shot examples matched to the target code structure. Combined with post-generation validation, these improvements could reduce behavioral regressions in complex refactorings.

5

CONCLUSION AND FUTURE WORK

In this paper, we present SmellCC, an IDE-native automated refactoring tool that bridges the gap between code smell detection and refactoring. By synergizing the precision of static analysis (via SonarQube) with the generative capabilities of LLMs (DeepSeekCoder), SmellCC offers a streamlined, one-click solution for managing code smells. Our evaluation demonstrates its efficacy, achieving a 96.8% remediation rate and 91.3% functional correctness across 50 Python projects. In the future, we plan to extend SmellCC by supporting more programming languages (e.g., Java), more IDEs (e.g., IntelliJ IDEA), and configurable LLM backends, while incorporating project-level context to address complex architectural smells in large-scale development environments.

Acknowledgment This research is supported by the National Science Foundation of China (No. 62572322). This research is partially sponsored by the CCF-Huawei Populus Grove Fund and Tencent Rhino-Bird Fund. We also thank the anonymous reviewers for their insightful comments and suggestions.

References [1] 2024. Our replication package. https://zenodo.org/records/17578401. [2] svenreichard blep, jejudd. 2013. CPPRefactory. https://sourceforge.net/projects/ cpptool/. Last accessed: September 9, 2024. [3] Zhenlong Dai, Chang Yao, WenKang Han, Yuanying Yuanying, Zhipeng Gao, and Jingyuan Chen. 2024. Mpcoder: Multi-user personalized code generator with explicit and implicit style representation learning. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 3765–3780. [4] Zhipeng Gao, Yanqi Su, Xing Hu, and Xin Xia. 2024. Automating todo-missed methods detection and patching. ACM Transactions on Software Engineering and Methodology 34, 1 (2024), 1–28. [5] Zhipeng Gao, Xin Xia, David Lo, John Grundy, and Thomas Zimmermann. 2021. Automating the removal of obsolete TODO comments. In Proceedings of the 29th

ASE ’26, October 12–16, 2026, Munich, Germany

ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 218–229. [6] Qiao Huang, Emad Shihab, Xin Xia, David Lo, and Shanping Li. 2018. Identifying self-admitted technical debt in open source projects using text mining. Empirical Software Engineering 23, 1 (2018), 418–451. [7] Zarina Kurbatova, Vladimir Kovalenko, Ioana Savu, Bob Brockbernd, Dan Andreescu, Matei Anton, Roman Venediktov, Elena Tikhomirova, and Timofey Bryksin. 2021. Refactorinsight: Enhancing ide representation of changes in git with refactorings information. In 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 1276–1280. [8] Wenhao Ma, Yaoxiang Yu, Xiaoming Ruan, and Bo Cai. 2023. Pre-trained Model Based Feature Envy Detection. In 2023 IEEE/ACM 20th International Conference on Mining Software Repositories (MSR). IEEE, 430–440. [9] Yubo Mai, Zhipeng Gao, Xing Hu, Lingfeng Bao, Yu Liu, and JianLing Sun. 2024. Are human rules necessary? generating reusable apis with cot reasoning and in-context learning. Proceedings of the ACM on Software Engineering 1, FSE (2024), 2355–2377. [10] Yubo Mai, Zhipeng Gao, Haoye Wang, Tingting Bi, Xing Hu, Xin Xia, and Jianling Sun. 2025. Towards better answers: Automated stack overflow post updating. In 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE, 591–603. [11] Ali Gholami Rudi and Lie Ryan. 2024. Rope: A Python Refactoring Library. https://github.com/python-rope/rope. Last accessed: September 9, 2024. [12] SonarSource. 2025. SonarLint: IDE static code analysis. https://marketplace. visualstudio.com/items?itemName=SonarSource.sonarlint-vscode [13] Nikolaos Tsantalis, Theodoros Chaikalis, and Alexander Chatzigeorgiou. 2008. JDeodorant: Identification and removal of type-checking bad smells. In 2008 12th European conference on software maintenance and reengineering. IEEE, 329–331. [14] Michele Tufano, Jevgenija Pantiuchina, Cody Watson, Gabriele Bavota, and Denys Poshyvanyk. 2019. On learning meaningful code changes via neural machine translation. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). IEEE, 25–36. [15] Nalin Wadhwa, Jui Pradhan, Atharv Sonwane, Surya Prakash Sahu, Nagarajan Natarajan, Aditya Kanade, Suresh Parthasarathy, and Sriram Rajamani. 2024. CORE: Resolving Code Quality Issues using LLMs. Proceedings of the ACM on Software Engineering 1, FSE (2024), 789–811. [16] Haoye Wang, Zhipeng Gao, Xing Hu, David Lo, John Grundy, and Xinyu Wang. 2024. Just-in-time todo-missed commits detection. IEEE Transactions on Software Engineering 50, 11 (2024), 2732–2752. [17] Zhipeng Xue, Zhipeng Gao, Shaohua Wang, Xing Hu, Xin Xia, and Shanping Li. 2024. Selfpico: Self-guided partial code execution with llms. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. 1389–1401. [18] Zhipeng Xue, Xiaoting Zhang, Zhipeng Gao, Xing Hu, Shan Gao, Xin Xia, and Shanping Li. 2026. Clean Code, Better Models: Enhancing LLM Performance with Smell-Cleaned Dataset. ACM Trans. Softw. Eng. Methodol. (2026). doi:10. 1145/3793252 Just Accepted. [19] Dapeng Yan, Wenjie Yang, Zhipeng Gao, Kui Liu, Zhikuang Cai, Xiaoyuan Xie, and Zhiming Liu. 2026. Evolving Trends in Cleanliness of Open Source Projects. ACM Transactions on Software Engineering and Methodology (2026). [20] Qihao Zhu, Daya Guo, Zhihong Shao, Dejian Yang, Peiyi Wang, Runxin Xu, Y Wu, Yukun Li, Huazuo Gao, Shirong Ma, et al. 2024. DeepSeek-Coder-V2: Breaking the Barrier of Closed-Source Models in Code Intelligence. arXiv preprint arXiv:2406.11931 (2024).

Received 2026-05-11; accepted 2026-06-19

Related documents

• Revisiting Code Debloating with Ground Truth-based Evaluation#120588
• Fine-grained Multi-Document Extraction and Generation of Code Change Rationale#10448
• Revisiting Feedback-Driven LLM Code Repair: A Replication and Exploratory Java Extension#819814
• Revisiting Feedback-Driven LLM Code Repair: A Replication and Exploratory Java Extension#809818
• Fidelity Probes for Specification--Code Alignment#1116286