Von der Idee zum Werkzeug: Wie wir mit einem KI-Modell in 3 Stunden ein Code-Analyse-Tool entwickelt haben#

Wir wollten wissen, wie weit man mit KI-gestützter Entwicklung wirklich kommt. Das Ergebnis: Ein Tool, das 1,2 Millionen Zeilen Java-Code analysiert – entwickelt in nur 3 Stunden mit einem Sprachmodell.

Dieser Beitrag zeigt, was dabei funktioniert hat und wo die Grenzen liegen.

Was war das Ziel?#

Wir wollten ein Code-Analyse-Tool für Java-Projekte entwickeln – mit realistischer Komplexität. Die Fragen dabei: Wie funktioniert die Zusammenarbeit mit einem Sprachmodell bei steigender Komplexität? Welche Strukturen sind nötig? Und wo sind die praktischen Grenzen?

Was kann das Tool?#

Das Tool analysiert Java-Projekte auf mehreren Ebenen:

• Datei-Ebene: Geschäftslogik, technische Details und Schnittstellen jeder einzelnen Datei verstehen
• Paket-Ebene: Zusammenhänge zwischen Paketen erkennen (z. B. Zuordnung zu Architektur-Schichten)
• Modul-Ebene: Struktur größerer Module erfassen
• System-Ebene: Gesamtarchitektur des Projekts beschreiben

Für jede Java-Datei führt das Tool vier spezialisierte Analysen durch. Die Ergebnisse werden in lesbarer Form ausgegeben – als strukturierte Beschreibungen, nicht als Rohdaten.

Wie wurde es entwickelt?#

Der Prozess lief in zwei Phasen:

Phase 1 – Anforderungen klären (1 Stunde): Wir haben im Dialog mit verschiedenen Sprachmodellen die Anforderungen ausgearbeitet. Das Modell stellte Fragen, wir haben Antworten gegeben. Wichtig war dabei: Aktiv gegen zu komplexe Lösungen steuern, denn Sprachmodelle neigen zu Overengineering.

Phase 2 – Code erzeugen (2 Stunden): Die Umsetzung erfolgte in 4-5 Iterationen. Der Ablauf: Erst funktionale Anforderungen, dann Benutzeroberfläche, dann Technologie-Auswahl, dann Architektur. Kein späteres Überarbeiten mehr nötig.

Gesamtaufwand: 3 Stunden über mehrere Tage verteilt.

Ergebnis: 5.000-6.000 Zeilen Python-Code in 6 Dateien.

Warum lief es so gut?#

Weil wir viel Zeit in klare Anforderungen gesteckt haben.

Je genauer die Beschreibung dessen, was das Tool können soll, desto besser der erzeugte Code. Diese Klarheit entsteht im Dialog – das Sprachmodell kann durch gezielte Nachfragen Lücken aufdecken. So wird die Beschreibung widerspruchsfrei und vollständig.

Ein zweiter Faktor: Die konsequente Anwendung des “Keep It Small and Simple”-Prinzips. Sprachmodelle schlagen gerne komplexe Lösungen vor. Einfachheit muss man aktiv einfordern.

Wichtige Erkenntnisse#

1. Gute Beschreibungen sind der Erfolgsfaktor#

Sprachmodell-gestützte Entwicklung funktioniert über präzise Beschreibungen. Der generierte Code ist nur so gut wie die Anforderungen, die man formuliert.

Diese Klarheit kann man im Dialog mit dem Modell erarbeiten. Es stellt Fragen wie: “Was soll passieren, wenn…?” oder “Welche Priorität hat…?”. So entstehen vollständige Beschreibungen.

2. Grenzen liegen bei der Code-Länge#

Sprachmodelle erzeugen zuverlässig Code bis etwa 1.000-1.500 Zeilen pro Komponente. Darüber hinaus nimmt die Qualität ab.

Das bedeutet: Man muss die Architektur so planen, dass einzelne Teile diese Grenze nicht überschreiten. Ein Verständnis für Software-Struktur bleibt nötig – nicht um selbst zu programmieren, aber um sinnvolle Aufteilungen zu spezifizieren.

3. Gegen Komplexität aktiv steuern#

Sprachmodelle überschätzen häufig ihre Fähigkeiten. Sie schlagen aufwendige Lösungen vor, wo einfachere ausreichen würden.

Die Konsequenz: Man muss die Auswahl der technischen Lösungen hinterfragen. “Gibt es eine einfachere Lösung?” ist z.B. eine gute Standard-Frage im Dialog.

4. Die Rolle verschiebt sich#

Entwickelnde werden zu Architekten und Anforderungs-Klärern. Die eigentliche Programmierung delegiert man an das Modell.

Das ermöglicht Fachexperten ohne tiefe Programmierkenntnisse, spezialisierte Tools für ihre Domäne zu bauen. Für explorative Projekte oder interne Werkzeuge ist das sehr wertvoll.

Was können andere davon lernen?#

• Investiere Zeit in klare Anforderungen – das spart später Korrektur-Aufwand
• Nutze den Dialog: Lass das Sprachmodell Fragen stellen
• Fordere aktiv einfache Lösungen ein, sonst wird es zu komplex
• Plane die Architektur so, dass Komponenten unter 1.500 Zeilen bleiben - besser unter 1.000
• Validiere regelmäßig: Ist der erzeugte Code noch auf dem richtigen Weg?

Fazit#

✔ Ein in 3 Stunden entwickeltes Tool hat ein Projekt mit 1,2 Millionen Zeilen Code analysiert

✔ Sprachmodell-gestützte Entwicklung eignet sich besonders für Prototypen und explorative Projekte

✔ Klare Anforderungen und einfache Strukturen sind der Schlüssel zum Erfolg

Wichtige Klarstellung: Dies war ein Experiment, kein produktionsreifes System. Die Frage war: Wie weit kommt man überhaupt? Die Antwort: Weiter als erwartet, aber mit klaren Grenzen.

Dieser Beitrag ist Teil einer Reihe über Entwicklung mit Sprachmodellen. Der Fokus liegt darauf, was funktioniert und was nicht – nicht auf perfekten Lösungen.