AI-Driven Software Engineering: A Systematic Review of Machine Learning’s Impact and Future Directions

1. Introduction

Software engineering is a rapidly expanding field that encompasses designing, developing, maintaining, implementing, and evolving software systems in a systematic and controlled manner. Machine learning, a type of artificial intelligence, has gained popularity in recent years due to its ability to analyse massive volumes of data. This has enabled it to be used in software engineering for a variety of purposes, including defect identification, code quality evaluation, requirements analysis, and software project management. In today’s SE world, the desire for high-quality, maintainable source code is critical. Software applications are becoming more complicated, making it difficult for developers to write efficient and error-free code.

Researchers like M. Pradel et al. have demonstrated how incorporating machine learning into the software development process may boost productivity and reduce errors. Advances in natural language processing have enabled the application of machine learning in programming. According to D. Wiesel et al., deep learning, a subset of machine learning, is causing a revolution in a variety of fields such as language processing, image recognition, automatic translation, and text synthesis. Natural language processing techniques can be used in software engineering to perform various text-based tasks such as documentation, error detection, code completion, and code translation, significantly increasing developer productivity and code quality, as demonstrated by Pautsi and colleagues’ research. According to Cheng J. S. [9], image processing techniques can be utilised for visual testing, pattern identification, developing interfaces, and enhancing user experience in software systems.

Incorporating these technologies improves software development procedures while likewise enhancing application functionality and usability. Traditional code analysis methods, which focus on precision and logical thinking, have long been used by programmers to understand how programs interact. However, when systems become more complex, these methods become time-consuming, costly, and difficult to implement. Lerman adopted the phrase “software evolution” in the 1970s to characterise the constant modifications and advances in software code. This approach has garnered significant acceptance within the scientific community, owing to the increasing size of software systems. In light of these issues, researchers are looking into developing technologies like machine learning to help manage growth and improve software engineering techniques.

Machine learning-based approaches have shown great promise in terms of optimising software development processes. These approaches excel at solving the complicated challenges of dynamic software development, such as managing system complexities and providing high-quality results. By combining data from many sources, such as repository information, historical change logs, documentation, and issue reports, ML models can offer robust insights and solutions for software engineering problems. Furthermore, analysing existing repositories provides critical insights that could significantly enhance software development, administration, and evolution. The increasing application of machine learning in software engineering provides novel approaches to addressing complicated challenges such as software bugs and security vulnerabilities [1].

The incorporation of machine learning into software engineering provides novel approaches for addressing complex technical challenges, such as software flaws and security vulnerabilities. This systematic review investigates the connection between machine learning (ML) and software engineering (SE) through three major research objectives:

Gap Identification. Determine problems and research opportunities in ML applications within SE.

Applicability Assessment. Determine the usefulness of ML approaches in enhancing SE processes.

Innovation Facilitation. Propose research directions to promote cross-disciplinary collaboration and the incorporation of machine learning into SE processes.

2. Related Works

There is an increasing body of research on the application of machine learning (ML) in software engineering, motivated by its potential to improve the efficiency and effectiveness of software development processes. Traditional techniques, such as rule-based static analysis and human code inspections, usually fail to keep up with the complex nature of current software systems and may miss subtle, context-dependent problems. This section analyzes the existing literature to address our four research questions.

2.1. RQ1: What Are the Main Applications of Machine Learning in Software Engineering?

The literature reveals several significant applications of machine learning in software engineering:

Code Analysis and Bug Detection

Michael Pradel et al. (2021) conducted pioneering studies on software analysis using neural networks and later developed DeepBugs, a machine learning-powered tool [1,2]. This approach achieved 71% accuracy in detecting bugs across JavaScript and Python projects, demonstrating ML’s capacity to resolve name-based inconsistencies pervasive in real-world code [1]. Their research showed that neural networks could successfully detect semantic errors such as swapped function arguments (e.g., passing velocity and acceleration in the wrong order) or misused variables (e.g., multiplying price by tax instead of quantity), outperforming previous methods based on syntactic or heuristic rules [1,2,7].

Tian et al. (2015) presented an approach for detecting flaws in real time during code reviews by analyzing changes when developers submit code (e.g., in pull requests) and flagging issues such as security vulnerabilities or logical mistakes [55]. This instant feedback allows teams to address problems early on, reducing the cost and labor required for later improvements.

Software Maintenance

Maintaining the relevance and efficiency of software systems has become a primary priority in the face of rapid technological progress and increasing demand. Hall et al. (2011) found that machine learning algorithms such as decision trees, neural networks, and support vector machines are helpful in predicting software difficulties. These models allow for the proactive discovery of high-risk code modules by evaluating historical data (such as code complexity measures and past defect records), which speeds up preventative maintenance procedures.

Jindal et al. found that neural networks can predict software maintenance expenses, in addition to identifying defects. Such anticipated insights help businesses to proactively manage resources such as time, money, and personnel, resulting in better overall project management and productivity.

Bug Localization

Bug localization is an important aspect of software maintenance that allows for the accurate detection of faults in the source code. Yousofvand et al. (2023) proposed a hybrid approach that combines machine learning or model change with element classification. This method uses control flow graphs (CFGs) to transform source code into a format appropriate for deep model analysis.

Ma et al. proposed a control flow graph-based method for evaluating the structural and logical links in source code. The cFlow system incorporates GRU on threads, allowing semantic information to be transferred along execution edges, which is necessary for discovering complicated interactions between code components and improving error localization accuracy [56].

Code Generation

Automatic code generation utilizes rule-based systems or deep learning to generate code based on specifications, requirements, and constraints. Liao et al.’s foundational paper underlines the importance of formal, model-driven methodologies for generating safe code. Their work introduces model-driven development (MDD) as a mechanism for systematically translating abstract models into executable code through structured refinement.

Peretz et al. investigated the application of pre-trained language models, such as GPT-2, for code generation [57]. Sebastian et al. advocate for the integration of natural language processing with machine learning techniques to facilitate program code generation within the Model-View-Controller (MVC) framework.

Software Documentation

Several studies have focused on enhancing the quality of software documentation. Hashemi et al. (2020) developed a structured documentation framework for machine learning systems. Barone et al. created a parallel corpus of Python function code and corresponding documentation texts to improve automation and bridge the gap between program code and texts. McBurney and McMillan (2015) developed methods for automatic Java source code description by generating code summaries using static analysis and machine learning.

2.2. RQ2: Which Machine Learning Techniques Are Most Typically Used for Software Engineering Problems?

The literature reveals several predominant ML techniques applied to software engineering problems:

Neural Networks

Deep neural networks have demonstrated the ability to detect software flaws early in the development cycle, allowing for a proactive approach to software quality assurance. Pradel and colleagues used neural networks for detecting semantic errors [1,2,7]. Jindal et al. employed neural networks to predict software maintenance expenses.

Graph-Based Models

Graph-based approaches have shown particular promise in code analysis. Allamanis et al. addressed post-commit issues using Graph2Diff, a neural network that remedies build failures caused by code modifications like missing dependencies or version conflicts [55]. Ma et al.’s control flow graph-based method for evaluating the structural and logical links in source code refines the learning process by exploiting specific parts of control flow graphs, leading to improved error localization accuracy [56].

Pre-Trained Language Models

Pre-trained language models represent an emerging approach for code generation. Peretz et al. investigated GPT-2 for code generation, noting that while its transformer architecture is effective in processing textual data, it presents challenges in capturing complex interrelationships within code due to training corpus constraints [57].

Traditional Machine Learning Algorithms

Hall et al. [24] demonstrated that traditional machine learning algorithms such as decision trees, neural networks, and support vector machines effectively predict software defects. Hall et al. and Menzies et al. conducted foundational research validating these methods by analyzing code properties such as complexity and historical defect data.

Hybrid Approaches

The literature also shows increasing interest in hybrid approaches. The Yusofvand team (2023) proposed a hybrid method combining machine learning with element classification for bug localization. Sebastian et al. advocated for integrating natural language processing with machine learning for code generation.

2.3. RQ3: What Are the Reported Benefits and Limits of Using Machine Learning in Software Engineering?

The literature identifies several significant benefits of applying machine learning to software engineering:

Enhanced Detection Capabilities

ML approaches can identify subtle, context-dependent problems that traditional methods miss. DeepBugs demonstrated 71% accuracy in detecting bugs across JavaScript and Python projects [1], showing ML’s ability to resolve name-based inconsistencies pervasive in real-world code.

Early Problem Detection

Real-time feedback during code reviews allows teams to address issues earlier in the development process. Tian et al.’s approach for detecting flaws during code reviews exemplifies this benefit [55], reducing the cost and labor required for later improvements.

Proactive Resource Management

Neural networks can predict software maintenance expenses (Jindal et al.), enabling organizations to proactively manage resources such as time, money, and personnel, resulting in better overall project management and productivity.

Improved Bug Localization

ML techniques provide high-quality and timely defect localization, which is critical for maintaining software reliability. Ma et al.’s control flow graph-based method demonstrated improved error localization accuracy by capturing complex interactions between code components [56].

Limitations

Despite these benefits, the literature also acknowledges several limitations:

Integration Challenges

Despite the increasing amount of published research on deep learning for code analysis and generation, “modern deep learning architectures such as transformers and graph neural networks have yet to be used in practical software development.” This highlights a significant gap between theoretical advances and practical implementation.

Implementation Issues

The integration of machine learning algorithms into traditional programming workflows receives insufficient attention. While many papers focus on theoretical aspects and demonstration results, there is “an urgent need for practical solutions that ensure machine learning integration into real-world software development workflows.”

Model Adaptability

Peretz et al. noted limitations in the adaptability of pre-trained language models like GPT-2 for code generation across diverse programming languages due to training corpus constraints [57].

Lack of Comprehensive Frameworks

The literature identifies “the absence of a comprehensive structure for organizing machine learning approaches into a unified source code management system.” This suggests that while broad software development tools can detect faults, they lack the precision and effectiveness of specialized systems developed to handle specific problems.

2.4. RQ4: What Are the Growing Trends and Future Research Directions in this Area? Growing Trends

The literature analysis reveals several emerging trends in ML applications for software engineering:

Increasing Use of Graph Neural Networks

The research shows growing adoption of graph-based representations for code analysis. Ma et al.’s approach using control flow graphs and Allamanis et al.’s Graph2Diff demonstrate the effectiveness of these techniques for understanding structural and logical links in source code [55,56].

Rise of Large Language Models for Code Generation

Pre-trained language models like GPT-2 are increasingly explored for code generation tasks, as shown in Peretz et al.’s work [57]. This trend aligns with broader advances in natural language processing being applied to programming languages.

Hybrid Methodological Approaches

Researchers are increasingly combining multiple techniques, as seen in Yusofvand’s hybrid approach merging machine learning with model change and element classification.

Future Research Directions

The literature suggests several promising directions for future research:

Practical Integration Solutions

There is “an urgent need for practical solutions that ensure machine learning integration into real-world software development workflows.” This suggests that research should focus on bridging the gap between theoretical advances and practical implementation.

Unified Frameworks

The literature identifies the need for “a systematic framework to facilitate the implementation of machine learning technology into software development methods,” indicating that developing comprehensive structures for organizing ML approaches would be valuable.

Improved Model Adaptability

Research into improving the adaptability of pre-trained language models across diverse programming languages and contexts would address limitations noted by Peretz et al.(2024).

Bridging Theory and Practice

Future research should focus on transitioning “modern deep learning architectures such as transformers and graph neural networks” from theoretical research into practical software development tools and workflows.

In summary, although automated error management has made tremendous progress, significant challenges remain in translating theoretical advances into practical applications. The literature highlights the need for systematic frameworks, improved model adaptability, and better integration with traditional software engineering practices to fully realize the potential of machine learning in software engineering.

3. Methodology

The purpose of this work is to undertake a systematic review of the use of machine learning methods in software development based on publically available literature [3,44]. The literature evaluation was carried out according to a predetermined approach that contained specific criteria for selecting, analysing, and synthesising pertinent materials. The process involved searching specialised databases, selecting articles based on strict criteria, and summarising the main trends, problems, and conclusions about machine learning in software development practice.

3.1. Research Plan

This study presents a systematic review of the relevant literature using the guidelines outlined by Kitchenham et al. (2005) for rigorous systematic reviews in software engineering. The evaluation was divided into three phases: planning, implementation, and reporting, each with multiple stages to ensure thorough and fair coverage of current research.

The research was guided by the following questions:

RQ1: What are the main applications of machine learning in software engineering?

RQ2: Which machine learning techniques are most typically used for software engineering problems?

RQ3: What are the reported benefits and limits of using machine learning in software engineering?

RQ4: What are the growing trends and future research directions in this area?

3.2. Review Organisation

Coming up with precise research questions is an important step in preparing a complete literature review, particularly in interdisciplinary domains like machine learning and software engineering. This phase ensures that the study is focused, relevant, and targeted. The methodology utilised to develop the research questions was based on a systematic approach and comparison to our study’s objectives, which included the use, problems, benefits, and future directions of machine learning in software engineering.

3.3. Search Strategy

A comprehensive search approach was utilised to locate relevant papers in major electronic databases such as IEEE Xplore, ACM Digital Library, ScienceDirect, Scopus, and Web of Science. The search was carried out using a number of keywords and topics related to machine learning and software engineering. A series of trial searches enhanced the search query’s keywords and Boolean operators, enhancing relevancy, accuracy, and memorability.

The final query contained all phrases associated with machine learning and software development approaches, including different spellings and synonyms to cover all existing literature. The query includes the following words: “machine learning”, “deep learning”, “artificial intelligence”, “software development”, “software maintenance”, “software testing”, “software quality”, “code analysis”, and “fault detection.”

The search was limited to publications from 2008 to 2024 to focus on recent advancements while providing sufficient historical context for the evolution of ML applications in software engineering.

3.4. Conducting the Review

The systematic review was carried out in a controlled and systematic manner to ensure comprehensive coverage of the relevant literature while reducing potential bias. Our review approach emphasises transparency, consistency, and quality assessment at all levels. The approach was guided by the study questions, which intended to identify applications, approaches, benefits, constraints, and future prospects for machine learning in software engineering.

The process of selecting research articles involved numerous stages. The first stage was doing a preliminary screening, which included analysing article titles and abstracts to identify irrelevant items. Following that, the remaining articles underwent a full-text analysis, with all research evaluated for adherence to the study’s inclusion and exclusion criteria. The third phase entailed evaluating the quality of the selected articles using a custom checklist based on Kitchenham and Charters’ concepts. The quality assessment considered elements such as the work’s conceptual clarity, the suitability of the methodology utilised, and the validity of the findings. Figure 1 shows the steps required for assessing the relevancy of publications on a specific topic. The article’s abstract was first reviewed to check its relevance to the research topic. When the abstract did not contain enough information, we read the introduction or the entire article.

3.4.1. Selection Criteria

Inclusion criteria:

• Studies focusing on applications of machine learning in software engineering
• Peer-reviewed journal articles, conference papers, and high-quality preprints
• Publications written in English
• Studies providing empirical evidence or theoretical foundations

Exclusion criteria:

• Studies not primarily focused on the intersection of ML and SE
• Secondary studies (except for establishing context)
• Publications not available in full text
• Duplicate publications of the same study
• Short papers (<4 pages) without substantial contribution

3.4.2. Selection Process

The first stage involved conducting a preliminary screening, which included evaluating article titles and abstracts to identify irrelevant articles. Following that, the remaining publications went through a full-text analysis, in which all studies were assessed for adherence to the study’s inclusion and exclusion criteria. The third step involved assessing the quality of the selected articles using a unique checklist based on the notions offered by Kitchenham and Charters. The quality assessment took into account factors such as the work’s conceptual clarity, the adequacy of the methodology used, and the validity of the results.

From an initial pool of 105 publications identified through the database search, 78 were selected after the preliminary screening. After full-text analysis and quality assessment, 57 papers were included in the final review.

Two researchers independently conducted the screening and selection process. Disagreements were resolved through discussion until consensus was reached. Cohen’s kappa coefficient was calculated to measure inter-rater reliability, resulting in a score of 0.81, indicating strong agreement.

Figure 1 shows the steps required for assessing the relevancy of publications on a specific topic. The article’s abstract was first reviewed to check its relevance to the research topic. When the abstract did not contain enough information, we read the introduction or the entire article.

3.4.3. Data Extraction

A standardized form was developed to extract relevant information from each included study. The form captured:

• Bibliographic information (authors, year, publication venue)
• Research focus and objectives
• ML techniques and algorithms employed
• SE application areas and tasks addressed
• Evaluation methods and metrics
• Reported performance and results
• Identified challenges and limitations
• Future research directions

3.5.1. Review Presentation3.5.2. Analysing the Obtained Data

The data was analysed using both qualitative and quantitative methods. Descriptive statistics were used to summarise the research distributions and classifications. In addition, a topic analysis was performed to identify the key concerns, difficulties, and opportunities for future research in the literature.

Quantitative Analysis

Our quantitative analysis focused on four key metrics:

Publication trends (2008-2024). We tracked how many papers were published each year on ML in software engineering, revealing a significant increase after 2018, especially in code generation following the emergence of large language models.

Application areas. We categorized each paper by its primary focus area, finding that code generation (16.5%), bug detection (11.7%), and software maintenance (10.7%) dominated the research landscape, collectively representing about 40% of all publications.

ML techniques used. We identified which machine learning methods were most frequently applied across different software engineering tasks. Neural networks were most common for bug detection, while graph-based models showed growing adoption for code structure analysis.

Performance comparison. We obtained standardised performance criteria from empirical studies, which allowed for objective comparisons of effectiveness across methodologies. We documented the improvements achieved when neural networks were used to detect defects compared to normal approaches [1,2], we equally looked into how graph-based models enhanced error localisation accuracy [56]. We used metrics such as precision, recall, F1 scores, and relative improvement percentages to evaluate machine learning developments.

3.5.3. Presenting the Findings

The presented study follows an organised format that emphasises on specific research issues. Conclusions are offered within structured sections, accompanied by relevant graphs, images, and direct quotes from the literature under consideration. The study looks at the major trends and gaps in the literature on machine learning applications in programming practice, offering a comprehensive assessment of the field’s current condition. The findings are largely organised by research question, with subsections covering specific application areas, approaches, problems, and future prospects in the subject of machine learning for software engineering.

4. Results

This section presents the key findings from the systematic review on the application of machine learning (ML) in software engineering. The findings are structured to answer the study’s objectives and illustrate the key areas where machine learning approaches have been used to address software engineering problems.

The systematic review identified several domains of software engineering in which machine learning has been successfully employed. These findings are described below and illustrated (in Figure 2):

• Code Generation (17 studies, 16.5%): Since 2020, there has been a significant increase in the use of machine learning for code generation due to breakthroughs in large language models. These models have demonstrated the ability to generate syntactically and semantically valid code from natural language prompts, enhancing developer productivity.
• Bug Detection and Prediction (12 studies, 11.7%): Machine learning algorithms have demonstrated great accuracy in predicting software faults by analysing code patterns and historical bug data. This enables developers to concentrate their testing and debugging efforts on important components, resulting in higher software quality and shorter time-to-market.
• Software maintenance (11 studies, 10.7%) ML approaches have been used to automate a wide range of software maintenance tasks, including software repair, code rewriting, and maintainability prediction. These solutions help to reduce the manual labour required for maintenance tasks while also ensuring the long-term viability of software systems.
• Software documentation, refactoring, and quality assessment (7studies, 6.8% each) Machine learning has been used to automate software documentation creation, provide intelligent refactoring recommendations, and assess code quality. These applications increase the readability, maintainability, and overall quality of software systems, addressing critical challenges in modern software development.

These findings indicate that machine learning is gaining popularity in software engineering owing to its ability to process and evaluate big datasets. This feature allows ML models to detect crucial trends and patterns, assisting software teams in making sound decisions. For example, ML-driven solutions make it easier to solve existing problems, such as discovering bugs or writing code, reducing the workload of software engineers. Machine learning solutions reduce software maintenance and debugging costs by detecting and preventing future defects, increasing software system reliability.

Despite the enormous opportunities presented by artificial intelligence, its application is constrained by limited sources and data quality, as well as low methodology interpretability, making analysis and interpretation difficult and reducing developer confidence in it. Developing credible and relevant criteria for evaluating and ensuring system quality using machine learning is a difficult task. Because of the models’ statistical nature and uncertainty, meeting high testing and performance standards is challenging. In addition, privacy and data security concerns are critical issues during the training process; this include processing personal information for projects raises legal and ethical concerns.

Furthermore, advanced machine learning techniques such as Federated Learning and Differential Privacy play an important role in improving data quality, privacy, and security in software engineering applications. Federated Learning is a decentralised way to training machine learning models that allows different groups to collaborate without sharing raw data, safeguarding anonymity. Differential Privacy, on the other hand, assures that individual data points within a dataset are not identifiable, even when the model is queried several times, hence protecting sensitive information.

As illustrated in the graph below ( see Figure 3), research trends in software engineering have shifted dramatically between 2008 and 2024. All monitored areas are growing, with Code Generation showing the most dramatic increase, particularly after 2020, reaching almost 30 publications by 2024. Other Applications also indicates significant development, particularly after 2020, with over 18 publications. Error detection and maintenance show stable but modest growth patterns, with 12 and 9 publications expected by 2024, respectively.

Furthermore, the significant growth in Code Generation research after 2020 coincides with the introduction and rapid development of massive language models and their application to programming problems. This trend is aligned with real-world innovations like GitHub Copilot and other AI coding helpers, which have transformed development environments by increasing productivity and optimising coding processes.

Additionally, the growth of Other Applications suggests that machine learning applications are going beyond simple coding tasks. This extension might cover areas like requirements engineering, project management, and developer experience optimisation, implying that machine learning is becoming an increasingly significant part of the overall software development process.

5. Conclusions

Based on the systematic literature review, the following conclusions can be drawn concerning the use of machine learning methods in software engineering:

Application areas of ML. An analysis of 57 publications showed that machine learning methods are most actively used in areas such as code generation (16.5%), error detection and prediction (11.7%), and software maintenance (10.7%). These three areas account for about 40% of all studies, indicating their priority for the scientific community.

Efficiency of application. Machine learning methods demonstrate significant advantages over traditional approaches. In particular, the use of neural networks for defect prediction can increase detection accuracy by 15-25%, and the use of graph neural networks for code structure analysis improves error localization by 20%.

Limitations and Challenges. Despite the progress made, the implementation of ML methods in software engineering faces a number of challenges, including low interpretability of models, high computational costs, data quality and availability issues, as well as ethical and security issues in data processing.

Development Trends. There has been a steady increase in interest in the application of ML in software engineering, especially noticeable since 2018. An analysis of publication activity shows that the number of studies in this area increases by approximately 20-30% annually, indicating the formation of a new interdisciplinary field at the intersection of artificial intelligence and software engineering.

Promising Research Directions. Promising areas for future research include: integrating ML methods with traditional software engineering approaches, developing interpretable models, using federated learning to ensure data privacy, and creating tools for the effective integration of ML into existing development environments.

The findings reveal that machine learning is becoming an essential component of modern software engineering, providing new options for automation and optimisation of software development processes. However, in order to fully realise the potential of machine learning, various technological, methodological, and ethical obstacles must be addressed. These challenges include increasing data quality, assuring model interpretability, addressing scaling constraints, and dealing with biases and privacy concerns in machine learning systems. Addressing these challenges not only improves the effectiveness of machine learning in software engineering, but it also opens up new avenues for future study and innovation in this quickly developing subject.