"Von Entwickler zu Entwickler: Was geht dir durch den Kopf, wenn du den Begriff „Softwarequalität“ hörst?
Du denkst wahrscheinlich an Dinge wie „Clean Code“, „Unit-Tests“, „Modularität“ oder „Architektur“. Und vermutlich auch an die Erkenntnis, dass man trotz all dieser Prinzipien oft ziemlich im Nebel steht, wenn man ein großes oder unbekanntes Projekt übernimmt.
Klassische Qualitätsmetriken wie „zyklomatische Komplexität“ oder „Lines of Code“ liefern zwar erste Anhaltspunkte, bleiben aber meist abstrakt. Über den tatsächlichen Kontext sagen sie nur wenig aus:
Genau hier setzt DeepQuali an. Es ist kein Zaubertool, das dir Entscheidungen abnimmt, sondern eher ein Kollege, der dir schnell ein klares Bild von einer Codebasis vermittelt. Wir bei QAware haben DeepQuali gemeinsam mit Partnern wie dem Fraunhofer IESE im Rahmen eines BMBF-Forschungsprojekts entwickelt und dabei vor allem das Backend beigesteuert. DeepQuali ist ein Baustein, um Softwarequalität besser einschätzen und gezielt verbessern zu können. Es ist unser Beitrag dazu, Softwarequalität ein Stück weit transparenter und greifbarer zu machen – von Entwicklern, für Entwickler.
Viele Ansätze zur Softwarequalität stützen sich noch immer auf statische Metriken: Anzahl der Codezeilen, Komplexitätswerte, Testabdeckung. Das sind nützliche Anhaltspunkte. Aber Hand aufs Herz: Wir alle kennen Projekte, bei denen auf dem Papier alles im grünen Bereich war – und die trotzdem schwer zu verstehen, mühsam zu erweitern oder sogar fragil waren. Das Problem: Zahlen allein liefern kaum Kontext. Sie verraten dir weder, ob ein Projekt sinnvoll strukturiert ist, noch ob eine Klasse eine klare Verantwortung hat oder das Zusammenspiel der Komponenten stimmig ist. Genau diese Fragen wollen wir Entwickler aber beantworten. Wichtig dabei: DeepQuali ist kein Black-Box-Orakel. Alle Prompts sind einsehbar, die Ergebnisse nachvollziehbar und die Bewertungen beruhen auf bekannten Prinzipien wie Kopplung, Kohäsion oder Schichtenmodellen.
DeepQuali soll keinesfalls die Entscheidungen von Architekten ersetzen. Das kann es nicht, und das will es auch nicht. Die Verantwortung bleibt am Ende immer bei uns Entwicklern und Architekten. DeepQuali liefert vielmehr strukturiertes Feedback:
Stell dir DeepQuali wie einen besonders aufmerksamen Co-Piloten vor: Es liest deinen Code, macht sich Notizen und gibt dir anschließend Hinweise wie diese:
Am Ende bekommst du also nicht nur Zahlen, sondern eine konkrete Einschätzung und sogar Vorschläge, die dich bei Refactorings und Architekturentscheidungen unterstützen.
Nun stellen sich natürlich Fragen:
Werfen wir einen genaueren Blick darauf, ohne gleich tief in Algorithmen oder YAML-Monstrositäten abzutauchen.
Bevor wir als Entwickler etwas bewerten können, brauchen wir zunächst Kontext. Bei Software bedeutet das vor allem, zu verstehen, wie die einzelnen Klassen miteinander zusammenhängen. DeepQuali nutzt dafür zwei unterschiedliche Ansätze:
Am Ende kennen wir alle Klassen – wobei wir mit „Klasse“ ab jetzt jede beliebige Quelldatei meinen – und ihre Abhängigkeiten. Das Ergebnis ist ein Netzwerk, manchmal sogar ein zyklisches. (Nein! Doch! Oh!) DeepQuali bringt Ordnung in diesen Abhängigkeitsdschungel, indem es das Netzwerk linearisiert. Dadurch werden Abhängigkeiten in der Regel vor dem Code analysiert, der sie verwendet. Technisch gesehen handelt es sich dabei um eine Näherungslösung für das Minimum Feedback Arc Set. An alle Graphen- und Algorithmustheoretiker: jetzt seid ihr wach!
In genau dieser Reihenfolge analysiert DeepQuali nun die Klassen und erstellt jeweils eine kompakte Zusammenfassung: Was macht die Klasse? Welche Methoden sind besonders wichtig? Dabei fließen die bereits erstellten Zusammenfassungen ihrer Abhängigkeiten in die Analyse ein.
Das KI-Modell betrachtet dabei nicht nur, was die Methoden tun, sondern auch grundlegende Architekturfragen: Hat die Klasse einen klaren Fokus? Wie stark ist sie gekoppelt? Sind ihre Schnittstellen einfach und verständlich?
Die Zusammenfassungen helfen also nicht nur dir, den Code schneller zu verstehen. Sie machen ihn auch für die KI handhabbar, ohne dass wir ihr den gesamten Quellcode auf einmal übergeben – und damit ziemlich sicher das Kontextfenster sprengen.
Alle Ergebnisse landen anschließend in einem Index, für den DeepQuali derzeit OpenSearch nutzt. Dort kannst du sie abrufen, filtern oder dich bequem über eine UI durchklicken.
Danach geht es eine Ebene höher: Die Ergebnisse der einzelnen Klassen fließen in die Analyse ihrer Pakete ein. Bei übergeordneten Paketen werden wiederum die Analysen der enthaltenen Unterpakete berücksichtigt. So arbeitet sich DeepQuali (bottom-up) von den tiefsten Paketen Schritt für Schritt bis zum Root-Package vor. Am Ende entsteht ein Gesamtbild der Projektstruktur – einschließlich Hinweisen auf Schichten, Architekturpatterns und Anti-Patterns.
Viele Ansätze zur Codeanalyse stoßen bei großen Projekten schnell an ihre Grenzen: Irgendwann wird der Input für das KI-Modell schlicht zu umfangreich. DeepQuali löst dieses Problem mit einem agglomerativen Ansatz und verdichtet die Informationen schrittweise. Statt Zehntausende Zeilen Code auf einmal in das Modell zu kippen, erstellt es kompakte Zusammenfassungen, die anschließend als Kontext dienen. So bleiben die Prompts überschaubar und die Ergebnisse aussagekräftig – selbst bei sehr großen Codebasen.
Die KI bewertet nicht einfach Codezeilen oder abstrakte LOC-Werte. Stattdessen richtet sie den Blick auf das, was für Entwickler wirklich relevant ist:
Stärken: klare Schichtentrennung, intuitive API, gute Testbarkeit
Risiken: eine zu komplexe OrderProcessor-Klasse, enge Kopplung an Datenbankdetails
Empfehlung: Geschäftslogik und Datenbankzugriff im OrderProcessor voneinander trennen
So entstehen kurze, fokussierte Einschätzungen mit konkreten Hinweisen, die sich direkt umsetzen lassen.
Ein interessantes Detail, ohne zu sehr ins Technische abzutauchen: DeepQuali wurde von Anfang an auf Erweiterbarkeit ausgelegt – mit Scripting als zentralem Baustein. Dadurch lässt es sich leicht an neue Anwendungsfälle anpassen: von Architekturbewertungen über Codequalitätsprüfungen bis hin zu speziellen Szenarien wie der „Code-Archäologie“ in Legacy-Systemen. Neue Funktionen können einfach über Groovy, JavaScript oder eine andere JSR223-kompatible Skriptsprache ergänzt werden.
Wie die Ergebnisse von DeepQuali konkret aussehen, zeigen die folgenden beiden Beispiele:
Du hast keine einzige Zeile Code gesehen und weißt trotzdem schon, wofür dieses Paket zuständig ist. Stell dir vor, du steigst neu in ein Projekt ein: keine Dokumentation, kein Onboarding – oder du übernimmst plötzlich ein gigantisches Legacy-System. DeepQuali schafft diese Art von Überblick für jedes einzelne Paket. Hilfreich? Jau!
Die Implementierung ist stark an ASM gekoppelt. Dadurch lässt sich das Framework für die Bytecode-Analyse nur schwer austauschen.
Das tief verschachtelte Visitor-Pattern mit anonymen inneren Klassen erschwert die Lesbarkeit und Wartung.
Fehlerhafter Bytecode oder Probleme beim ASM-Parsing werden bislang nur unzureichend abgefangen und können zu unerwarteten Abstürzen führen.
Klare Trennung der Verantwortlichkeiten (Separation of Concerns) durch eigene Visitor-Klassen wie DependencyGraphCollector, die dem ASM-Visitor-Pattern folgen.
Gut dokumentierte öffentliche API mit ausführlichem Javadoc zu den Vorteilen und Grenzen der Bytecode-Analyse.
Thread-sicheres Design durch ein Enum-Singleton und unveränderliche statische Methoden.
Ein insgesamt gut aufgebautes Werkzeug zur Bytecode-Analyse mit klarer API und guter Dokumentation. Schwächen zeigt es vor allem bei der engen Kopplung an ASM und der komplexen, verschachtelten Visitor-Implementierung.
| attribute | rating |
|---|---|
| apiDesign | 8 (very good) |
| complexity | 5 (average) |
| coupling | 6 (decent) |
| focus | 8 (very good) |
| modularity | 6 (decent) |
| testability | 7 (good) |
Was meinst du: Vermittelt dir dieser Auszug ein Gefühl dafür, wo die Architektur solide ist und an welchen Stellen es hakt? Und sind die Empfehlungen konkret genug, um daraus die nächsten Schritte abzuleiten?
Entwicklungszyklen werden immer kürzer, der Zeitdruck steigt. Dabei entstehen schnell technische Schulden, die im Arbeitsalltag zunächst kaum auffallen – bis sie irgendwann teuer werden. DeepQuali soll dabei helfen, solche Probleme frühzeitig sichtbar zu machen: nicht mit abstrakten Diagrammen, sondern mit konkreten Hinweisen direkt aus dem Code.
Manchmal fühlt sich das fast wie Code-Archäologie an: Ein altes Projekt ohne Dokumentation? Kein Problem. DeepQuali arbeitet sich durch die Klassen und Pakete und liefert innerhalb weniger Minuten einen Überblick, für den du sonst deutlich länger bräuchtest.
So weit die Theorie. Aber was passiert, wenn DeepQuali auf die Realität trifft? Auf unübersichtlichen, komplexen und undokumentierten Code – du kennst die üblichen Verdächtigen.
Zeit für Erfahrungen aus der Praxis!
Eines unserer größten Aha-Erlebnisse: Schon die kurzen Beschreibungen, was eine Klasse tut und wie sie in das System eingebettet ist, verändern den Blick auf ein Projekt enorm. Ursprünglich waren diese Zusammenfassungen nur als Kontext für die Architekturbewertung durch das LLM gedacht. In der Praxis haben sie sich aber als äußerst hilfreich erwiesen, um ein Projekt schneller zu verstehen.
Das Abstraktionsniveau, das Modelle wie ChatGPT oder Claude dabei erreichen, ist beeindruckend. DeepQuali wird so zum Navigationssystem für Codebasen: Repository rein, grobe Landkarte raus. Gerade bei unbekanntem Code spart das enorm viel Zeit.
Auch die Architekturbewertungen funktionieren in der Praxis erstaunlich gut: Das LLM erkennt zuverlässig, ob ein Projekt sinnvoll in Schichten gegliedert ist, ob die Domänenlogik sauber vom Framework getrennt wurde – oder ob sich irgendwo ein God-Class-Monster versteckt.
Im Entwicklungsalltag sehen wir vor allem zwei Einsatzmöglichkeiten für DeepQuali:
Ad-hoc-Analysen: Du möchtest dir schnell einen Überblick über ein Projekt verschaffen – beim Einstieg, während eines Reviews oder bei einer Runde „Code-Archäologie“.
Integration in CI/CD-Pipelines: DeepQuali lässt sich als leichtgewichtiges Analysewerkzeug in bestehende Pipelines integrieren. Dabei soll es bewusst kein hartes Quality Gate bilden, sondern auf mögliche Probleme hinweisen – denn die Bewertungen können von Lauf zu Lauf leicht schwanken.
DeepQuali ist keine Silver Bullet. Aber es ist ein Werkzeug, das Zeit spart und wertvolle Einblicke liefert. Es macht Stärken und Schwächen sichtbar, gibt Denkanstöße für bessere Architekturentscheidungen und hilft dir, dich schneller in unbekannten oder gewachsenen Codebasen zurechtzufinden.
Wichtig ist dabei: DeepQuali bewertet die Struktur, nicht die fachliche Korrektheit. Es kann dir nicht sagen, ob deine Geschäftslogik sinnvoll ist oder die Architektur tatsächlich zu deiner Domäne passt. Dafür – und für viele weitere Fragen – bleibt menschliche Expertise unverzichtbar.
Für uns ist DeepQuali vor allem ein Beitrag dazu, Softwarequalität transparenter und greifbarer zu machen. Und wenn es dir hilft, dich in deinem nächsten Projekt schneller zurechtzufinden, hat es seinen Zweck erfüllt.