Review unter neuen Vorzeichen

Generierten Code prüfen, ohne alles neu zu schreiben

Die Fehler sitzen woanders als bei handgeschriebenem Code. Wer weiß, wo sie sitzen, spart im Review Zeit und findet trotzdem deutlich mehr als vorher.

KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt
Seit 1997 am Markt Kleine Gruppen Präsenz und Live-Online Zertifizierte Trainer
Worum es geht

Mehr Code in weniger Zeit verschiebt den Engpass ins Review

Der Vorschlag entsteht in Sekunden, die Prüfung dauert genauso lange wie vorher. In Teams, die Assistenten ernsthaft nutzen, wächst deshalb zuerst die Warteschlange offener Pull Requests, und danach sinkt die Gründlichkeit, mit der jeder einzelne gelesen wird. Der Produktivitätsgewinn kippt an dieser Stelle, ohne dass es jemand kommen sieht.

Dazu kommt eine Eigenheit der Fehler. Handgeschriebener Code scheitert oft laut und früh, weil jemand einen Gedanken nicht zu Ende gebracht hat. Generierter Code ist syntaktisch sauber, ordentlich formatiert und benannt wie guter Code, und trägt trotzdem eine Annahme in sich, die niemand geprüft hat. Er sieht damit vertrauenswürdiger aus, als er ist.

Wenn das Team dann noch die Tests aus derselben Quelle bezieht, schließt sich der Kreis. Der Code tut, was die Tests erwarten, die Tests erwarten, was der Code tut, und die Pipeline ist grün.

KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt
Schritt für Schritt

Schritt für Schritt

  1. 1

    Generierte Anteile im Pull Request vermerken

    Schreib in die Beschreibung, welche Teile aus einem Vorschlag stammen. Das lenkt die Aufmerksamkeit im Review, ohne den Quelltext mit Kommentaren zu belasten.

    Geschafft, wenn: das Review weiß von Anfang an, wo es genauer hinsehen muss

  2. 2

    Neue Abhängigkeiten einzeln nachschlagen

    Prüf für jeden neuen Import, ob das Paket existiert, seit wann es veröffentlicht wird, wer es pflegt und ob es für diese Aufgabe angemessen ist.

    Geschafft, wenn: kein erfundener oder frisch untergeschobener Paketname passiert das Review

  3. 3

    Maschinelle Prüfungen als Pflichtschritt schalten

    Linter, Typprüfung, statische Analyse, Abgleich gegen eine Schwachstellendatenbank und eine Suche nach Zugangsdaten laufen automatisch, bevor ein Mensch den Diff öffnet.

    Geschafft, wenn: das Review beginnt bei den Stellen, die Urteilsvermögen brauchen

  4. 4

    Fehlerpfade zuerst lesen

    Geh die Stellen durch, an denen etwas schiefgehen kann: leere Rückgaben, abgebrochene Verbindungen, fehlende Felder, unerwartete Größen. Ein pauschales Abfangen aller Ausnahmen ist ein Befund, keine Lösung.

    Geschafft, wenn: jeder Fehlerfall hat eine benannte Behandlung oder eine bewusste Entscheidung dagegen

  5. 5

    Testfälle gegen die Anforderung halten

    Nimm die fachliche Erwartung und prüf jeden Testfall dagegen. Streich Tests, die nur wiederholen, was im Code steht, und ergänz mindestens einen Fall, der bei falscher Logik rot wird.

    Geschafft, wenn: eine grüne Pipeline sagt wieder etwas aus

  6. 6

    Diff klein halten oder teilen

    Setz eine Obergrenze für die Zeilenzahl eines Pull Requests und teil größere Änderungen auf. Die Grenze richtet sich danach, was jemand in einer Sitzung wirklich liest.

    Geschafft, wenn: kein Review endet mit einem Durchwinken aus Erschöpfung

  7. 7

    Verantwortung festhalten

    Wer den Pull Request eröffnet, erklärt auf Nachfrage jede Zeile. Nimm diese Regel in die Beitragsrichtlinien auf, damit sie nicht von der Tagesform abhängt.

    Geschafft, wenn: die Herkunft des Codes ist im Team kein Argument mehr

Sechs Stellen, an denen generierter Code kippt

  1. 01 Ein Import zeigt auf ein Paket, das es so nicht gibt.
  2. 02 Die Bibliotheksversion stammt aus einer alten Aufrufform.
  3. 03 Alle Ausnahmen werden pauschal abgefangen.
  4. 04 Ein Beispielschlüssel aus dem Prompt steht im Code.
  5. 05 Die Tests prüfen den Code statt die Anforderung.
  6. 06 Der Diff ist zu groß, um ernsthaft gelesen zu werden.
Was du mitnimmst

Was du danach im Review anders machst

Nach dieser Seite hast du eine Reihenfolge für das Review und weißt, welche Prüfungen du vollständig an Werkzeuge abgeben kannst.

Importliste zuerst lesen

Jeder neue Import wird in der Registry nachgeschlagen, bevor irgendjemand die Logik bewertet. Alter, Pflege und Herkunft des Pakets entscheiden.

Fehlerpfade vor Erfolgspfad

Du liest zuerst die Stellen, an denen etwas schiefgehen kann, und erkennst pauschales Abfangen von Ausnahmen als das, was es ist.

Tests gegen die Anforderung

Du prüfst jeden Testfall gegen die fachliche Erwartung statt gegen den Code und erkennst Tests, die nur die Implementierung spiegeln.

Maschinen vor Menschen

Linter, Typprüfung, statische Analyse, Abhängigkeitsabgleich und die Suche nach Zugangsdaten laufen als Pflichtschritt, bevor jemand den Diff öffnet.

Diffgröße begrenzen

Du setzt eine Obergrenze, ab der ein Pull Request geteilt wird, weil größere Änderungen faktisch nicht mehr gelesen werden.

Verantwortung klarhalten

Wer den Pull Request eröffnet, erklärt jede Zeile. Die Herkunft des Codes ändert daran nichts, und das Team spricht das offen aus.

KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt

Prüf zuerst die Abhängigkeiten, nicht die Logik

Modelle erzeugen gelegentlich Importe für Pakete, die es unter diesem Namen nicht gibt oder nie gab. Beim Lesen wirkt der Name plausibel, weil er dem Muster echter Pakete folgt. Genau dieses Muster wird ausgenutzt: Wer den halluzinierten Namen in einer öffentlichen Registry anlegt, bekommt Installationen von allen, die den Vorschlag ungeprüft übernommen haben. Der erste Blick im Review gilt deshalb der Importliste, nicht der Funktion.

Die Prüfung selbst ist schnell erledigt. Gibt es das Paket, seit wann, wie viele Veröffentlichungen hat es, wer pflegt es, passt es zu dem, was hier gebraucht wird. Wenn ein neues Paket im Diff auftaucht, das nur eine einzige Hilfsfunktion beisteuert, ist meist die bessere Frage, ob diese zwanzig Zeilen nicht direkt ins Projekt gehören.

Dasselbe gilt für Versionen. Modelle greifen auf Muster aus ihrem Trainingsmaterial zurück, und das kann eine Bibliotheksversion sein, die inzwischen bekannte Schwachstellen hat oder deren Aufrufform sich geändert hat. Ein Abgleich der Abhängigkeiten gegen eine Schwachstellendatenbank gehört als Pflichtschritt in die Pipeline, nicht in den Kopf der Person, die reviewt.

Der Erfolgspfad stimmt fast immer, die Fehlerpfade nicht

Generierter Code beschreibt zuverlässig, was passieren soll, wenn alles gut geht. Was passiert, wenn die Antwort leer ist, die Verbindung abbricht, ein Feld null enthält oder die Datei größer ist als erwartet, bleibt oft unbeantwortet oder wird mit einem pauschalen Abfangen aller Ausnahmen erschlagen, das den Fehler verschluckt. Lies im Review zuerst die Stellen, an denen etwas schiefgehen kann, und erst danach die eigentliche Logik.

Der zweite Blick gilt den Randfällen der Daten: leere Liste, ein einzelnes Element, Sonderzeichen, Zeitzonen, Zahlenformate. Hier liefern Modelle plausible, aber ungeprüfte Annahmen. Wenn im Diff eine Annahme steckt, die nirgends abgesichert ist, gehört an diese Stelle entweder eine Prüfung oder ein Test.

Tests, die nichts beweisen

Wenn dasselbe Modell Code und Tests erzeugt, prüfen die Tests häufig die Implementierung statt die Anforderung. Sie bestätigen, dass die Funktion das tut, was in ihr steht, und laufen deshalb zuverlässig grün, auch wenn die Anforderung von Anfang an falsch verstanden wurde. Das ist gefährlicher als gar kein Test, weil eine grüne Pipeline Sicherheit suggeriert.

Der Ausweg ist unspektakulär, aber wirksam. Formulier die erwarteten Ergebnisse aus der fachlichen Anforderung heraus, bevor du dir Tests erzeugen lässt, und prüf im Review jeden Testfall gegen die Anforderung, nicht gegen den Code. Ein Testfall, der bei falscher Logik nicht rot werden kann, ist keiner.

Werkzeuge zuerst, Menschen danach

Alles, was eine Maschine finden kann, soll eine Maschine finden, bevor ein Mensch den Diff öffnet. Das sind Formatierung und Linterregeln, statische Codeanalyse auf bekannte Schwachstellenmuster, der Abgleich der Abhängigkeiten, eine Suche nach Zugangsdaten im Diff und die Typprüfung. Laufen diese Schritte verpflichtend vor dem Review, kommt der Mensch mit voller Aufmerksamkeit an die Stellen, die Urteilsvermögen verlangen.

Für Zugangsdaten lohnt der eigene Schritt besonders. Beispielwerte aus dem Prompt landen erstaunlich oft als echte Zeichenkette im Code, weil sie im Vorschlag schon eingesetzt waren. Ein Scanner auf Muster von Schlüsseln und Token im Diff kostet kaum etwas und verhindert den peinlichsten Fall.

Wer den Pull Request eröffnet, verantwortet den Code

Die wichtigste Regel ist organisatorisch, nicht technisch. Der Ursprung des Codes ändert die Verantwortung nicht. Wer einen Vorschlag übernimmt, muss ihn erklären können, Zeile für Zeile, so wie er selbst geschriebenen Code erklären würde. „Das hat das Modell so gemacht“ ist im Review keine gültige Antwort.

Hilfreich ist, im Pull Request zu vermerken, welche Teile generiert wurden. Nicht zur Kontrolle, sondern weil das Review dann gezielt auf die typischen Schwächen schauen kann. Teams, die damit offen umgehen, prüfen schneller und finden mehr als Teams, in denen niemand darüber spricht.

Halte den Diff klein. Ein Vorschlag über vierhundert Zeilen wird nicht ernsthaft gelesen, egal wer ihn geschrieben hat. Bei generiertem Code fällt das stärker ins Gewicht, weil die Menge, die in kurzer Zeit entsteht, die verfügbare Prüfkapazität schnell übersteigt.

Dazu passende Kurse

Wie ein Team Vorschläge annimmt, prüft und absichert, ohne dabei das Tempo zu verlieren, behandeln die Kurse für Softwareentwicklung mit KI-Unterstützung .

Sobald ein Werkzeug nicht mehr nur vorschlägt, sondern Änderungen selbst durchführt, verschiebt sich die Prüfung noch einmal, und dazu passen die Schulungen zu Agenten, die selbst Änderungen ausführen .

Wissen prüfen

Wie sicher bist du beim Thema wirklich?

Lesen fühlt sich schnell nach Können an. Ein kurzer Test zeigt dir, was davon schon sitzt und wo sich ein Kurs lohnt. Kostenlos, ohne Anmeldung, mit einer Erklärung zu jeder Antwort.

Die Inhalte wurden sehr gut vermittelt und Fragen wurden perfekt beantwortet.
LLM Security: Injections erkennen & abwehren
Marco ist ein extrem guter Trainer, der mit seinem Fachwissen zum Thema KI sehr viel Expertise mitbringt.
KI Data Science: Datenanalyse Grundkurs
Seminarleiter war sehr gut vorbereitet, Den Lehrstoff hat er ausführlich und praxisorientiert vorgetragen.
ChatGPT Aufbaukurs: Datenanalyse, Automatisierung und Workflows

Häufige Fragen

Darf ich generierten Code überhaupt ins Produkt übernehmen?
Rechtlich hängt das vom Anbieter und vom Vertrag ab, ein pauschales Ja oder Nein wäre falsch. Klär zwei Punkte vor der Einführung: was die Nutzungsbedingungen des Anbieters zu den Ausgaben sagen und ob das Werkzeug so eingestellt ist, dass eure Eingaben nicht zum Training verwendet werden. Beides gehört schriftlich festgehalten, nicht mündlich angenommen.
Woran erkenne ich einen erfundenen Paketnamen?
Er sieht aus wie ein echter, darauf ist kein Verlass. Schlag jeden neuen Import in der Registry nach: Veröffentlichungsdatum, Zahl der Versionen, Herkunft, verlinktes Repository. Ein Paket, das vor zwei Wochen mit Version 1.0.0 erschienen ist und genau den Namen trägt, den du gerade vorgeschlagen bekommen hast, ist ein deutlicher Grund für einen zweiten Blick.
Sollen wir generierte Zeilen im Quelltext markieren?
Im Code selbst meist nicht, solche Markierungen veralten mit der ersten Änderung. Sinnvoller ist ein Hinweis im Pull Request, welcher Teil aus einem Vorschlag stammt. Das steuert die Aufmerksamkeit im Review und verschwindet nach dem Merge, ohne den Quelltext zu belasten.
Persönlich für dich da

Deine Ansprechpartner

Du bist dir nicht sicher, welcher Kurs oder welches Level zu dir passt? Wir beraten dich persönlich und kostenlos.

Yves Hoppe

Yves Hoppe

Weiterbildung & Beratung

Hilft dir, aus dem KI-Programm den passenden Kurs für deinen Stand zu finden.

Norbert Jansen

Norbert Jansen

Beratung & Inhouse

Plant mit dir Inhouse-Trainings, die auf eure Abläufe und euren Datenbestand zugeschnitten sind.

Werkzeuge nutzen und trotzdem sauber bleiben

In den Kursen zur Entwicklung mit KI-Unterstützung arbeitest du an echten Diffs und legst die Prüfschritte fest, die dein Team danach verbindlich nutzt.