The core challenge the team tackled is one that haunts deep learning across domains: neural networks are insatiably hungry for large, diverse, well-labeled datasets. In software engineering, that hunger is hard to satisfy. Annotated code smell datasets are scarce, expensive to produce, and heavily skewed—some smell types dominate the labeled examples while others appear only in tiny numbers. Class imbalance of this kind pushes a neural network toward the majority categories, leaving it nearly blind to the minority ones, which are often the most damaging defects. Data augmentation, the technique of programmatically expanding a training set without collecting new real-world samples, has transformed fields like image recognition and natural language processing, but translating it to source code has proven far trickier, because code must remain syntactically valid and semantically faithful after any transformation.

The researchers’ solution leans on a practice every programmer already knows: refactoring, the discipline-preserving rearrangement of code that changes its internal structure without altering its external behavior. Because a refactor is guaranteed to keep a program’s functionality intact while reshaping its form, it provides a principled way to generate legitimate new training variants of the same code. The team compared two augmentation engines: a rule-based approach that applies classical refactoring operations directly, and a large language model-based approach that uses generative models to produce refactored variants of source code. Crucially, they paired these with a loss penalty, an algorithmic balancing scheme for neural network training that penalizes errors on underrepresented classes more heavily, aiming to counteract the dataset’s skew from the optimization side as well as the data side.

To represent code in a form a neural network can digest, the team turned to pre-trained transformer models from the BERT family: the original BERT, which treats code as plain text; CodeBERT, which was pre-trained jointly on programming and natural languages; and GraphCodeBERT, which additionally incorporates the data-flow structure of programs during pre-training. Each model converts snippets of source code into dense numerical embeddings—vector fingerprints of a program’s semantics—which then serve as inputs to the downstream classification network. This embedding stage matters because two pieces of code that differ only in formatting or naming should map to nearby points in the embedding space, and the more structurally aware the embedding model, the more stable that mapping should be under refactoring.

The experimental results delivered a clear verdict. Code refactoring-based augmentation powered by GraphCodeBERT embeddings and large language models measurably enhanced classifier performance, and its benefits were most pronounced precisely where deep learning models are weakest: the imbalanced, underrepresented smell classes. When the team analyzed how the volume of augmented data influenced outcomes, they discovered a pattern of diminishing returns with an important twist. The greatest improvement arrived with the first increments of augmentation applied to minority classes; beyond that point, adding more synthetic examples yielded progressively smaller gains. The impact of augmentation volume also varied depending on the size of the class being boosted, a finding the researchers argue should inform how practitioners budget their augmentation efforts rather than blanket-duplicating synthetic data across all categories.

Equally instructive were the negative results. The loss penalty mechanism, which was expected to amplify the benefit of augmentation by rebalancing training dynamics, had a negligible effect on overall performance—and in some configurations proved actively detrimental. Augmentation based on vanilla BERT and CodeBERT embeddings likewise failed to move the needle or even hurt accuracy in certain settings. The implication is that not all code-aware embeddings are created equal: models that ignore program structure, such as plain BERT, appear unable to fully exploit refactored variants, while GraphCodeBERT’s data-flow-informed pre-training gives it the structural sensitivity needed to recognize that a refactored snippet and its original are two faces of the same entity.

Beyond the headline results, the study makes a methodological contribution of its own. Evaluating augmentation strategies requires repeatedly testing how performance responds to different volumes of synthetic data across multiple classes, a combinatorially expensive process. To tame this, the team developed a novel weighting strategy that optimizes the evaluation of augmentation volume distribution, cutting the computational overhead of the analysis while preserving its analytical precision. This kind of efficiency matters in practice, because organizations auditing large industrial codebases cannot afford exhaustive, compute-hungry tuning cycles for every detection model they deploy. The weighting scheme, the authors suggest, could become a reusable tool for anyone designing augmentation pipelines for code intelligence systems.

The broader significance of the work lies in what it says about the mechanics of learning from code. The findings reinforce a growing consensus that source code should not be treated as ordinary text. Programs carry rich graph-structured semantics—call graphs, data dependencies, inheritance hierarchies—and augmentation strategies that respect and exploit those structures deliver gains that text-level tricks cannot match. The results align with a wave of recent research on code-specific augmentation, from clone-aware contrastive learning to mixup-based transformations, but they are among the first to systematically quantify the relationship between augmentation volume, class size, and model architecture in the code smell domain, and to do so while comparing rule-based and LLM-based generation head to head.

For software engineering teams, the practical takeaway is immediately actionable. Code smell detection models trained with refactoring-based augmentation and structure-aware embeddings should be more reliable at flagging underrepresented defect patterns—precisely the smells that human reviewers most often miss. Because refactoring transformations are behavior-preserving by construction, the synthetic data they generate avoids the hallucination risks that come with purely generative augmentation, offering a safer middle ground between hand-crafted rules and free-form LLM generation. The researchers have also made their work reproducible, releasing all related source code and data through public repositories on GitHub and Zenodo, lowering the barrier for other teams to adopt and extend the technique.

Looking ahead, the authors suggest that code refactoring-based augmentation could drive the development of more efficient data augmentation strategies not only for code smell classification but for deep learning applications across software engineering more broadly—vulnerability detection, code search, clone detection, and automated repair among them. The lesson generalizes: when real-world labeled data is scarce, the discipline of software engineering itself, with its guarantees of behavioral equivalence, can become the engine that manufactures trustworthy training data. In a field racing to replace human code reviewers with machines, teaching models to see the same code through many refactored lenses may prove one of the most cost-effective ways to give them the experience they need—without a single additional line of manually annotated code.

Subject of Research: Data augmentation via code refactoring to improve deep learning-based code smell classification.

Article Title: Enhancing code smell classification with code refactoring-based data augmentation

Article References: Nizam, A., Aydin, M., Islamoglu, E., Sahmoud, S., & Ozaydin, S. B. (2026). Enhancing code smell classification with code refactoring-based data augmentation. Knowledge and Information Systems, 68(1), Article 254. https://doi.org/10.1007/s10115-026-02859-2

Image Credits: AI Generated

DOI: 10.1007/s10115-026-02859-2

Keywords: code smell, data augmentation, code refactoring, code embedding, GraphCodeBERT, CodeBERT, BERT, large language models, class imbalance, deep learning, software quality, Enhancing