Artificial Intelligence in Software Development
How LLMs are changing development
Modernizing legacy systems is one of the biggest IT challenges: Outdated technology, lack of documentation and complex dependencies make updates expensive and risky. AI, especially LLMs, helps to efficiently analyse, document and modernize legacy applications.
Why Artificial Intelligence Is Changing Software Development
Artificial intelligence in software development has made enormous progress in recent years. This has been made possible by the exponential increase in computing power—especially through modern GPUs and TPUs—as well as scalable cloud infrastructures.
A key driver of this development is Large Language Models (LLMs) and generative AI. These models are particularly suitable for tasks that require language understanding and generation - and this is precisely where their strength lies in dealing with software code, which can also be regarded as language.
This makes it clear that software development with artificial intelligence is one of the most effective fields of application for modern AI technologies.
Artificial Intelligence in Software Development: Three Key Areas of Application
In the development process, artificial intelligence supports software development in three particularly relevant areas:
- Coding: AI helps with writing, completing and optimizing source text.
- Documentation: Automated creation of use cases, architecture overviews and technical concepts.
- Quality assurance: Generation of test cases and test plans to ensure software quality.
These fields of application show how artificial intelligence makes software development more efficient, faster and more precise.
Github Copilot: Artificial Intelligence for Software Development in Practice
There is now a wide range of tools that provide optimized LLMs for software architects and developers and incorporate them into the development process.
A prominent tool for AI-supported development is GitHub Copilot. It is an extension that is firmly integrated into various development environments (IDEs). The supported IDEs range from Visual Studio Code and Visual Studio to the various JetBrains IDEs, Eclipse IDE and Xcode.
The developer works as usual in their IDE and can use AI support. This takes place in different modes:
Ask
This is a classic chat function, as known from other AI tools. The developer asks questions and receives textual answers. They can, for example, have existing code explained to them or receive help with technical questions. The answers can also contain code, which the developer has to copy manually into the actual application.
Next Edit Suggestions (NES)
NES offers an AI-based auto-complete where the developer is shown code change suggestions directly in the editor. Compared to classic auto-complete, these can already contain complete algorithms. Example: The developer starts a new method with the name "ValidateIBAN" and directly receives implementation suggestions for the complete method for validating the account number with check digit calculation.
Edits
In edits mode, the developer not only receives textual responses to his requests, but also suggestions for changes to the actual code of the application, which he can then accept, reject or adapt iteratively through further requests.
Agent
An extended "edits" mode that automatically reacts to feedback (e.g. test errors) and can iterate automatically. The agent can use so-called tools to execute actions (e.g. start a test run) or retrieve information (e.g. access an internal wiki). These tools can be proprietary extensions or MCP servers. MCP is a protocol developed by the company Anthropic to standardize the linking of LLMs with other applications and data sources. MCP servers are already available for many use cases (e.g. for retrieving data from Confluence).
The interactions with GitHub Copilot result in requests to an LLM. The developer can select different models for this (e.g. GPT-4.1 or Claude Sonnet). The feedback is then processed by GitHub Copilot to display a corresponding response or to edit code.
Context must also be transported with the actual prompt. This can contain the following components, among others:
- The current chat history
- The current file or the text around the cursor
- Individual files, folders or even the entire source code of the application
- Data from extensions or from MCP servers
Artificial Intelligence in Software Development: Practical Example of Legacy CRM
The demo application "Legacy CRM" shows how artificial intelligence supports software development in concrete terms - from analysis to documentation and migration.
AI-Supported Analysis and Documentation in Software Development
With GitHub Copilot's Ask mode, a developer can analyze and document a legacy application. The AI helps to understand technologies, functions and structures and to generate use cases, technical descriptions and diagrams.
Especially when onboarding new developers, artificial intelligence accelerates software development through automated knowledge transfer and documentation.
In order to document an existing system in detail, user stories, use cases, technical descriptions and diagrams, for example, can also be generated in Ask mode.
Artificial Intelligence for Test Design and Quality Assurance in Software Development
Solid test coverage is essential for any modernization. AI supports the design of unit, integration and manual tests.
In edit or agent mode, the developer can implement missing tests with AI support - provided the prompts contain precise information on frameworks and libraries. This makes artificial intelligence software development a game changer in the area of quality assurance.
AI in Software Development: Planning and Implementing Migrations
The strength of AI is also evident in the planning and execution of migrations. GitHub Copilot helps with the selection of target technologies and migration phases.
For specific tasks - such as the transformation of a legacy UI from ASP.NET WebForms to Angular - the AI provides support with specific code suggestions and architecture tips.
Artificial intelligence software development is thus becoming the driving force behind modern IT landscapes.
Challenges in the Use of Artificial Intelligence in Software Development
The use of artificial intelligence in software development offers enormous opportunities - but also brings with it specific challenges. In order for AI-supported modernization projects to be successful, developers must be aware of technical limitations, proceed methodically and build up new skills. Key stumbling blocks such as context limitation, misinterpretation by AI models, the selection of suitable models and precise prompting are discussed in more detail below.
1. the context limit
The size of the context that can be given to an LLM with the prompts is limited. Depending on the model and programming language to around 50K - 100K lines of code. This is quickly exceeded by moderately complex applications.
As the LLM is therefore only aware of a section of the application during the analysis, developers are required to enable a well-founded evaluation by carefully selecting suitable context information. In addition, the developer must perform the corresponding task successively on suitable sections of the application.
Arvato Systems has developed a create your own approach as an iterative process.
2. AIs also make mistakes
In addition, it is important to note that AI tools make misjudgements that must be recognized and corrected in the further process.
One source of these errors is the so-called hallucination of AI models, in which incorrect or invented information can be provided, but which often appears plausible or correct. This can lead, for example, to gaps being creatively filled and non-existent features being described in the subsequent documentation of a system.
Hallucination can be limited to a certain extent by appropriate prompts, but critical human review is also required - for example by the technical experts of an application.
The topic of review also plays a role for code changes in particular, as this also occasionally generates code that is syntactically correct but functionally incorrect.
On the one hand, it is necessary to keep the scope of code changes to a manageable level so that reviews remain manageable. On the other hand, it is essential for developers to understand code reviews as an independent discipline and to professionalize them in order to systematically uncover errors - especially since these are often more subtle and difficult to detect than human errors.
The scope of changes also plays a role for the agent mode, which - for example by executing tests - can partially correct errors itself. If the changes are too large, the agent is often unable to correct all errors, or new errors are constantly generated. This can lead to an endless iteration loop. The agent mode has an integrated protection mechanism for this, which queries at certain time intervals whether the agent should continue to search for a solution.
3. The right model selection
In order to use LLMs effectively for development tasks, it is also important to select the right model for the right task.
Reasoning models such as Claude lead to much higher quality results - but are also significantly slower, while models such as GPT 4.1 deliver results relatively quickly.
If a developer uses GPT 4.1 for a task that is too complex, the results may not be satisfactory. If, on the other hand, a reasoning model is used for a task that is too simple, the developer may have to wait an unnecessarily long time for a result.
In addition, the choice of model plays a role in terms of costs, as different billing factors apply to the individual models.
4. precise prompting
As already mentioned, precise prompting with clear information on the implementation details, such as the frameworks, components to be used and the desired architecture, is essential.
Many of these details can be stored project-wide in so-called instruction files, which are automatically sent to the model with every prompt.
In addition, extending the context data by configuring appropriate extensions and MCP servers is crucial. For example, to look up architecture details in an internal Confluence or to retrieve details about the libraries used by Context7.
Creating exact prompts, compiling suitable instruction files and selecting appropriate MCP servers are also specific areas of expertise that a developer must master.
Conclusion: Artificial Intelligence as a Driver of Modern Software Development
Modernizing legacy systems remains challenging - but with artificial intelligence in software development it is much more efficient.
KI supports the writing of code, the generation of technical documentation and quality assurance. Mastering model selection, prompting and reviews takes software development to a new level.
At the same time, AI is not a sure-fire success, and a co-pilot is not an autopilot. Selecting the right model, precise prompting, an iterative approach and critical reviews are crucial for success. Those who build up these skills in a targeted manner can not only modernize legacy code, but also raise software development as a whole to a new level.
Would you like to know how Arvato Systems uses AI in application modernization or do you need support in modernizing your legacy systems? Contact us for an individual consultation.
Written by
Hanno Kortekamp is a software architect at Arvato Systems and is responsible for the technical design and implementation of modern web applications. In addition to architecture, his focus is on coordinating and coaching development teams. With over 25 years of experience, he brings extensive know-how in the modernization of existing systems as well as in the development of new applications. His projects span a wide range of industries, including finance, customer service and healthcare.