Hinweis zur Auflage: Diese Rezension bezieht sich auf die 1. Auflage (2025). Seit 2026 gibt es eine 2., aktualisierte und erweiterte Auflage (546 Seiten, ISBN 978-3-367-11024-7), die laut Inhaltsverzeichnis mit neuen Kapiteln zu KI-Agenten, Agentic Coding und MCP genau die unten kritisierten Lücken adressiert. Die folgende Bewertung gilt der 1. Auflage — eine Neubewertung der Neuauflage steht aus.
Über das Buch
Das Buch von 2025 stammt von drei deutschsprachigen IT-Autoren: Michael Kofler als bekanntem Fachbuchautor, Bernd Öggl und Sebastian Springer.
Die Leitfrage des Buchs: Was können große Sprachmodelle in der Softwareentwicklung leisten, wie setzt man sie effizient ein, und wie geht man verantwortungsvoll mit ihnen um? Adressat ist laut Vorwort der bereits versierte Programmierer — Funktionen, Methoden und Klassen sollten sicher beherrscht werden, idealerweise auch IT-Hintergrundwissen zu Datenbanken oder Git. Programmieranfänger sind ausdrücklich nicht gemeint; eine Ausnahme macht das Pair-Programming-Kapitel, das sich speziell an Lernende richtet.
Aufbau
Das Buch gliedert sich in zwei Teile.
Teil I — Coding mit KI-Unterstützung (Kap. 1–8) deckt den Einsatz von Cloud-LLMs und Coding-Assistenten in den klassischen Software-Entwicklungs-Aktivitäten ab: Einführung und Prompting-Grundlagen, Pair Programming als Lernhilfe, Debugging, Refactoring, Software-Testing, Dokumentation, Datenbank-Arbeit und Scripting/Systemadministration.
Teil II — Sprachmodelle lokal ausführen, fortgeschrittene KI-Tools (Kap. 9–13) geht weiter: lokale LLM-Ausführung (GPT4All, Ollama, Continue, Tabby), die OpenAI-/Ollama-/Groq-APIs zur automatisierten Code-Verarbeitung, Level-3-Tools (OpenHands, Aider) als autonome Coding-Agenten, Retrieval Augmented Generation und Text-to-SQL mit LlamaIndex, sowie eine abschließende Risiko- und Ausblicks-Diskussion.
Meine Bewertung
Diese Rezension entsteht im Mai 2026, gut ein Jahr nach Erscheinen. Bei einem Thema, das sich monatlich neu erfindet, ist das ein strenger Maßstab. Vieles von dem, was dem Buch heute fehlt, war zur Drucklegung schlicht nicht in Reichweite — Claude Code etwa, das mittlerweile den Coding-Alltag vieler Entwickler bestimmt, erschien erst im Februar 2025.
Trotzdem bleibt eine zentrale Kritik bestehen: Das Buch zeigt durchgängig nur ein Schema — Prompt formulieren, Output verwenden. KI-Agenten, die selbstständig Code ausführen, deployen, den Browser steuern, Screenshots machen, debuggen und fixen, kommen nicht vor. Aider und OpenHands werden in Kapitel 11 als Level-3-Tools behandelt; das waren bei Drucklegung die seriösen freien Coding-Agenten. Damit fehlt dem Buch in der Rückschau aber genau die Dimension, die heute den Praxis-Unterschied macht.
Zweiter wiederkehrender Punkt: Die Beispiele sind durchgängig Mini-Projekte — Passwortgenerator, IBAN-Validierung, Quiz, Sudoku-Solver, einzelne Scripts, kleine SQL-Schemata. Das hat seinen Grund: ChatGPT, GitHub Copilot & Co. waren 2024 in genau diesem Sweet-Spot stark. Die Grenzen bei großen Codebasen werden mehrfach genannt — als Token-Limit der APIs (Kap. 10), als Warnung gegen das Anfüttern ganzer Projekte ins Kontextfenster (Kap. 11), und als „Frage der Wartbarkeit" in einem eigenen kurzen Abschnitt im Risiko-Kapitel (Kap. 13.1). Letzteres trifft den Schmerzpunkt vieler KI-Coding-Anwender präzise:
„Mit KI-Tools können Sie sehr schnell sehr viel Zeilen Code produzieren. Ihre so gemessene Produktivität wird großartig sein, Ihre Chefin wird Sie loben. Wer aber wartet diesen Code? Wer behebt einen Fehler, der nur unter recht speziellen Umständen auftritt und das erste Mal nach drei Monaten entdeckt wird?" (Kap. 13.1)
Ein scharfer Befund — der dann aber in zwei Absätzen abgehandelt wird, statt zum Leitmotiv des Buchs zu werden. Osmani hat aus dem gleichen Problem das „70-%-Problem" als Vokabel gebaut und ein ganzes Kapitel daraus gemacht: KI bringt einen 70 % des Wegs zur Lösung, die restlichen 30 % musste man damals noch selbst coden.
Das ist heute nicht mehr so: KI liefert in der Regel funktionierenden Code; ob dieser professionellen Ansprüchen (Sicherheit, Wartbarkeit, …) genügt, ist das Problem von heute.
Methodisch wirken viele Kapitel unsystematisch — viele Beispiel-Prompts, aber keine durchziehende Methodik. Refactoring (Kap. 4) ist mit knapp 18 Seiten, davon viele Code-Seiten, zu dünn. Das Einführungskapitel hat einen Stilbruch: nach praxisorientiertem Start folgt unvermittelt ein LLM-Grundlagen-Abschnitt von neuronalen Netzen aus.
Substanz hat das Buch dort, wo es nüchtern und technisch arbeitet. Kapitel 8 (Scripting und Systemadministration) thematisiert eine Domäne, die formell kein Coding-Thema ist. Kapitel 9 (lokale Sprachmodelle) ist ebenfalls solide gemacht — wobei genau hier das Buch sein eigenes Cover-Versprechen relativiert: lokale LLMs spielen in der produktiven Softwareentwicklung praktisch keine Rolle, weil die Qualität dafür noch nicht reicht.
Cover-seitig wird mehr versprochen, als geliefert wird: Prompt Engineering wird angerissen, nicht systematisch behandelt. Retrieval Augmented Generation, ebenfalls auf dem Cover, wäre ein eigenes Buch wert und wird hier knapp am viel-falter durchgespielt — dem Schmetterlings-Monitoring-Projekt, das dem Buch als durchgängiges Anwendungsbeispiel dient.
Andere Stimmen
Die Amazon-Rezeption zum Buch fällt überwiegend wohlwollend aus — und damit auseinander mit dem Urteil dieser Rezension. Zwei Punkte erklären die Diskrepanz: zum einen der zeitliche Versatz (Drucklegung 2024, hier besprochen 2026), zum anderen das Anwendungsprofil. Wer „Coding mit KI" als Einstieg ins Thema liest und KI-Hilfe primär für überschaubare Coding-Aufgaben einsetzt, findet hier viele brauchbare Beispiele und eine ehrliche Begleitung. Wer KI-Tools im größeren Software-Engineering einsetzen will und einen Agenten-Workflow erwartet, wird das Buch eher als limitiert empfinden.
Gesamteindruck
Das Buch deckt sein Thema solide ab. Für den Stand der Erstellung (Vorwort Herbst/Winter 2024, erschienen 2025) ist das ein brauchbarer Überblick — die positive Amazon-Resonanz spiegelt das.
Heute (Mai 2026) ist es trotzdem nicht mehr erste Empfehlung. Das Buch ist insgesamt zu unstrukturiert — überwiegend Beispiele aus diversen Teilgebieten der Programmierung, ohne durchziehende Methodik. Es fehlt der Agenten-Workflow, der im praktischen Einsatz heute den Unterschied macht.
Wünschenswert wäre ein Buch, das das Phänomen KI + Softwareentwicklung systematisch behandelt — denn es gibt Probleme und Prinzipien, die die schnelle technologische Entwicklung überdauern. Die Wartbarkeits-Frage aus Kapitel 13.1 gehört genau dorthin.
Kapitel für Kapitel
Kapitel 1: Einführung
Erste Einführung in den Umgang mit KI-Tools beim Programmieren. Stellt Chat-basierte Werkzeuge (ChatGPT, Claude, Gemini) und Code-Assistenten (GitHub Copilot) gegenüber, behandelt die Grundlagen des Prompting und schließt mit einer Erläuterung, wie Large Language Models hinter den Kulissen funktionieren.
Mein Kommentar: Nicht schlecht — die Tools (ChatGPT, Copilot u.a.) werden vorgestellt, mir aber zu detailliert: Screenshots fast eine Drittel-Buchseite, Shortcut-Tabellen, das brauche ich nicht. Was mich wundert: Nach dem praxisorientierten Start kommt am Ende plötzlich ein Unterkapitel „Grundlagen von Large Language Models", das ganz vorne bei neuronalen Netzwerken beginnt — Stilbruch im Kapitel. Was mir gefallen hat: Abbildung 1 zeigt den Hype-Zyklus bei der Nutzung von KI-Tools. Das deckt sich mit meinem eigenen Erleben: 2025 bin ich vom Gipfel der überzogenen Erwartungen über das Tal der Enttäuschung auf den Pfad der Erleuchtung gekommen. 2026 stehe ich wieder auf einem Gipfel der Erwartungen — diesmal werden sie aber tatsächlich erfüllt.
Kapitel 2: Pair Programming
KI-gestütztes Pair Programming als Lernhilfe für Einsteiger: Code in Funktionen strukturieren, objektorientiert programmieren, drei durchgängige Beispiele (IBAN-Validierung, Quiz, Sudoku-Solver). Empfehlung: Chat-System statt Code-Assistent beim Lernen.
Mein Kommentar: Der Titel ist irreführend — die Autoren positionieren das Kapitel auf S. 63 explizit an Programmier-Lernende, das ist also kein Pair-Programming-Kapitel im klassischen Sinn. Es werden viele Prompt-Beispiele in Python und Java gegeben, eine Systematik kann ich darin nicht erkennen. Die Prompts werden alle auf Englisch formuliert. Anfangs erzielte man mit englischen Prompts bessere Ergebnisse, mittlerweile sind die LLMs so gut, dass die Sprache kaum noch eine Rolle spielt.
Kapitel 3: Debugging
Fehlersuche mit KI-Unterstützung in verschiedenen Umgebungen — Web-Applikationen, App-Entwicklung, Raspberry Pi, Visual Studio / VS Code. Vergleich zur Rubber-Duck-Methode: die KI als aktive Gesprächspartnerin bei der Fehleranalyse.
Mein Kommentar: Auch hier keine Systematik. Verschiedene Fehlermöglichkeiten werden aufgezählt und gezeigt, wie man sie mit LLMs behebt — in der Regel: fehlerhaften Code in den Prompt setzen, mit der Bitte um Fix. In Sektion 3.4 wird auf nur drei Seiten erwähnt, dass Sprachmodelle in IDEs wie Visual Studio und VS Code integriert sind. Was abschließend fehlt: Heute gibt es Coding-Agenten, die selbstständig Code ausführen, deployen, den Browser steuern, Screenshots machen, debuggen und fixen. Das zeigt das Buch nicht — eben veraltet.
Kapitel 4: Refactoring
Refactoring-Theorie (Lesbarkeit, Wartbarkeit, Code-Smells) und praktische Refactoring-Strategien mit KI-Werkzeugen. Empfehlung: Kombination aus statischer Codeanalyse (z.B. SonarQube) für den Überblick und KI-Tools für die Detail-Arbeit. Best Practices und Fazit.
Mein Kommentar: Das Kapitel ist sehr dünn (S. 127–145, knapp 18 Seiten), und viele dieser Seiten sind komplett mit Code gefüllt, so dass inhaltlich nicht viel übrig bleibt. Auf den ersten Seiten werden Code-Smells vorgestellt. Letztendlich ist der Anteil, der von KI durchgeführt werden soll, sehr gering. Das Kapitel finde ich sehr schwach.
Kapitel 5: Software testen
KI-Unterstützung in allen Phasen des Software-Testings: Testdaten-Generierung, Testautomatisierung, testgetriebene Entwicklung, Umgang mit Abhängigkeiten, Test-Optimierung und End-to-End-Tests. Plus die Warnung: KI-generierte Tests immer überprüfen.
Mein Kommentar: Auch hier ist der Einsatz der KI hauptsächlich: man erstellt einen Prompt und arbeitet so mit der KI. Das ist das generelle Problem des Buches — auch in diesem Kapitel —, dass nicht mit KI-Agenten wie Claude Code gearbeitet wird. Deswegen ist die Nutzung der KI noch sehr eingeschränkt und umständlich.
Kapitel 6: Software dokumentieren
Code-nahe Dokumentationsformen: Inline-Kommentare, Funktions- und Klassen-Dokumentation, API-Dokumentation. Wie man veraltete Dokumentation aufspürt und mit KI aktualisiert.
Mein Kommentar: In diesem Kapitel konnte ich für mich wenig mitnehmen. Im Wesentlichen bittet man im Prompt das Sprachmodell, etwas zu kommentieren — mehr nicht.
Kapitel 7: Datenbanken
Anwendung von KI-Tools im Datenbank-Umfeld: Datenbankdesign, SQL-Kommandos zusammenstellen, Administrations-Aufgaben und Client-Programmierung. Tipp: DBMS-Variante (PostgreSQL, MySQL, SQL Server etc.) immer im Prompt nennen, sonst bekommt man Antworten am eigenen System vorbei.
Mein Kommentar: Wieder wird an vielen Beispielen gezeigt, wie man ein Sprachmodell für Datenbank-Programmierung nutzt. In der Regel verläuft das so: Im Prompt wird eine Datenbank-Aufgabe in natürlicher Sprache gestellt, das Sprachmodell spuckt die entsprechende SQL-Syntax aus. Im Buch ist das immer das gleiche Schema — eine Aufgabe wird als Prompt formuliert, man nimmt den Output. Alles unsystematisch anhand von Beispielen. Letztendlich brauche ich dafür dieses Buch nicht.
Kapitel 8: Scripting und Systemadministration
Sammlung von Beispielen, in denen KI-Tools (ChatGPT, Copilot) bei Scripting (Bash, Python, PowerShell), regulären Ausdrücken und Systemadministration helfen. Beobachtung der Autoren: deutlich schwächere Ergebnisse bei PowerShell als bei Bash und Python.
Mein Kommentar: Die Autoren weisen zurecht darauf hin, dass Systemadministration eigentlich kein klassisches Coding-Thema ist. Ich finde das gut. Persönlich profitiere ich stark davon, dass Sprachmodelle auch sehr gut darin sind, Systeme zu administrieren — ich selbst bin nicht in der Lage, Softwareprojekte auf Servern zu deployen, aber dank Sprachmodellen und KI-Agenten kann ich das mittlerweile sehr souverän bewerkstelligen. Insofern finde ich das Thema sehr gut. Wieder die gleiche Kritik wie überall: im Buch werden nur Prompts in ein LLM eingegeben, mit dem Output wird dann irgendwas gemacht.
Kapitel 9: Sprachmodelle lokal ausführen
Wechsel von Cloud-LLMs zu lokal ausgeführten Modellen. Installation und Anwendung von GPT4All und Ollama, Open WebUI als Browser-Frontend, das Continue-Plugin als Copilot-Alternative, die Ollama-API für eigene Programme, Tabby als integrierte Server-Editor-Lösung.
Mein Kommentar: Inhaltlich finde ich das Kapitel gut — die Installation lokaler Sprachmodelle wird relativ detailliert beschrieben. Was ich allerdings kritisieren muss: Das Buch verspricht, ein Praxisbuch für die Softwareentwicklung zu sein. Lokale Sprachmodelle haben damals und auch heute keine Auswirkung auf die Softwareentwicklung — die Qualität dieser Modelle ist einfach noch zu schlecht.
Kapitel 10: Code automatisiert verarbeiten
Crashkurs für die OpenAI-, Ollama- und Groq-APIs. Auf dieser Basis Beispiel-Scripts, die Prompts auf ganze Verzeichnisse anwenden — z.B. automatisierte Code-Kommentierung oder Python-2-zu-3-Migration. Realitäts-Check der Autoren: machbar, aber bei keinem Test wirklich großartig.
Mein Kommentar: In diesem Kapitel geht es darum, wie man die APIs der Sprachmodelle nutzt. Wieder an zahlreichen Beispielen demonstriert.
Kapitel 11: Level-3-Tools — OpenHands und Aider
Stellt zwei autonome Coding-Tools vor, die High-Level-Aufträge in mehreren Schritten selbständig ausführen. Einordnung der KI-Autonomie in fünf Level (Code-Completion → Full Autonomy). Praxis-Erfahrungen mit OpenHands und Aider — viel Potenzial, aber alles andere als perfekt.
Mein Kommentar: Zu dem Kapitel kann ich ehrlich gesagt nicht viel sagen — hier hätte es eigentlich spannend werden können. Aber die wirklich relevanten Agentensysteme wie Claude Code (Anthropic, Februar 2025) kamen erst nach Drucklegung dieses Buches.
Kapitel 12: Retrieval Augmented Generation (RAG) und Text-to-SQL
Anwendungsentwicklung am durchgängigen Beispiel des viel-falter-Projekts (Schmetterlings-Monitoring der Uni Innsbruck, betreut von Bernd Öggl). Zwei Techniken am gleichen Datenbestand: RAG für die PDFs/Webseiten des Projekts (Embedding-Modell, Vector-Store, Anfragen via LlamaIndex/Python), Text-to-SQL für die Schmetterlings-Datenbank (Mongo-Export nach SQLite, LLM bekommt Tabellen-Struktur als Kontext und formuliert SQL aus deutscher Frage). Verbindendes Motiv: einen schlummernden Datenschatz per natürlicher Sprache durchsuchbar machen.
Mein Kommentar: … (noch zu ergänzen)
Kapitel 13: Risiken und Ausblick
Zusammenfassende Risiko-Diskussion: veralteter Code aus alten Trainingsdaten, Wartbarkeits-Probleme, Datenschutz, beispielhaftes KI-Versagen aus der Praxis der Autoren. Ethische Fragen. Schluss-Thesen: KI-Tools sind im Coding-Alltag etabliert, Anwendung nur im Rahmen eigenen Wissens, Fehler passieren weiter, Chancen nutzen statt fürchten. Claude Code oder andere Anfang-2025-Tools werden nicht erwähnt — das Buch endet im Stand von Mitte 2024.
Mein Kommentar: … (Kapitel noch nicht zu Ende gelesen.)
Kommentare
Noch keine Kommentare. Schreib den ersten.
Melde dich an, um zu kommentieren.