Large Language Models (LLMs) haben das Programmieren grundlegend verändert. Sie generieren in Sekunden funktionierenden Code, schlagen Architekturen vor und füllen Boilerplate Code fehlerfrei aus und haben Antworten auf alle noch so technisch komplexen Fragen. Das zeilenweise Schreiben von Code ist kein Engpass mehr und trotzdem können LLMs ohne Experten keine gute Software schreiben.
Muster statt Verständnis
LLMs reproduzieren Muster aus Trainingsdaten. Sie optimieren auf Wahrscheinlichkeit, nicht auf Verantwortung. Sie habe keine semantische Wahrnehmung von Anforderungen, Sicherheitsanforderungen oder von langfristigen Systemauswirkungen.
Aktuelle Untersuchungen zeigen:
- Ein erheblicher Anteil KI-generierter Codeschnipsel enthält ernsthafte Sicherheitslücken oder verstößt gegen gängige Sicherheitsstandards, unabhängig von Modellgröße oder Anbieter. ¹
- KI-Tools sind schwach darin, Risiken, Bedrohungsmodelle oder implizite Annahmen korrekt zu erfassen, selbst wenn der Code funktional korrekt ist. ²
- LLM-Assistenz führt häufig zu mehr technischer Schuld: mehr Duplikate, höhere Komplexität, schwerer wartbare Strukturen. Entwickler neigen dazu, generierten Code zu akzeptieren, ohne ihn zu hinterfragen. ³
- Paradoxerweise kann bei erfahrenen Entwicklern die Produktivität sinken, weil der Review-, Debugging- und Absicherungsaufwand steigt. ⁴
Kurz gesagt: KI ist exzellent darin, plausible Lösungen vorzuschlagen. Aber sie versteht nicht, was langfristig wirklich zählt und was sich duch KI nicht geändert hat ist, dass es sehr einfach ist, schlechte Software zu entwickeln.
Das Problem ist nicht der Code, sondern die Steuerung
Früher lag der Engpass in der Implementierung. Heute verschiebt er sich. Das Schreiben von Code haben LLMs weitgehend „gelöst”. Was sie nicht lösen:
- Sicherheitsarchitektur
- Bedrohungsmodelle
- Compliance-Anforderungen
- Systemgrenzen
- Performance-Strategien
- Wartbarkeit
- Klare Anforderungen
Diese Dinge entstehen nicht automatisch aus gut aussehenden Codeblöcken. Sie müssen bewusst festgelegt, überprüft und durchgesetzt werden.
Wem das jetzt irgendwie bekannt vorkommt, das war auch in den letzten 50 Jahren schon so und wird sich auch durch Code generierende Modelle nicht verändern. Gute Software muss von schlauen Köpfen geplant und umgesetzt werden.
Alter wein in neuen Schläuchen. Denn genau hier beginnt unsere neue Verantwortung, die auch in pre KI Zeiten dieselbe war.
Vom Coder zum System-Dirigenten
Die Rolle des Entwicklers verändert sich aber dennoch fundamental. Es geht nicht mehr darum, jede Codezeile selbst zu schreiben. Stattdessen wird es auch für Junior-Entwickler wichtig,
- Anforderungen präzise zu definieren
- Sicherheitsregeln explizit zu formulieren
- Architekturentscheidungen bewusst zu treffen
- Ergebnisse kritisch zu prüfen
- Konformität systematisch zu verifizieren
Wir verschieben uns von „Implementierung” zu „Steuerung”. LLMs sind keine autonomen Entwickler. Sie sind extrem leistungsfähige Werkzeuge. Aber ein Werkzeug ersetzt nicht das Urteilsvermögen eines Experten und ein Werkzeug ist nur so leistungsfähig, wie die Person, die es verwendet.
Die eigentliche Gefahr ist Kontrollverlust durch Bequemlichkeit
Die größte Gefahr sind nicht schlechte KI oder schlechte Entwickler. Die größte Gefahr ist Bequemlichkeit.
Wenn wir generierten Code übernehmen, ohne ihn zu prüfen, wenn wir Sicherheit implizit statt explizit behandeln, wenn wir Verantwortung an Wahrscheinlichkeitsmodelle delegieren, dann steuert die KI uns. Vielleicht nicht bewusst, aber faktisch auf jeden Fall.
Und dann verbringen wir mehr Zeit mit Review, „Vibe-Debugging” und Reparaturen, als wir früher mit sauberer Entwicklung gebraucht hätten.
Fazit: LLMs richtig führen lernen
Der entscheidende Skill der Zukunft ist nicht Vibe-Coding, es ist Prompting und zwar so, dass man selbst das Volant in der Hand hält und nicht das LLM die Führung übernimmt.
Wir müssen lernen:
- Anforderungen präzise zu formulieren
- Sicherheitsmechanismen explizit zu definieren
- Architektur bewusst vorzugeben
- Generierten Code systematisch zu prüfen
- KI-Ergebnisse zu validieren statt zu vertrauen
Die KI darf uns nicht steuern. Wir müssen die KI steuern.
Das einfache Programmieren ist automatisiert. Die Verantwortung ist es nicht, denn wer LLMs nur als Beschleuniger nutzt, der verliert die Kontrolle. Wer sie als Werkzeug unter klarer Führung einsetzt, gewinnt echte Produktivität, muss sich aber ernsthaft damit beschäftigen, was viel Zeit und Geduld kostet und den Willen zu lernen voraussetzt.
Der Unterschied liegt nicht im Modell, sondern im Umgang damit.
Wenn sich das alles für dich als alter Wein in neuen Schläuchen anfühlt, dann bist du vermutlich kein Berufseinsteiger, sondern schon mehrere Jahre in der Softwareentwicklung tätig. Somit fühlt sich das auch nicht mehr bedrohlich an, sondern eher als bekannte Erfahrung.
Denn KI ersetzt keine Erfahrung. Sie skaliert sie.
Die Grundlagen guter Softwareentwicklung, strukturiertes Denken, Priorisierung, kontinuierliche Tests, gründliche Dokumentation und Sicherheitsbewusstsein, bleiben unverändert. Was sich stetig ändert, ist das Tempo und die Art, wie wir Werkzeuge einsetzen und das sind wir doch mittlerweile gut gewohnt.