Advancements in Artificial Intelligence (AI) and Machine Learning (ML) have recently sparked widespread discussions and captured headlines. Individuals and enterprises alike are eager to leverage these technologies. Software development companies and engineers are particularly intrigued by the rapid development and diversity of these technologies. For years, engineers have sought methods to create code from ideas.

There are considerable investments in developer focused tools to speed up code-crafting. Snippet libraries, which house pre-written templates that can be copied and pasted, frameworks and scaffolding generators that assist in code creation, are two examples. Numerous other innovative strategies are emerging, all aimed at expediting the transformation of ideas into code. However, groundbreaking Large Language Model (LLM) products such as GitHub's Copilot, OpenAi Codex, CodeT5, Tabnine, PolyCoder, and the ever-expanding list of alternatives are overshadowing conventional approaches.

So, what implications does this hold for the future of writing code? Furthermore, what does it all mean for software product companies' perennial challenges? Will it decrease time-to-market (TTM), reduce development costs, increase quality or is there a downside in the long term that may outweigh the short-term gains?

"They say AI will replace software developers, but I'm not worried. After all, who else will teach AI to fix its own bugs and debug its existential crisis?"

Upside - Accelerated development

Computer source code created by large language models (LLMs) accelerates software development. Today, LLM-generates code snippets, templates, and even entire functions. These tools provide developers with a starting point that saves time and effort in the short term. Through the automation of repetitive tasks, LLM-generated code allows developers to focus on higher-level aspects of software development, such as architectural design, user experience, and business logic. Increased efficiency can lead to faster project delivery, reduced time-to-market, and enhanced productivity for development teams.

LLM-created code serves as a valuable learning tool for developers. LLMs trained in vast amounts of code and programming knowledge provide insights into different coding styles, best practices, and design patterns. Developers can study and analyze LLM-generated code to enhance their coding skills, improve code readability, and adopt industry-standard approaches. Furthermore, LLMs can collaborate, suggest alternative code implementations, and enable developers to explore different solutions. They can also learn from the generated code's strengths and weaknesses.

Another aspect of LLM-generated code's value is its potential for innovation and creativity. LLMs will produce code that incorporates novel approaches and unconventional solutions. LLMs have access to vast knowledge and patterns extracted from many diverse codebases. Code structures and functions not previously considered by human developers now exist in LLM-generated code. This innovative code generation spurs creative ideas and inspires developers to think outside the box. It can also lead to the discovery of more efficient algorithms or novel solutions to complex problems. LLM-generated code serves as a prompt to catalyze creative thinking and foster innovation in software development.

Downside - Accelerated tech debt

Technical debt resulting from LLM-generated code encompasses several factors.

  1. LLM generated code often lacks adequate documentation and comments, making it difficult for other developers to comprehend and maintain the codebase. This lack of clarity can lead to prolonged debugging and troubleshooting efforts.
  2. LLMs will prioritize speed in generating code that produces the desired output rather than adhering to best practices or optimizing for performance. Consequently, inefficient, or bloated code generation necessitates future refactoring and optimization efforts.
  3. LLMs may not fully grasp the underlying architecture or design patterns of the codebase, resulting in suboptimal or inconsistent code structures that heighten complexity.

    LLM-generated code lacks customization and adaptability. While LLMs are trained on vast amounts of data, the genericized solution fails to fully capture the specific nuances and requirements of individual projects. Consequently, the generated code, while functional, will not perfectly align with the project's needs, necessitating manual modifications and workarounds. This customization effort adds to technical debt by introducing code complexity and potential issues requiring future maintenance.

    Another aspect of technical debt arising from LLM-generated code is the absence of comprehensive test coverage. While LLMs are trained to produce code that produces the expected output, they do not understand the larger context to create exhaustive test cases or ensure code quality. Consequently, the generated code may lack appropriate unit tests, integration tests, or other forms of automated testing. This elevates the risk of introducing bugs and makes refactoring or extending the codebase challenging without a comprehensive testing infrastructure.

    Using LLMs for code generation also introduces security vulnerabilities and compliance risks. LLMs may unintentionally generate code containing security flaws, such as injection vulnerabilities or weak authentication mechanisms. Furthermore, the generated code may need to adhere to industry-specific regulations or privacy standards, amplifying the likelihood of non-compliance. Addressing these security and compliance issues contributes to technical debt, necessitating additional time and effort to identify and mitigate potential risks.

    Maintaining LLM-generated code over time can prove challenging due to the rapid evolution of the underlying LLM models. With each release of updated versions, changes in code generation techniques may arise, resulting in inconsistencies or deprecated code patterns. Consequently, periodic updates and refactoring become imperative to align the codebase with the latest capabilities of LLMs, further increasing the technical debt associated with the project.

    Lastly, relying on LLM-generated code can pose challenges for knowledge transfer and skill development within development teams. As developers become accustomed to using LLMs for code generation, they may rely less on their coding skills and understanding of fundamental principles. This dependency can limit knowledge growth and hinder team software engineering capabilities. Over time, this knowledge gap can contribute to technical debt accumulation as developers struggle to address issues beyond LLM-generated code.

     In conclusion, Large Language Models (LLMs) for code generation introduce unique challenges that contribute to technical debt. LLM-generated code often lacks documentation, customization options, comprehensive testing, and security and compliance standards adherence. Additionally, the rapid evolution of LLM models and the reliance on generated code will hinder knowledge transfer and skill development within development teams. It sacrifices long-term maintainability for ease of development, resulting in limited extensibility, a reduced emphasis on software architecture, performance optimization challenges, and testing limitations. These factors underscore the importance of carefully managing technical debt to ensure software sustainability and quality.

     What does this mean for CTO’s?

    Developer excitement and priority business outcomes will drive conversations to adopt and incorporate LLM-generated code into your products. You may even experience staff stealthily using LLM generated code. Proper oversight and guide rails are a must. Without these in place, your applications will become a hodgepodge of architectural and coding strategies that implicitly add technical dept, silently. LLM created code is a powerful ally when used correctly. Embrace what it produces while carefully integrating it into your products. Ensure it conforms to your architecture, meets unit and integration test requirements, has the proper code “smell”, is sufficiently documented, and passes strict code reviews – it must be your code.

    1. Embrace LLM generated code as a tool.
    2. Implement proper engineering guiderails and processes and monitor compliance.
    3. Ensure adoption and use do not degrade the architecture and codebase.
    4. Assign ownership of LLM usage into a stewardship group which contains representatives from all development disciplines – architecture, development, data, QA, DevOps, and product.
    5. Do not use the “speed” of LLM generated code to meet commitments by circumventing established processes.
    6. Check out our CEO's Guide to Artificial Intelligence (AI) and Machine Learning (ML).

    AKF helps software product companies with strategies and processes to identify and manage Technical Debt.  Call us and we can help!