Die Bedeutung von Clean Code
Sind Clean Code und KI ein Widerspruch? Oder ist Clean Code in Zeiten von KI Tools sogar noch wichtiger geworden?
Das Thema Clean Code hat sich in den zurückliegenden Jahren in der Softwareentwicklung zu einem Kernthema entwickelt. Prinzipien und Praktiken der Clean Code Developer Initiative sind weithin anerkannt und werden mal mehr, mal weniger intensiv angewandt. Sogar automatisierte Tests werde geschrieben. Manchmal… Doch in den letzten Monaten gibt es eine Entwicklung, die eine Neubewertung des Themas Clean Code erfordert: die KI.
Anfangs war die KI für uns Softwareentwickler ein Werkzeug, das die Arbeit in der IDE vereinfacht hat. Die Codevorschläge wurden immer besser, aber im Grunde haben wir den Großteil des Codes immer noch selbst geschrieben. Das ein oder andere Codesnippet hat man sich mal generieren lassen und dann, hoffentlich, nach den Regeln der Kunst so angepasst, dass es nicht nur seinen Zweck erfüllte, sondern auch die Clean Code Prinzipien eingehalten hat und somit den Werten Wandelbarkeit und Korrektheit gehorchte. Die aktuelle Entwicklung der „Agentic AI“ stellt allerdings einiges auf den Kopf. Vereinfacht gesagt kann ich in Claude Code meine Anforderungen formulieren und erhalte Code, der zumindest schonmal macht was er soll. Dafür sorgen die Tests, die ebenfalls generiert werden. Durch Agentic AI wird das Tool in die Lage versetzt, mit der Codebasis und den Tools wie Compiler und Test Runner unmittelbar zu interagieren. Auch der Zugriff auf das Web ist möglich, um nach Bibliotheken und Dokumentation zu suchen. Die KI kann damit die Softwareentwicklung autark übernehmen. Der Schlüssel zu all dem sind die MCP Server.
Die KI hat sich so sehr schnell zu einem relevanten Werkzeug entwickelt, das die Arbeitsweise von Softwareentwicklern dramatisch verändert. Vielfach herrscht noch Angst und Ablehnung. Doch wir haben uns auch sehr schnell an Compiler und Hochsprachen gewöhnt. Niemand schaut in den vom Compiler generierten Maschinencode. So wird es auch mit der KI passieren: niemand wird mehr in den Code schauen, wenn die KI aus Anforderungen lauffähige Software macht. Und im Zweifel wird, wie beim Compiler, nach jeder Änderung alles oder jedenfalls relevante Teile neu generiert.
Häufig höre und lese ich die Kritik, dass die KI so schlechten Code erzeugt, dass damit keine langfristig wandelbare Software erstellt werden kann. Doch genau das stelle ich sehr in Frage. Natürlich benötigt ein so leistungsfähiges Werkzeug einen ebenso leistungsfähigen Bediener. Wer noch nie in seinem Leben Software entwickelt hat, wird, derzeit, mit der KI nur mittelmäßige Codequalität erreichen. Doch zum einen bin ich weiterhin überzeugt, dass sich dies sehr schnell ändern wird. Zum anderen müssen wir das Potential der KI nutzen und uns fragen, wie wir unsere Arbeitsweise verändern müssen. Produktivitätssteigerungen im Bereich von Faktor 5 – 10 mal mehr Output habe ich selbst erlebt. Das können wir nicht ignorieren. Die Frage lautet also, wie integrieren wir die KI so in unseren Softwareentwicklungsprozess, dass wir mindestens die selbe Qualität erhalten, wie derzeit bei handgemachter Software.
Von den Anforderungen zum Code
In unseren Trainings vermitteln wir einen Softwareentwicklungsprozess, der in 8 Schritten von den Anforderungen zum Code führt. Ich habe in diesem Beitrag darüber berichtet. Dies sind die Schritte:
Anforderungen
- Anforderungen vertikal zerlegen
- Entwurf in die Breite
- Eine Anforderung auswählen
- Verfeinerung des Entwurfs in die Tiefe
- Arbeitsorganisation
- Implementation inkl. Tests
- Integration inkl. Tests
- Code Review
Code
Als erstes habe ich mich gefragt, ob wir durch leistungsfähige KI Tools wieder zurückkehren zum Wasserfall anstelle der Agilität. Doch diesen Gedanken habe ich schnell verworfen. Auch wenn ich als Entwickler 10-mal soviel Features pro Zeiteinheit entwickeln kann, muss ich dazu Feedback vom Kunden bzw. Product Owner erhalten. Ggf. müssen wir überdenken, wieviele Features wir in einen Sprint aufnehmen können und die Sprintdauer weiter verkürzen, weil die Ergebnisse so viel schneller vorliegen. Doch an der Agilität geht auch mit Einsatz der KI kein Weg vorbei.
Agilität = regelmäßiges kurzfristiges Feedback
Entwurf in die Breite
Auch der zweite Schritt bleibt weiterhin sinnvoll. Im Wesentlichen geht es hier darum klarzustellen, was die Eingaben des Anwenders sind und welche Ausgaben er erwartet. Die folgende Abbildung zeigt das am Beispiel eines CSV Viewers.
Dieser Schritt führt zu einer Präzisierung der Anforderungen und führt gleichzeitig zur Klarheit, welche Daten ein Dialog liefern muss und welche Daten als Resultat zurückgeliefert werden.
Eine Anforderung auswählen
Auch die Auswahl einer einzelnen Anforderung bleibt wichtig, denn die Implementation soll weiterhin in Inkrementen erfolgen, zu denen wir Feedback einholen. Hier ist weiterhin der Product Owner dafür verantwortlich, die nächste relevante Anforderung auszuwählen, die für ihn bzw. die Kunden den größten Nutzen stiftet. Der Fokus auf die Bedürfnisse der Anwender bleibt eine zentrale Aufgabenstellung.
Verfeinerung des Entwurfs in die Tiefe
Die Verfeinerung des Entwurfs in die Tiefe ist allerdings nun Aufgabe der KI. Als Entwickler muss ich die Details nicht mehr vordenken, sondern kann dies der KI überlassen. Solange ich der KI präzise beschreibe, was meine Anforderungen sind, kann diese Code und Tests erzeugen. Allerdings ist es wichtig, hier zwischen dem Erstellen eines Plans und dessen Umsetzung zu trennen. Dieser Schritt könnte also bei Einsatz der KI lauten:
- Planung der Implementation
Hier fordern wir die KI auf, uns Fragen zu den Anforderungen und der technischen Umsetzung zu stellen und anschließend einen Plan für die Umsetzung zu generieren. Diesen begutachten und verbessern wir so lange, bis wir mit dem Ergebnis zufrieden sind. Hier ist der Punkt erreicht, wo der „Vibe Coder“ nicht mehr mitkommt. Es Bedarf der Expertise eines Softwareentwicklers, den Plan für die Implementation zu bewerten und anzupassen. Wohlgemerkt wird hier noch kein Code generiert sondern nur der Plan dazu erstellt.
Arbeitsorganisation
Der nächste Schritt, Arbeitsorganisation, kann komplett entfallen. Da die KI die reine Programmierarbeit vollständig übernimmt, brauchen wir diese Tätigkeit nicht mehr auf mehrere Teammitglieder aufteilen. Komponentenorientierung und Contract First sind nicht mehr notwendig.
Implementation inkl. Tests
Es folgt die Implementation durch die KI. Vermutlich ist es sinnvoll, das Generieren der Tests als eigenen Arbeitsschritt für die KI zu definieren. Somit wird der Punkt „Implementation inkl. Tests“ aufgeteilt in
- Implementation generieren
- Tests generieren
Insbesondere die Tests müssen wir uns allerdings anschauen und bewerten, ob damit unsere Anforderungen tatsächlich überprüft werden. Auch die Code Coverage Analyse ist hier wichtig um herauszufinden, ob die von der KI generierten Tests ausreichen.
Integration inkl. Tests
Da wir die arbeitsteilige Implementation durch das Team gestrichen haben, entfällt auch die Integration der einzeln erstellten Codebereiche. Die Integrationstests sehe ich unter dem vorherigen Punkt „Tests generieren“. Wohlgemerkt war mit diesem Schritt gemeint, die einzelnen Ergebnisse der arbeitsteiligen Implementation durch mehrere Entwickler zusammenzuführen. Die Integration des Ergebnisses der Iteration in die Versionskontrolle und den „Rest“ der Anwendung bleibt bestehen. Auch hierbei unterstützt uns die KI, indem wir ihr die Kontrolle über die Versionsverwaltung übergeben. Commit Meldungen und Merge Konflikte können von ihr bearbeitet werden.
Code Review
Ein Code Review ist weiterhin fundamental, denn es stellt sicher, dass die Prinzipien in der Codebasis weiterhin eingehalten werden. Allerdings werden wir auch hierbei die KI einsetzen. Wir beauftragen die KI in einem gesonderten Schritt, den Code zu bewerten nach den Clean Code Prinzipien. Die KI wird hier also den Code, den sie vorher generiert hat, bewerten und ggf. refaktorisieren. Die Tests müssen dabei natürlich weiterhin grün bleiben. Gleichzeitig sollen auch die Tests bewertet werden. Hier kann die KI bspw. die Testabdeckung ermitteln und ggf. Tests ergänzen um Lücken zu füllen.
Dieser Schritt muss durch den Entwickler begleitet werden. Oft sind die Ergebnisse der KI sehr gut. Allerdings müssen wir uns als Entwickler die Änderungen anschauen und bewerten, ob wir sie übernehmen wollen. Das geht allerdings deutlich schneller, als ohne KI.
Zusammenfassend sieht der Ablauf damit wie folgt aus:
Anforderungen
- Anforderungen vertikal zerlegen (Dev/Team)
- Entwurf in die Breite (Dev/Team)
- Eine Anforderung auswählen (Product Owner)
- Planung der Implementation (KI)
- Durchführung der Implementation (KI)
- Tests generieren (KI)
- Code Review (KI, Dev/Team)
Code
Hinter den einzelnen Schritten steht, welche Rolle dafür hauptsächlich verantwortlich ist.
Es fällt auf, dass nur noch die ersten drei Schritte menschliche Arbeitskraft benötigen. Der dritte Schritt, Auswahl einer Anforderung, fällt in den Aufgabenbereich des Product Owners und wird diesen in der Regel nur kurzes Nachdenken kosten. Damit die KI vernünftigen Output produzieren kann, benötigt sie vernünftigen Input. Das ist bei einem Softwareentwicklungsprozess ohne KI zwar auch der Fall, wird aber in vielen Projekten nicht wirklich angegangen. Oft sind Entwickler mit unvollständigen Anforderungen konfrontiert und saugen sich dann etwas aus den Fingern. Diese Zeiten sind nun vorbei. Allerdings sind wir als Entwickler nun nicht alleingelassen, sondern die KI wird uns bzw. dem Product Owner Fragen stellen und Vorschläge unterbreiten, um Klarheit in die Anforderungen zu bringen. Das alleine kann schon einen Gewinn an Produktivität bedeuten, da weniger Umarbeitung nach dem Feedback erforderlich ist, wenn wir von vornherein für Klarheit sorgen.
Fazit
Dies ist der aktuelle Stand meiner Gedanken. Ich habe diesen Prozess für mich angewendet in kleinen Beispielen und größeren Anwendungen. Er funktioniert. Ich schließe jedoch nicht aus, dass sich hier neue Erkenntnisse ergeben aus denen Änderungen an dieser Vorgehensweise resultieren. Die ursprünglichen 8 Schritte sind ebenfalls über einen längeren Zeitraum entstanden.
Wir sind gerade dabei, unsere Trainingsinhalte zu überarbeiten und werden dabei Schritt für Schritt die KI integrieren. Ist Clean Code damit hinfällig? Nein, ganz und garnicht. Es bleibt weiterhin extrem wichtig, die Prinzipien und Praktiken der Clean Code Developer Initiative zu verstehen und anzuwenden. Allerdings ändert sich unsere Vorgehensweise im täglichen Entwicklungsprozess sehr deutlich. Dieses zusätzlich benötigte Know How wollen wir als Akademie weiterhin vermitteln und so den aktuellen Entwicklungen Rechnung tragen.
Ich freue mich über jeden Kommentar!
German 
English