1. ABSTRACT
This paper examines how Generative AI (GenAI) can enhance software maintenance, the most expensive phase of software development. With developers spending significant time understanding existing code, GenAI tools show promise in automating code comprehension, bug detection, and maintenance suggestions. While these tools can optimize traditionally time-intensive processes, human oversight remains crucial for validating AI-suggested solutions. The research proposes integrating fine-tuned Large Language Models (LLMs) throughout the software development lifecycle (SDLC), enabling context-aware assistance from project inception through maintenance, with emphasis on improved long-term project support and knowledge retention. This analysis illuminates both the current capabilities and limitations of GenAI in software maintenance, pointing toward more efficient AI-assisted practices.
2. INTRODUCTION
Software maintenance is a crucial phase in the software development life cycle, involving activities to keep the system functional, secure, and up to date. It includes corrective maintenance for fixing bugs and errors, as well as responding to changing requirements; adaptive maintenance to ensure compatibility with new environments; perfective maintenance for enhancing performance and features; and preventive maintenance to identify and address potential issues before they impact the system, improving long-term stability and reliability. Software spends the majority of its time in the maintenance phase, making it the most expensive phase of the software development life cycle [1].
In practice, software maintainability is often neglected, resulting in poor documentation and complex code that is difficult to understand. Software engineers invest significant time in understanding the existing code, migrating it across environments, and performing refactoring and bug fixes. The integration of Generative AI in software maintenance presents exciting opportunities to optimize these processes, significantly improving efficiency while reducing both effort and costs.
3. LITERATURE REVIEW
In recent years, there have been efforts to improve software maintenance and evolution. The paper “Chatbots As Fluent Polyglots: Revisiting Breakthrough Code Snippets” [2] AI-driven code assistants’ advanced capabilities in analyzing multi-language codebases. These systems effectively parse complex code structures, excel at refactoring legacy code, and provide valuable insights for optimizing high-value repositories while maintaining core business logic. Similarly, the paper “An Empirical Evaluation of GitHub Copilot’s Code Suggestions” [3] explores the use of ChatGPT’s natural language understanding and generation capabilities to enhance software maintainability. The study proposes that integrating ChatGPT into the software maintenance workflow can lead to more efficient and effective maintenance practices.
4. TECHNICAL ANALYSIS
According to the article “Measuring Program Comprehension: A Large-Scale Field Study with Professionals” [4], software developers spend approximately 58% of their time understanding existing code. This highlights the significant cognitive effort required to analyze, interpret, and modify software systems, particularly in large and complex codebases.
GenAI can play a crucial role in accelerating code comprehension by providing natural language explanations, automated documentation, and suggestions for code improvements. AI-powered tools like GitHub Copilot, Amazon CodeWhisperer, and OpenAI Codex can assist developers by summarizing code functionality, refactoring outdated code, and suggesting optimizations.
In addition to aiding comprehension, GenAI can help in identifying potential bugs using techniques such as:
- Static Code Analysis – Detecting syntax errors, code smells, and security vulnerabilities before execution.
- Runtime Anomaly Detection – Monitoring application logs to spot unexpected behavior, crashes, or performance degradation.
- AI-Based Code Reviews – Automating the review process to catch inconsistent patterns, missing error handling, and deviations from coding best practices.
However, despite these advancements, true bug identification requires business context and human involvement. Not all flagged anomalies are genuine defects—some may be intentional design choices or features that align with business requirements. Developers and domain experts must validate and assess whether an issue is truly a bug or an expected behavior. Let’s take a simple example to understand this:
The following code snippet appears correct at first glance, with no apparent anomalies:
| def apply_discount(price, discount):
return price – discount # discount applied as an absolute value |
If the price is $50 and the discount is 20, the function subtracts $20. However, considering the business context where the discount should be a percentage, this becomes a critical bug. The corrected code should be:
| def apply_discount(price, discount):
return price – (price * discount / 100) # applies percentage discount |
While AI can flag such anomalies, human validation remains essential to confirm intent and ensure business rules are correctly implemented. By combining GenAI-driven automation with human expertise, software teams can significantly improve maintenance efficiency, reduce debugging time, and enhance overall software quality.
Source: OpenAI’s DALL·E, ChatGPT.
5. FUTURE TRENDS
GenAI tools have emerged as valuable accelerators in code maintenance processes, offering capabilities like automated bug detection, code optimization, and documentation generation. However, their effectiveness is limited when introduced only at the maintenance stage due to missing project context. Integrating GenAI from a project’s inception offers a more effective approach, where fine-tuned LLMs evolve in parallel with the development lifecycle. These models build comprehensive knowledge through each phase: capturing business rules and constraints during requirements analysis, documenting architectural decisions in design, learning codebase patterns during development, and understanding bug patterns through testing. This continuous learning process creates an AI system with deep contextual understanding, enabling more intelligent maintenance solutions. The accumulated project knowledge leads to more precise and informed decision-making during the maintenance phase.
While this comprehensive involvement would enable AI systems to develop a deeper understanding of both technical and business aspects, we are still in the early stages of this vision. Current technological limitations and the complexity of business logic mean that human oversight remains essential. Future research should focus on developing frameworks that optimize LLM integration throughout the software development lifecycle, balancing automated assistance with human oversight. This approach could transform maintenance from a reactive troubleshooting process to a proactive, intelligence-driven practice that anticipates and prevents potential issues based on a comprehensive project context.
6. CONCLUSION
The integration of Generative AI in software maintenance marks a significant advancement in addressing the challenges of this costly phase of software development. GenAI tools demonstrate considerable potential in reducing time spent on code comprehension, bug detection, and maintenance tasks. While these AI-powered solutions show promise in automation, they are most effective when combined with human expertise and business context understanding.
Current limitations of GenAI tools in understanding business-specific requirements highlight the continued importance of human oversight. However, the future integration of project-specific LLM models throughout the software development lifecycle offers a path toward more contextually aware maintenance solutions.
The key to successful implementation lies in balancing automation with human intervention, ensuring AI enhances rather than replaces human judgment. This evolution points toward a future where maintenance becomes more proactive and efficient while maintaining essential human oversight in critical decisions.
7. REFERENCES
1) https://www.baytechconsulting.com/blog/projecting-costs-in-software-maintenance
2) David Noever, Kevin Williams, “Chatbots As Fluent Polyglots: Revisiting Breakthrough Code Snippets” arXiv:[ rXiv:2301.03373] [Jan 2023]
3) Chakraborty, Moumita, et al. “Code Maintenance Using OpenAI’s Codex.” 2022 International Conference on Trends in Electronics and Informatics (ICOEI), 2022, pp. 1242-1246, doi:10.1109/ICOEI53556.2022.9796235.
4) Zhao, Yangyang, et al. “The Impact of Continuous Integration on Other Software Development Practices: A Large-Scale Empirical Study.” 2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE), 2017, pp. 60-71, doi:10.1109/ASE.2017.8115619.
8. AUTHOR’s BIO
Sandeep Kumar Gond is a seasoned software engineer with over 20 years of experience in designing and developing distributed systems. He has led multiple high-impact projects, driving scalable architectures, technical leadership, and mentoring senior engineers. He is currently exploring the application of Generative AI in the software development lifecycle.
