Künstliche Intelligenz in der Softwareentwicklung

Die Modernisierung von Legacy-Systemen zählt zu den größten IT-Herausforderungen: Veraltete Technik, fehlende Doku und komplexe Abhängigkeiten machen Updates teuer und riskant. KI, speziell LLMs, hilft, Altanwendungen effizient zu analysieren, dokumentieren und modernisieren.

Im Entwicklungsprozess unterstützt künstliche Intelligenz Softwareentwicklung in drei besonders relevanten Bereichen:

• Coding: KI hilft beim Schreiben, Vervollständigen und Optimieren von Quelltext.
• Dokumentation: Automatisierte Erstellung von Use-Cases, Architekturübersichten und technischen Konzepten.
• Qualitätssicherung: Generierung von Testfällen und Testplänen zur Absicherung der Softwarequalität.

Diese Einsatzfelder zeigen, wie künstliche Intelligenz die Softwareentwicklung effizienter, schneller und präziser macht.

Es gibt mittlerweile ein großes Angebot an Werkzeugen, die LLMs für Softwarearchitekten und Entwickler optimiert bereitstellen und in den Entwicklungsprozess einfließen lassen.

Ein prominentes Werkzeug für KI-gestützte Entwicklung ist GitHub Copilot. Es handelt sich dabei um eine fest in diverse Entwicklungsumgebungen (IDEs) integrierte Erweiterung. Die unterstützten IDEs reichen dabei von Visual Studio Code und Visual Studio über die verschiedenen JetBrains-IDEs bis hin zu Eclipse-IDE und Xcode.

Der Entwickler arbeitet wie gewohnt in seiner IDE und kann dabei KI-Unterstützung nutzen. Diese erfolgt in unterschiedlichen Modi:

• Ask

  Hierbei handelt es sich um eine klassische Chatfunktion, wie man sie von anderen KI-Tools kennt. Der Entwickler stellt Fragen und erhält textuelle Antworten. Hierüber kann er sich z.B. existierenden Code erklären lassen oder Hilfe bei technischen Fragen erhalten. Die Antworten können dabei auch Code enthalten, den er aber manuell in die eigentliche Anwendung übernehmen muss.

• Next Edit Suggestions (NES)

  NES bietet ein AI-basiertes Auto-Complete bei dem der Entwickler Code-Änderungsvorschläge direkt im Editor angezeigt bekommt. Diese können gegenüber klassischem Auto-Complete schon komplette Algorithmen enthalten. Beispiel: Der Entwickler beginnt eine neue Methode mit dem Namen „ValidateIBAN“, und erhält direkt Implementierungsvorschläge der kompletten Methode zur Validierung der Kontonummer mit Prüfziffernberechnung.

• Edits 

  Im Edits Modus bekommt der Entwickler auf seine Anfragen nicht nur textuelle Antworten, sondern auch Änderungsvorschläge für den tatsächlichen Code der Anwendung, die er dann annehmen, ablehnen oder durch weitere Anfragen iterativ anpassen kann.

• Agent 

  Ein erweiterter „Edits“-Modus, der automatisch auf Rückmeldungen (z.B. Testfehler) reagiert und automatisch iterieren kann. Dabei kann der Agent so genannte Tools nutzen, um Aktionen auszuführen (z.B. einen Testlauf starten) oder Informationen abzurufen (z.B. Zugriff auf ein internes Wiki). Diese Tools können proprietäre Extensions oder MCP-Server sein. Bei MCP handelt es sich um ein von der Firma Anthropic entwickeltes Protokoll zur Standardisierung der Verknüpfung von LLMs mit weitern Anwendungen und Datenquellen. Es sind bereits MCP-Server für viele Anwendungsfälle verfügbar (z.B. zum Abruf von Daten aus Confluence).

Die Interaktionen mit GitHub Copilot resultieren in Anfragen an ein LLM. Dafür kann der Entwickler verschiedene Modelle auswählen (z.B. GPT-4.1 oder Claude Sonnet). Die Rückmeldung wird dann von GitHub Copilot verarbeitet, um eine entsprechende Antwort anzuzeigen oder auch Code zu editieren.

Mit dem eigentlichen Prompt muss dabei auch Kontext transportiert werden. Dieser kann u.a. folgende Bestandteile enthalten:

• Der aktuelle Chatverlauf
• Die aktuelle Datei oder der Text um den Cursor
• Einzelne Dateien, Ordner oder auch der gesamte Quellcode der Anwendung
• Daten aus Extensions oder von MCP-Servern

Anhand der Demoapplikation „Legacy CRM“ wird gezeigt, wie künstliche Intelligenz Softwareentwicklung konkret unterstützt – von der Analyse über die Dokumentation bis hin zur Migration.

Mit dem Ask-Modus von GitHub Copilot kann ein Entwickler eine Legacy-Applikation analysieren und dokumentieren. Die KI hilft dabei, Technologien, Funktionen und Strukturen zu verstehen und daraus Use-Cases, technische Beschreibungen und Diagramme zu generieren.

Gerade beim Onboarding neuer Entwickler beschleunigt künstliche Intelligenz Softwareentwicklung durch automatisierte Wissensvermittlung und Dokumentation.

Um nun ein existierendes System im Detail nachzudokumentieren, können, ebenfalls im Ask Modus, beispielsweise User Stories, Use-Cases, technische Beschreibungen und Diagramme generiert werden.

Eine solide Testabdeckung ist essenziell für jede Modernisierung. KI unterstützt beim Design von Unit-, Integrations- und manuellen Tests.

Im Edits- oder Agent-Modus kann der Entwickler fehlende Tests KI-gestützt implementieren – vorausgesetzt, die Prompts enthalten präzise Angaben zu Frameworks und Libraries. So wird künstliche Intelligenz Softwareentwicklung auch im Bereich Qualitätssicherung zum Gamechanger.

Auch bei der Planung und Durchführung von Migrationen zeigt sich die Stärke von KI. GitHub Copilot hilft bei der Auswahl von Zieltechnologien und Migrationsphasen.

Bei konkreten Aufgaben – etwa der Transformation einer Legacy-UI von ASP.NET WebForms zu Angular – unterstützt die KI durch konkrete Codevorschläge und Architekturhinweise.

Künstliche Intelligenz Softwareentwicklung wird so zur treibenden Kraft für moderne IT-Landschaften.

Der Einsatz von Künstlicher Intelligenz in der Softwareentwicklung bietet enorme Chancen – bringt jedoch auch spezifische Herausforderungen mit sich. Damit KI-gestützte Modernisierungsprojekte erfolgreich verlaufen, müssen Entwickler technische Grenzen kennen, methodisch vorgehen und neue Kompetenzen aufbauen. Im Folgenden werden zentrale Stolpersteine wie Kontextlimitierung, Fehlinterpretationen durch KI-Modelle, die Auswahl geeigneter Modelle sowie das präzise Prompting näher beleuchtet.

1. Die Kontextlimitierung

Die Größe des Kontexts, den man einem LLM mit den Prompts mitgeben kann, ist begrenzt. Je nach Modell und Programmiersprache auf rund 50K – 100K Codezeilen. Dies wird von mittelmäßig-komplexen Anwendungen schnell überschritten. 

Da dem LLM bei der Analyse daher nur ein Ausschnitt der Anwendung bekannt ist, sind Entwickler gefordert, durch die sorgfältige Auswahl geeigneter Kontextinformationen eine fundierte Auswertung zu ermöglichen. Zudem muss der Entwickler die entsprechende Aufgabe sukzessive an passenden Teilbereichen der Applikation ausführen.

Arvato Systems hat hierzu einen eigenen Ansatz als iterativen Prozess geschaffen.

2. Auch KIs machen Fehler

Zusätzlich ist es wichtig zu beachten, dass KI Tools Fehleinschätzungen treffen, die im weiteren Prozess erkannt und behoben werden müssen. 

Eine Quelle für diese Fehler ist die so genannte Halluzination von KI-Modellen, bei der falsche oder erfundene Informationen geliefert werden können, die jedoch oft plausibel oder korrekt erscheinen. Dies kann beispielsweise dazu führen, dass bei der Nachdokumentation eines Systems Lücken kreativ gefüllt und nichtexistierende Features beschrieben werden.

Das Halluzinieren lässt sich in gewisser Weise durch entsprechende Prompts einschränken, aber auch kritischer menschlicher Review ist erforderlich - zum Beispiel durch die Fachexperten einer Applikation.

Das Thema Review spielt insbesondere auch für Code Änderungen eine Rolle, denn ebenfalls hierbei wird gelegentlich Code erzeugt, der zwar syntaktisch korrekt, aber funktional falsch ist.

Zum einen ist es hierbei notwendig den Umfang von Code-Änderungen in überschaubarem Rahmen zu halten, damit Reviews beherrschbar bleiben. Zum anderen ist es für Entwickler essenziell, Code-Reviews als eigenständige Disziplin zu begreifen und zu professionalisieren, um Fehler systematisch aufzudecken – insbesondere, da diese häufig subtiler und schwerer zu erkennen sind als menschliche Fehler.

Auch für den Agentenmodus, der – zum Beispiel durch das Ausführen von Tests – Fehler in Teilen selbst beheben kann, spielt der Umfang von Änderungen eine Rolle. Werden die Änderungen zu groß, gelingt es dem Agenten oft nicht alle Fehler zu beheben, oder es werden dabei immer neue Fehler erzeugt. Dies kann in eine endlose Iterationsschleife münden. Der Agentenmodus hat dafür einen integrierten Schutzmechanismus, der in gewissen Zeitintervallen abfragt, ob der Agent weiterhin nach einer Lösung suchen soll.

Die Modernisierung von Legacy-Systemen bleibt anspruchsvoll – aber mit künstlicher Intelligenz in der Softwareentwicklung deutlich effizienter.

KI unterstützt beim Schreiben von Code, der Generierung technischer Dokumentation und der Qualitätssicherung. Wer Modellwahl, Prompting und Reviews beherrscht, hebt die Softwareentwicklung auf ein neues Niveau.

Gleichzeitig gilt: KI ist kein Selbstläufer, und ein Copilot ist kein Autopilot. Die Auswahl des passenden Modells, präzises Prompting, ein iteratives Vorgehen und kritische Reviews sind entscheidend für den Erfolg. Wer diese Kompetenzen gezielt aufbaut, kann nicht nur Legacy-Code modernisieren, sondern die Softwareentwicklung insgesamt auf ein neues Niveau heben.

Möchten Sie wissen, wie Arvato Systems KI in der Applikationsmodernisierung einsetzt oder benötigen Sie Unterstützung bei der Modernisierung Ihrer Legacy-Systeme? Kontaktieren Sie uns für eine individuelle Beratung.