31.10.2019
Von Peter Hecker, Inhaber von HECKER CONSULTINGKleine Pull Requests, Checklisten, guter Ton, Linter und Tests in der CI: So werden Code-Reviews wirksam. Dazu die Grenzen von KI-Reviews wie Copilot.

Freitagnachmittag, kurz vor Feierabend: Im Postfach liegt ein Pull Request mit 1.800 geänderten Zeilen, dazu die Bitte um „einen kurzen Blick“. Was folgt, kennt fast jedes Entwicklungsteam. Jemand scrollt durch, findet zwei Tippfehler in Variablennamen, schreibt „Sieht gut aus“ und klickt auf Freigeben. Formal hat ein Review stattgefunden. Tatsächlich hat niemand den Code verstanden.
Code-Reviews gehören heute in fast jedem Softwareteam zum Alltag. Bevor eine Änderung in den Hauptzweig des Projekts übernommen wird, liest mindestens eine zweite Person sie gegen. Das klingt nach Kontrolle, ist im besten Fall aber etwas anderes: ein Gespräch über Code, bei dem Fehler auffallen, Wissen im Team verteilt wird und die Software auf Dauer verständlich bleibt. Ob das gelingt, hängt weniger vom Werkzeug ab als von ein paar Gewohnheiten. Und seit KI-Assistenten selbst Code schreiben und Reviews kommentieren, sind neue Fragen hinzugekommen.
Ein Review hat mehrere Ziele, und es hilft, sie im Team ausdrücklich zu benennen. Erstens sollen Fehler auffallen, bevor sie bei Kundinnen und Kunden ankommen: falsche Logik, vergessene Sonderfälle, Sicherheitslücken. Zweitens soll der Code verständlich und wartbar bleiben – auch für Menschen, die ihn in zwei Jahren ändern müssen. Drittens verteilt ein Review Wissen: Wer den Code einer Kollegin liest, weiß danach, wie dieser Teil der Anwendung funktioniert. Fällt jemand aus, steht das Team nicht ohne Wissen da.
Was ein Review nicht leisten sollte: Tests ersetzen, Formatierungsfragen klären oder eine Architekturentscheidung nachholen, die eigentlich vor der ersten Codezeile hätte fallen müssen. Wer im Review grundsätzlich über den Lösungsansatz streitet, hat das Gespräch zu spät begonnen. Größere Vorhaben sollten deshalb vorher kurz skizziert und abgestimmt werden.
Auf Plattformen wie GitHub heißt der Vorschlag einer Änderung Pull Request, bei GitLab Merge Request. Gemeint ist dasselbe: Eine Entwicklerin bittet darum, ihre Änderungen in den gemeinsamen Code zu übernehmen, und andere kommentieren Zeile für Zeile.
Der wirksamste Tipp für bessere Reviews setzt vor dem Review an: kleine Pull Requests. Eine oft zitierte Faustregel lautet, nicht mehr als etwa 400 Zeilen am Stück und nicht länger als rund 60 Minuten zu prüfen, weil danach die Aufmerksamkeit spürbar nachlässt. Die genauen Zahlen sind weniger wichtig als die Richtung. Eine Änderung, die eine Sache erledigt, lässt sich in einer Viertelstunde gründlich prüfen. Ein Paket aus Umbau, neuer Funktion und Aufräumarbeiten dagegen lädt zum Durchwinken ein.
Ebenso wichtig ist die Beschreibung. Ein guter Pull Request erklärt in wenigen Sätzen, was sich ändert, warum, und wie man es ausprobieren kann. Verweist er auf die zugehörige Anforderung, etwa eine User Story mit Akzeptanzkriterien, kann die Reviewerin prüfen, ob der Code tatsächlich das Gewünschte tut. Wie solche Anforderungen aussehen sollten, beschreibt der Beitrag über User Stories und ihre Akzeptanzkriterien.
Ohne gemeinsame Kriterien prüft jede Person nach eigenem Geschmack. Die eine achtet auf Namen, der andere auf Performance, die dritte auf gar nichts Bestimmtes. Eine kurze Checkliste schafft Verlässlichkeit. Sie sollte auf eine Bildschirmseite passen und zum Projekt passen, etwa so:
Die Checkliste gehört idealerweise direkt in die Vorlage für neue Pull Requests. So sieht die Autorin schon beim Erstellen, worauf später geachtet wird – und erledigt vieles selbst.
Code-Reviews sind auch ein soziales Ritual. Ein Kommentar wie „Das ist falsch“ landet bei der Empfängerin anders als „Was passiert hier, wenn die Liste leer ist?“. Die Frage führt zum selben Ergebnis, lässt aber Raum für Gründe, die der Reviewer vielleicht nicht kennt. Einige Gewohnheiten haben sich bewährt:
Wichtig ist auch die Gegenseitigkeit. Wenn Berufseinsteiger ebenso den Code der erfahrenen Kolleginnen prüfen, lernen sie am schnellsten – und die Erfahrenen bekommen ehrliche Rückfragen zu Stellen, die sie selbst für selbstverständlich halten.
Vieles, worüber in Reviews früher gestritten wurde, gehört heute in die Pipeline. Gemeint ist die Continuous Integration (CI), also die automatische Prüfung, die bei jeder Änderung anläuft. Sie übernimmt drei Aufgaben zuverlässiger als jeder Mensch:
Diese Reihenfolge spart Zeit und Nerven: Menschen konzentrieren sich auf Logik, Verständlichkeit und Design, die Maschine auf das Mechanische. Wie Tests mit KI-Unterstützung entstehen und wo dabei Vorsicht geboten ist, zeigt das Seminar Software-Tests mit ChatGPT und Copilot.
Seit einiger Zeit können KI-Assistenten Pull Requests selbst kommentieren. Bei GitHub lässt sich Copilot als Reviewer anfordern; der Assistent fasst die Änderung zusammen und hinterlässt Hinweise zu einzelnen Zeilen. Auch GitLab und spezialisierte Anbieter haben vergleichbare Funktionen im Programm.
In der Praxis sind solche KI-Reviews nützlich für eine erste Durchsicht: Sie finden vergessene Fehlerbehandlungen, Tippfehler in Bedingungen, unklare Namen und manchmal echte Logikfehler. Für die Autorin eines Pull Requests sind sie eine gute Selbstkontrolle, bevor ein Mensch Zeit investiert.
Die Grenzen sind allerdings deutlich. Ein KI-Reviewer kennt meist nur den sichtbaren Ausschnitt, nicht die Absprachen im Team, die fachlichen Regeln oder den Grund, warum eine Lösung bewusst anders gebaut wurde. Er formuliert falsche Hinweise ebenso überzeugt wie richtige und übersieht, was eine erfahrene Kollegin sofort bemerken würde. Bei GitHub zählt ein Copilot-Review standardmäßig auch nicht als Freigabe. Meine Einschätzung: KI-Reviews sind ein guter Filter vor dem eigentlichen Review, aber kein Ersatz dafür. Die Entscheidung, ob Code in das Produkt kommt, trifft ein Mensch, der ihn verstanden hat.
Die zweite Veränderung betrifft die andere Seite: Immer mehr Code, der zur Prüfung vorgelegt wird, stammt ganz oder teilweise von einem KI-Assistenten. Solcher Code sieht oft sauber aus, ist ordentlich formatiert und kommentiert. Gerade das verführt dazu, ihn weniger kritisch zu lesen.
Typische Schwachstellen sind erfundene Funktionen oder Bibliotheken, veraltete Schnittstellen, übersehene Sonderfälle, Tests, die nur prüfen, was der Code ohnehin tut, und Sicherheitsmuster aus alten Lehrbuchbeispielen. Zudem wachsen Pull Requests mit KI-Hilfe schnell auf eine Größe, die kein Mensch mehr sorgfältig prüfen kann. Drei Regeln helfen:
Welche Spielregeln sich für den Einsatz von KI-Assistenten im Team bewährt haben, beschreibt der Beitrag Copilot-Chaos oder Code-Kontrolle: 4 Regeln für den Einsatz von KI-Assistenten. Wie sich KI-Werkzeuge sinnvoll in den gesamten Entwicklungsablauf einfügen, ist Thema des Seminars Moderne KI-Entwicklungsprozesse mit intelligenten Assistenten.
Gute Code-Reviews sind keine Frage teurer Werkzeuge, sondern von Vereinbarungen. Für die meisten Teams lohnt sich ein kleiner Satz an Regeln: Pull Requests klein halten und gut beschreiben, eine kurze gemeinsame Checkliste nutzen, alles Mechanische der CI überlassen, freundlich und begründet kommentieren und Reviews zeitnah erledigen, damit niemand tagelang wartet. KI-Reviewer können diesen Ablauf beschleunigen, wenn sie als erster Filter dienen. Überschätzt wird dagegen die Idee, KI könne das Review ganz übernehmen – gerade weil immer mehr Code maschinell entsteht, wird das menschliche Verständnis wichtiger, nicht unwichtiger.
Code-Reviews sind dabei nur ein Baustein. Welche Gewohnheiten Softwareprojekte insgesamt erfolgreicher machen, von klaren Zielen bis zum Umgang mit technischen Schulden, fasst der Beitrag Praktische Tipps für bessere Software-Projekte zusammen. Weitere Seminare rund um Entwurf, Qualität und Architektur finden Sie im Themenbereich Software Engineering.
In den meisten Teams reicht eine sorgfältige Freigabe. Bei sicherheitskritischen Teilen, zentralen Schnittstellen oder Datenbankänderungen ist eine zweite Person sinnvoll, idealerweise jemand mit Überblick über die Architektur.
Viele Teams vereinbaren, Reviews innerhalb eines Arbeitstags zu beginnen. Lange Wartezeiten führen dazu, dass Entwickler mehrere Änderungen parallel anfangen – das macht die nächsten Pull Requests größer und die Reviews schlechter.
Teilweise. Wer zu zweit programmiert, prüft den Code bereits beim Entstehen. Viele Teams verzichten dann auf ein ausführliches Review und lassen nur noch die automatischen Prüfungen laufen. Für Änderungen mit großer Tragweite bleibt ein frischer Blick von außen trotzdem nützlich.
Technisch ist das möglich: Bei GitHub können Administratoren seit Herbst 2026 einschalten, dass eine Copilot-Freigabe als erforderliche Freigabe zählt, auf Wunsch beschränkt auf bestimmte Pfade. Sinnvoll ist das höchstens in engen Grenzen. Ein KI-Hinweis kann ein Review vorbereiten, die Freigabe sollte bei einer Person liegen, die den Code versteht und für ihn einsteht.
Wir erweitern ständig unser Beratungsportfolio. Über 600 Beratungsleistungen haben wir für Sie im Programm. Selbstverständlich lassen sich die einzelnen Themen kombinieren. So erhalten Sie genau die Beratung, die Sie wünschen und brauchen.
Mehr IT-, Online-, Digital-Beratungsleistungen anzeigen >>Moderne KI-Entwicklungsprozesse für die eigene Arbeit: Sie ordnen Aufgaben zwischen sich und intelligenten Assistenten neu, erweitern Ihre Werkzeuge mit MCP und Skills, koordinieren mehrere Agenten und sichern das Ergebnis ab.
Software Tests mit ChatGPT und GitHub Copilot: Sie leiten Testfälle aus Anforderungen ab, automatisieren Unit-, API- und UI-Tests mit Playwright, erzeugen Testdaten und Berichte – und prüfen per Mutationstest, ob die Tests Fehler wirklich finden.
Sie klären Kontext und Stakeholder, finden mit Double Diamond, Ishikawa und 5-Why die eigentlichen Ursachen und entscheiden begründet, welche Lösung in die Anforderungen eingeht.
Sie formulieren Anforderungen nach Schablone, beseitigen Mehrdeutigkeiten und liefern eine Anforderungsdokumentation, mit der Fachbereich, Entwicklung, Test und Coding-Agenten ohne Rätselraten arbeiten können.
Full-Stack-Webentwicklung mit KI an einem durchgehenden Projekt: vom Wireframe über Frontend, API und Datenbank bis zu Tests, Pipeline, Deployment und Dokumentation – jeder Schritt mit passenden Werkzeugen und überprüfbarem Ergebnis.
Sie beschreiben APIs kompakt in TypeSpec, erzeugen daraus OpenAPI 3, JSON Schema und Protobuf und setzen einheitliche API-Richtlinien über wiederverwendbare Bibliotheken und Linter durch.
Sie bauen in Go, Rust und TypeScript je einen kleinen Prototyp, messen Performance, Speicher und Entwicklungstempo und verlassen den Workshop mit einer begründeten Entscheidungsvorlage samt Bewertungsmatrix für Ihre Backend-Sprache.
Sie lernen die Grundlagen, nach denen moderne Software-Anwendungen aufgebaut sind – vom Python-Skript über die Full-Stack-Anwendung bis zur Cloud – und begründen Architekturentscheidungen nachvollziehbar.
Sie verankern Sicherheit in jeder Phase der Entwicklung – mit Bedrohungsmodellen im Entwurf, sicheren Mustern im Code, SAST und DAST in der Pipeline und einer SBOM für jede Auslieferung.
Wo die Grenze zwischen zwei Services verläuft, wann ein Event besser ist als ein Aufruf und welche Kompromisse bei Daten, Latenz und Betrieb dazugehören – danach entscheiden Sie begründet, ob Microservices zu Ihrem System passen.
Sie erkennen und beheben die häufigsten Schwachstellen in Webanwendungen und APIs nach den OWASP Top 10 – von fehlerhafter Zugriffskontrolle über Injection bis zu unsicherem Design und neuen Risiken durch Lieferketten und LLM-Funktionen.
Sie wenden die fünf SOLID-Prinzipien und die GRASP-Muster an Python-Code mit Typ-Hinweisen und Protocols an, erkennen Verstöße im Code-Review und machen Klassen leichter erweiterbar und testbar.
Sie verstehen, warum große native iOS- und Android-Apps anders gebaut, getestet und betrieben werden als Webanwendungen, und kennen bewährte Lösungen für Releases, Architektur, Teams und Betrieb.
Sie entwerfen Dienstverträge mit Protocol Buffers, bauen Java-Microservices mit gRPC über HTTP/2 – unär und mit Streaming – und sichern sie mit Deadlines, TLS, Tests und Tracing ab, pur oder mit Spring Boot und Quarkus.
Sie zerlegen einen gewachsenen Monolithen Schritt für Schritt in Microservices – mit klarem Ziel, sauberem Service-Schnitt, Migration im laufenden Betrieb und einem Team, das die neue Architektur auch betreiben kann.
Sie analysieren gewachsene COBOL-Programme, sichern ihr Verhalten mit Tests ab, refaktorisieren sie schrittweise und wählen eine Migrationsstrategie, die Fachlogik und Daten nicht unterwegs verliert.
Sie automatisieren Webanwendungen mit Selenium WebDriver, wählen robuste Locators, lösen Synchronisationsprobleme mit expliziten Wartezeiten und bringen Ihre Testsuite mit Page Objects und Selenium Grid in die CI-Pipeline.
Sie führen ein kleines Produkt in drei Sprints von der Problemaussage über geprüfte Anforderungen, Proof of Concept und Modelle bis zum Release 1.0 – und halten jede Entwurfsentscheidung nachvollziehbar fest.
Aktuelle und interessante Themen und Beiträge für Sie zusammengetragen und aufbereitet.
COBOL steckt hinter Überweisungen, Versicherungen und Renten. Wie der Alltag von COBOL-Programmierern aussieht, was Entwickler verdienen, welche Rolle KI bei der Modernisierung spielt und für wen sich der Einstieg lohnt.
Domain Storytelling macht Fachwissen sichtbar: Fachleute erzählen einen konkreten Ablauf, der live als Bild aus Akteuren, Arbeitsgegenständen und Aktivitäten entsteht. Sie erfahren, wie ein Workshop abläuft und welche Werkzeuge helfen.
WinForms, WPF, UWP, WinUI 3, MAUI, Avalonia, Uno und Blazor: Was die .NET-Oberflächentechniken können, wo ihre Grenzen liegen und welches Framework wofür passt – mit Entscheidungshilfe und Blick auf Web, Flutter und React Native.
Rust gilt als schnell, sicher und schwer zu lernen. Sie erfahren, was Ownership, Borrowing, Lifetimes, Traits und Cargo bedeuten, wer Rust einsetzt und wie Sie mit offiziellen Werkzeugen, Forschungstools und KI-Assistenten den Einstieg schaffen.
Systematische Problemanalyse ist der Schlüssel zu erfolgreichem Requirements Engineering. Dieser Artikel zeigt Ihnen bewährte Methoden und Techniken zur Problemidentifikation, -analyse und Lösungsentwicklung. Erfahren Sie, wie der Double-Diamond-Prozess Ihre Anforderungsanalyse verbessert und warum iteratives Vorgehen entscheidend für den Projekterfolg ist.
Anforderungsmanagement entscheidet, ob ein Projekt liefert, was gebraucht wird. Lernen Sie Prozess, bewährte Methoden zum Ermitteln, Beschreiben und Priorisieren, agiles Vorgehen und passende Werkzeuge kennen.
Was DDD in der Softwareentwicklung bedeutet, wann es sich lohnt und wie Bounded Contexts, Aggregate und Event Storming zusammenhängen – verständlich für Entwickler, Architekten und Fachleute, die zum ersten Workshop eingeladen sind.
Was Software über Jahre wartbar hält: Modularität, saubere Schnittstellen, die Wahl zwischen Monolith und Microservices, ADR und arc42, der Umgang mit technischen Schulden und KI-Komponenten als austauschbare Bausteine.
Ein Modell im Notebook ist noch kein Produkt. Welche Regeln, Tests und Werkzeuge Data-Science-Teams brauchen, damit Modelle nachvollziehbar, reproduzierbar und im Betrieb verlässlich bleiben – mit Beispielen in Python.
Softwareprojekte scheitern selten an der Technik, sondern an unklaren Zielen, späten Rückmeldungen und fehlender Qualität. Welche Gewohnheiten helfen – von kleinen Inkrementen über Tests und ehrliche Schätzungen bis zu KI-Assistenten.
Warum brauchen Sie einen Prototypen? Haben Sie zufällig eine Menge Ideen und Anforderungen von Kunden, wenn es um das Projekt geht? Wenn ja, dann ist ggf. die Entwicklung eines Prototypen eine geeignete Methode diese Ideen und Anforderungen zu überprüfen. Ein Prototyp ist etwas, das die meisten Menschen mit materiellen Produkten assoziieren, nicht unbedingt mit mobilen oder Web-Anwendungen. In der IT-Branche - und insbesondere in modernen Softwarehäusern - wird der Prototyp jedoch sehr häufig im Softwareentwicklungsprozess eingesetzt. Zunehmend ist er auch ein Schlüsselelement im Prozess der Vertragsabschlüsse.
Gute User Stories brauchen Zeit: eine konkrete Rolle, einen ehrlichen Nutzen und prüfbare Akzeptanzkriterien. Wie Sie Stories nach INVEST schreiben, sinnvoll teilen, mit Story Mapping ordnen und KI dabei mit Bedacht nutzen.
Start-ups sind aus unserer Gegenwart nicht mehr wegzudenken. Immer mehr davon sind Unternehmen, die mit IT zu tun haben. Doch wir kennen nur die, die erfolgreich waren. Von denen, die gescheitert sind, hat noch nie jemand etwas gehört. Manchmal war ihr Scheitern mit überbewerteten Plänen verbunden, ein anderes Mal scheiterten sie, weil sie sich darauf konzentrierten, sofort etwas Neues zu schaffen, ohne einen richtigen langfristigen Ansatz zu verfolgen.