Das letzte Wort behalten: mit KI in der IDE arbeiten, ohne die Kontrolle zu verlieren
Kurz gesagt
Niveau: Fortgeschritten
Die KI kann den Großteil des Codes schreiben, aber ein Mensch muss ihn verstehen, über ihn entscheiden und für ihn geradestehen. Studien zeigen, dass KI Hilfe die Fähigkeit zur Fehlersuche schwächen und falsche Sicherheit erzeugen kann, also schütz dein Verständnis bewusst:
- Arbeite in kleinen Schritten, je ein Test und ein Commit.
- Lies jeden Diff mit einer Checkliste: Umfang, Abhängigkeiten, Geheimnisse, Fehler, Datenzugriff, personenbezogene Daten, Namen, Tests.
- Schreib Zahlungen, Anmeldung, Datenmodell und kritischen Pfad selbst. Die KI berät.
- Scheitert ein Test, lies den Trace ab deinem Code, reproduzier, grenz ein, nutz blame oder bisect, und stell der KI erst dann eine enge Frage.
- Halte das Warum in Commits und Releases fest.
Die KI tippt schneller, als du denkst, und die Tests bleiben grün bis zu dem Abend, an dem sie es nicht mehr sind. Dieses Kapitel handelt von dir: wie du verstehst, was du auslieferst, wie du eine Änderung der KI prüfst, bevor du sie annimmst, und wie du einen roten Test selbst untersuchst, gezeigt an einem Abend in einem erfundenen Grazer Teeshop.
Die Frage hinter diesem Artikel
Die zwei Kapitel davor haben die Regeln aufgestellt. In testgetriebener Entwicklung mit KI arbeitet der Assistent zuerst mit dem Test, weil eine Regeldatei, ein Hook und ein CI Check ihn dazu bringen. In wenn die KI den Test statt den Code ändert sind die Tests davor geschützt, dass der Assistent sie heimlich zurechtbiegt. Beide Kapitel handeln von Mechanik. Dieses handelt von dir.
Die Frage ist schnell gestellt und schwer gelebt: Wie bleibst du die Person, die versteht und entscheidet, wenn die KI einen Großteil deines Codes schreibt? Nicht in der Theorie, sondern an einem ganz normalen Arbeitstag, mit einer Deadline, einem Werkzeug, das schneller tippt, als du denkst, und einem Test, der im ungünstigsten Moment rot wird.
Die Antwort hat sechs Teile. Versteh, was du auslieferst. Arbeite in kleinen Schritten. Lies jeden Diff, bevor du ihn annimmst. Schreib den Code mit hohem Risiko selbst. Behalte den kritischen Pfad im Blick. Und wenn etwas bricht, such den Fehler zuerst selbst und frag die KI erst dann, mit Belegen in der Hand. Zum Schluss geht es um das Protokoll deiner Entscheidungen und darum, warum all das die Arbeit versicherbar hält.
Das Beispielunternehmen ist dasselbe wie in der ganzen Serie. Das Teehaus am Grieskai ist ein erfundener Onlineshop für Tee in Graz, unter teehausgrieskai.example. Er verkauft losen Tee und Monatsabos, nimmt Kartenzahlungen über einen Zahlungsanbieter an und hat Rabattcodes, einen Lagerbestand und Bestellmails. Entwickelt wird er von Jana, ebenfalls erfunden, die jeden Tag mit einem KI Assistenten arbeitet.
Warum du das Konstrukt verstehen musst
Solange Code teuer zu schreiben war, hatte jede Person, die ihn auslieferte, ihn wenigstens getippt. Das stimmt nicht mehr. Ein Assistent baut ein funktionierendes Feature in einer Minute, und wer es übernimmt, hat vielleicht nie hineingeschaut. Solange die Tests grün sind, scheint das egal. Der Ärger beginnt, wenn um 23 Uhr ein Test rot wird und du wissen musst, wo du suchen sollst.
Die Forschung dazu ist jung, aber sie zeigt in eine Richtung. In einer randomisierten Studie vom Jänner 2026 lernten 52 überwiegend junge Entwicklerinnen und Entwickler eine Python Bibliothek, die sie noch nicht kannten, ein Teil mit KI Assistent, ein Teil ohne. Danach erreichte die Gruppe mit KI in einem Quiz zur Bibliothek 50 %, die Gruppe, die von Hand programmiert hatte, 67 %. Der größte Abstand lag bei den Fragen zur Fehlersuche1. Genau die Fähigkeit, die du brauchst, wenn etwas kaputtgeht, wuchs am wenigsten.
Eine zweite Studie fand etwas Unbequemeres. Wer einen KI Assistenten hatte, schrieb deutlich unsichereren Code als die Vergleichsgruppe und hielt den eigenen Code häufiger für sicher2. Weniger sicher, aber selbstsicherer. Eine Befragung von Microsoft Research unter 319 Wissensarbeiterinnen und Wissensarbeitern fand dasselbe Muster ganz allgemein: Mehr Vertrauen in generative KI ging mit weniger kritischem Denken einher3.
Entwicklerinnen und Entwickler spüren das selbst. In der Stack Overflow Developer Survey 2025 gaben 46 % an, der Genauigkeit von KI Werkzeugen zu misstrauen, 33 % vertrauten ihr. Der häufigste Frust, von 66 % genannt: Lösungen der KI, die "fast richtig, aber eben nicht ganz" sind. 45 % sagten, die Fehlersuche in KI generiertem Code koste mehr Zeit4. Fast richtig ist die gefährliche Sorte falsch, weil sie einen flüchtigen Blick übersteht.
Nichts davon heißt "lass die KI weg". Ich nutze KI an jedem Arbeitstag, sortiert nach Risikostufe, und auf die Stufen komme ich weiter unten zurück. Es heißt: Verständnis entsteht nicht nebenbei. Du musst es bewusst schützen.
Beispiel: zwei Versionen desselben späten Abends
Es ist 22:50 Uhr, und der Verlängerungsjob für die Abos vom Teehaus am Grieskai ist im Testlauf vor einem Release durchgefallen. Stell dir zwei Versionen von Jana vor.
Die erste hat die Änderungen des letzten Monats so übernommen, wie der Assistent sie geschrieben hat. Sie weiß, dass der Shop Abos hat und dass sie sich verlängern, aber nicht, wo das Verlängerungsdatum berechnet wird, welches Objekt die Karte belastet oder was was aufruft. Sie kopiert den Fehler in den Assistenten, bekommt einen selbstbewussten Fix, übernimmt ihn, sieht Grün und geht schlafen. Ob der Fix stimmt, kann sie nicht sagen.
Die zweite hat jede Änderung gelesen, bevor sie sie angenommen hat. Sie weiß, dass Verlängerungen über ein Service Objekt laufen, dass das Datum aus einer Methode des Abo Modells kommt und dass der Zahlungsaufruf hinter einer eigenen Klasse steckt. Sie liest den Fehler, öffnet innerhalb einer Minute die richtige Datei und stellt dem Assistenten eine einzige, enge Frage zu einer Methode, die sie nicht kennt.
Beide haben den ganzen Monat mit KI gearbeitet. Nur die zweite kann am nächsten Morgen die Frage des Inhabers beantworten: Was ist kaputtgegangen, warum, und ist es ordentlich repariert? Der Rest dieses Artikels zeigt, wie du die zweite Jana wirst.
Kleine Schritte, kleine Diffs
Ein Diff ist die Liste der Zeilen, die eine Änderung hinzufügt und entfernt. Assistenten liefern gern große: Du bittest um ein Feature und bekommst zwölf Dateien, eine neue Bibliothek und ein Refactoring, um das du nie gebeten hast. Ein großer Diff ist schwer zu lesen, also wird er überflogen, und ein überflogener Diff ist kaum geprüft.
Googles öffentliche Engineering Richtlinien sagen es klar. Kleine Änderungen werden schneller und gründlicher geprüft, bringen seltener Fehler hinein, verschwenden weniger Arbeit, wenn sie abgelehnt werden, und lassen sich leichter zurücknehmen. Als Faustregel nennt der Leitfaden 100 Zeilen meist eine vernünftige Größe und 1.000 Zeilen meist zu groß5.
Der DORA Report 2024, die jährliche Studie von Google Cloud zur Softwareauslieferung, liefert eine Warnung, die genau auf die Arbeit mit KI passt. Mit steigender KI Nutzung schätzte der Report einen Rückgang des Auslieferungsdurchsatzes um 1,5 % und der Auslieferungsstabilität um 7,2 %. Sein Schluss: Ein besserer Entwicklungsprozess verbessert die Auslieferung nicht automatisch, nicht ohne die Grundlagen erfolgreicher Auslieferung wie kleine Batches und robuste Tests6.
Die Gewohnheit lautet also: Bitte um einen kleinen, benannten Schritt nach dem anderen, jeder an einen Test gebunden, und committe ihn, bevor du um den nächsten bittest.
Beispiel: ein Feature, drei Diffs
Das Teehaus am Grieskai will, dass Kundinnen und Kunden auf ihrer Kontoseite das Datum der nächsten Lieferung sehen und ein Abo für einen Monat pausieren können. In einem einzigen Prompt angefragt, würde der Assistent Modell, Controller, View, Mailer und Tests auf einmal anfassen.
Jana teilt es stattdessen in drei Aufträge.
- "Ändere
Subscription#next_renewal_onso, dass das nächste Verlängerungsdatum eine Pause berücksichtigt. Fang mit einem fehlschlagenden Unit Test an." Rund 30 Zeilen, ein Modell und eine Testdatei. - "Zeig das nächste Lieferdatum auf der Kontoseite an, mit
next_renewal_on. Fang mit einem fehlschlagenden Systemtest an." Rund 40 Zeilen, eine View und ein Test. - "Bau den Pausieren Button so, wie es das Gherkin Szenario in
features/pause_subscription.featurebeschreibt." Rund 80 Zeilen in einem Controller, einer View und den Step Definitions.
Jeder Schritt ist klein genug, um ihn in ein paar Minuten Zeile für Zeile zu lesen, jeder hat seinen eigenen Test, und jeder ist ein eigener Commit. Stellt sich Schritt zwei als falsch heraus, fliegt er raus, ohne dass Schritt eins und drei verloren gehen. Wie du weiter unten siehst, ist in Schritt eins auch ein Fehler hineingerutscht, und gerade der kleine Commit hat ihn schnell auffindbar gemacht.
Lies jeden Diff, bevor du ihn annimmst
Jeder ernsthafte Assistent zeigt dir seine Änderungen, bevor sie deine werden. Claude Code, der Kommandozeilenassistent von Anthropic, hat Berechtigungsmodi: Im manuellen Modus fragt er vor jeder Dateiänderung und jedem Shell Befehl, und bevor er eine Datei ändert, legt er einen Schnappschuss an, zu dem du zurückspringen kannst7. In Visual Studio Code bleiben Änderungen des Copilot Agenten im Editor markiert, bis du Keep oder Undo wählst, einzeln oder für ganze Dateien8. Andere Werkzeuge arbeiten ähnlich. Das Werkzeug gibt dir den Moment. Ob du ihn nutzt, liegt bei dir.
Einen Diff lesen heißt Korrektur lesen, und Korrekturlesen klappt am besten mit einer kurzen Liste. Diese würde ich jeder Person geben, die mit einem Assistenten arbeitet:
- Tut es, was der Test verlangt, und nicht mehr? Zeilen, die nichts mit dem Test zu tun haben, sind das Erste, was du hinterfragst.
- Neue Abhängigkeiten. Jede neue Bibliothek ist Code, dem du ab jetzt vertraust. Eine Studie mit 576.000 generierten Codebeispielen fand, dass Modelle Pakete vorschlugen, die es gar nicht gibt, mindestens 5,2 % der Fälle bei kommerziellen Modellen und 21,7 % bei Open Source Modellen9. Prüf, ob ein neuer Name wirklich das echte Paket ist, gepflegt von den Leuten, die du meinst.
- Geheimnisse. Keine Schlüssel, Passwörter oder Tokens im Code. Push Protection von GitHub kann bekannte Formate von Geheimnissen blockieren, bevor sie in einem Repository landen10, aber das ist ein Netz, keine Gewohnheit.
- Fehlerbehandlung. Was passiert, wenn der Netzwerkaufruf scheitert, der Datensatz fehlt oder der Wert leer ist? Mehr dazu in Fehlerbehandlung richtig gemacht.
- Datenzugriff. Wessen Daten liest oder ändert diese Abfrage, und wird das auf dem Server geprüft? Fehlerhafte Zugriffskontrolle steht in den OWASP Top 10, der Standardliste der Risiken für Webanwendungen, auf Platz eins, und 94 % der getesteten Anwendungen zeigten eine Form davon11.
- Personenbezogene Daten. Landet etwas Persönliches in einem Log, einer Mail oder bei einem Dritten, der es nicht braucht?
- Namen. Sagen die neuen Namen, was der Code tut? Ein Name, den du selbst nie gewählt hättest, ist ein Hinweis, dass du die Änderung noch nicht verstehst.
- Tests unberührt. Hat sich im selben Diff ein Test geändert, lies den zuerst. Genau darum geht es im vorigen Kapitel.
Am Ende steht eine von drei Entscheidungen: annehmen, selbst ändern oder ablehnen und selbst schreiben. Der Ablauf unten ergänzt die Frage nach dem kritischen Pfad, die die nächsten Abschnitte erklären.
Beispiel: ein Kundenexport, Korrektur gelesen
Ein Kunde vom Teehaus am Grieskai möchte seine Bestellhistorie herunterladen. Jana bittet den Assistenten um einen CSV Export, zuerst mit dem Test. Der Test, den er schreibt, läuft durch, und das ist der Code, den er vorschlägt:
# Gemfile
gem "csv"
# app/controllers/order_exports_controller.rb
class OrderExportsController < ApplicationController
def show
orders = Order.where(customer_id: params[:customer_id])
Rails.logger.info("CSV export for #{current_customer.email}")
send_data OrdersCsv.new(orders).to_s, filename: "orders.csv"
end
end
Jana geht ihre Liste durch.
- Tut es, was der Test verlangt, und nicht mehr? Ja. Der Test meldet einen Kunden an, ruft den Export auf und prüft, dass die Datei seine Bestellungen enthält.
- Neue Abhängigkeiten. Eine neue Zeile,
gem "csv". Ein erfundenes Paket? Nein. Seit Ruby 3.4 ist die csv Bibliothek ein Bundled Gem statt eines Default Gems, eine Rails App auf Ruby 3.4 muss sie also aufführen12. Jana prüft, dass der Name das offizielle Gem ist, und behält die Zeile. - Geheimnisse. Keine.
- Fehlerbehandlung. Hier kann nichts auf ungewöhnliche Weise scheitern. Passt.
- Datenzugriff. Das ist das Problem. Die Bestellungen werden über
params[:customer_id]gesucht, eine Zahl aus der Webadresse. Jeder angemeldete Kunde könnte diese Zahl ändern und die Bestellhistorie eines anderen herunterladen, mit Namen und Adressen. Der Test hat das nicht bemerkt, weil er immer nur den eigenen Export abgefragt hat. - Personenbezogene Daten. Die Logzeile schreibt die Mailadresse des Kunden ins Serverlog. Dort braucht sie niemand.
- Namen. Passen.
- Tests unberührt. Kein bestehender Test hat sich geändert.
Es geht um Kundendaten, also hohe Risikostufe. Jana bittet nicht um einen zweiten Versuch. Sie schreibt den fehlenden Test selbst, den, der die Bestellungen eines anderen Kunden lesen will und nichts bekommen darf, sieht ihn scheitern und repariert den Controller selbst:
def show
orders = current_customer.orders.order(:placed_at)
Rails.logger.info("CSV export for customer #{current_customer.id}")
send_data OrdersCsv.new(orders).to_s, filename: "orders.csv", type: "text/csv"
end
current_customer.orders erreicht immer nur die Bestellungen der angemeldeten Person, es gibt also keine Zahl in der Adresse mehr, die man ändern könnte. Die Logzeile hält jetzt eine interne Kennung fest statt einer Mailadresse. Zwei geänderte Zeilen, und beide kamen aus der Checkliste, nicht aus Glück.
Schreib den Code mit hohem Risiko selbst
Nicht jede Zeile verdient dieselbe Sorgfalt, und wer so tut, ermüdet, bis er gar nichts mehr ordentlich prüft. Ich sortiere jede Arbeit nach Risikostufe, bevor die KI sie anfasst. Niedriges Risiko: Die KI baut, ich prüfe. Mittleres Risiko: Die KI entwirft, ich überarbeite. Hohes Risiko: Ich entscheide, die KI berät nur.
Hohes Risiko ist alles, wo ein Fehler Geld kostet, gegen das Gesetz verstößt oder dich festlegt: Zahlungen und Erstattungen, Anmeldung und Berechtigungen, das Datenmodell (die Tabellen und wie sie zusammenhängen), personenbezogene Daten und jeder Schritt des kritischen Pfads. Der Grund ist nicht, dass die KI dort schlechteren Code schreibt. Der Grund ist, dass du genau dort jede Zeile verstehen musst, wenn sie bricht, und selbst schreiben ist der verlässlichste Weg, sie zu verstehen. Der Artikel zur Verantwortung für KI Code erklärt die Stufen ausführlicher.
Beispiel: eine Woche Arbeit im Teehaus am Grieskai, sortiert
Jana hat diese Woche fünf Aufgaben. Bevor sie den Assistenten öffnet, bekommt jede eine Stufe.
| Aufgabe | Stufe | Wer schreibt |
|---|---|---|
| Neues Layout für die Seite "Unsere Tees" | Niedrig | Die KI baut, Jana prüft den Diff |
| Adminbericht der meistverkauften Tees pro Monat | Niedrig | Die KI baut, Jana prüft den Diff |
| Bestellbestätigung mit dem nächsten Lieferdatum | Mittel | Die KI entwirft, Jana überarbeitet Text und Logik |
| Ein Rabattcode, der nur für Abos gilt | Hoch | Jana schreibt, die KI erklärt auf Nachfrage Rails Methoden |
| Aboverlängerung und Kartenbelastung | Hoch | Jana schreibt, die KI berät nur |
Der Adminbericht liest Daten, ändert aber nie welche, und nur das Personal sieht ihn, ein Fehler wäre also sichtbar und harmlos. Der Rabattcode ändert, was Kundinnen und Kunden zahlen, es geht also um Geld. Die Verlängerung belastet jeden Monat eine Karte, ohne dass jemand zuschaut, und ist damit die teuerste Stelle im Shop, um falschzuliegen. Zehn Minuten Sortieren entscheiden, wohin die Stunden sorgfältigen Lesens gehen. Das geht sich auch in einer vollen Woche aus.
Behalte den kritischen Pfad beim Arbeiten im Blick
Der kritische Pfad einer Software ist die Kette von Schritten, die funktionieren muss, damit das Unternehmen Geld verdient oder seine gesetzlichen Pflichten erfüllt. Für einen Shop: stöbern, Warenkorb, Checkout, Zahlung, Bestellbestätigung, und beim Teehaus am Grieskai auch die monatliche Verlängerung. Der kritische Pfad in Software erklärt, wie du ihn findest und absicherst. Mit dem kritischen Pfad aus der Projektplanung hat er nur den Namen gemeinsam.
Beim Arbeiten halten ihn drei kleine Gewohnheiten im Blick. Eine Datei zum kritischen Pfad im Repository listet jeden Schritt auf, mit dem Code, der ihn umsetzt, und den Tests, die ihn absichern. Die Tests auf dem kritischen Pfad tragen einen Tag oder liegen in einem eigenen Ordner, damit sie sich allein ausführen lassen. Und du lässt genau diese Tests zuerst laufen, lokal, bevor du pushst, weil sie nie rot sein dürfen.
In meiner eigenen Arbeit hat jedes Produkt einen festgelegten kritischen Pfad, und sobald ein kritischer Pfad verifiziert ist, friere ich ihn hinter einem Freigabeschritt ein: Eine Änderung daran braucht eine ausdrückliche Freigabe. Jedes Release geht dann durch ein Test Gate.
Beispiel: Janas Datei zum kritischen Pfad und ihre Routine
Jana führt im Repository vom Teehaus am Grieskai eine kurze Datei:
# docs/critical_path.md
## 6. Monatliche Verlängerung
Code: app/services/subscriptions/renewal.rb, Subscription#next_renewal_on,
app/jobs/renew_subscriptions_job.rb
Tests: test/critical/subscription_renewal_test.rb,
features/renewal.feature (@critical)
Änderungsregel: Freigabe durch Jana vor dem Merge
Ihre kritischen Tests liegen in test/critical, und ihre Cucumber Szenarien auf dem Pfad tragen den Tag @critical. Cucumber kann gezielt nur die Szenarien mit einem bestimmten Tag ausführen13. Vor jedem Push startet sie zwei Befehle:
bin/rails test test/critical
bundle exec cucumber --tags @critical
Der erste führt jeden Minitest im Ordner für kritische Tests aus, der zweite jedes Szenario mit dem Tag @critical. Zusammen dauern sie keine Minute. Erst wenn beide grün sind, lässt sie die ganze Suite laufen und pusht. Wenn sie einen Diff des Assistenten prüft, gleicht sie ihn mit den "Code" Zeilen der Datei ab. Das ist die Frage nach dem kritischen Pfad im Prüfablauf oben.
Such den Fehler zuerst selbst, dann frag mit Belegen
Wenn ein Test scheitert, ist der schnellste Zug, den Fehler in den Assistenten zu kopieren. Manchmal klappt das. Aber du überspringst damit genau den Teil, in dem du lernst, wie sich dein eigenes System verhält, und überlässt die Diagnose einem Werkzeug, das laut den Umfragezahlen oben ziemlich oft "fast richtig, aber eben nicht ganz" liegt.
Die Reihenfolge, bei der du am Steuer bleibst, hat fünf Schritte.
- Lies die Meldung. Die erste Zeile des Fehlers sagt öfter, als man denkt, ganz klar, was schiefging.
- Lies den Stacktrace ab der ersten Zeile deines eigenen Codes. Ein Stacktrace ist die Liste der Methodenaufrufe, die liefen, als der Fehler passierte, der neueste zuerst. Überspring die Zeilen aus Ruby und aus Gems und such die erste Zeile, die in deine eigenen Dateien zeigt. Rails filtert den Trace standardmäßig auf die Zeilen deiner Anwendung, und
bin/rails test -bzeigt den vollständigen14. - Reproduzier ihn. Lös den Fehler absichtlich noch einmal aus, in der Konsole oder in einem kleineren Test. Kannst du ihn nicht reproduzieren, kannst du auch nicht wissen, ob du ihn behoben hast.
- Grenz ihn ein. Kürz den fehlschlagenden Fall, bis nur noch die Ursache übrig ist: ein Objekt, eine Methode, eine Eingabe.
- Find die Änderung. Zeigt der Trace auf eine Zeile, zeigt
git blame, welcher Commit sie zuletzt geändert hat15. Wenn nicht, findetgit bisectden ersten fehlerhaften Commit, indem es die Menge der Commits immer wieder halbiert und jede Mitte als gut oder schlecht testet16.
Erst dann fragst du die KI, und zwar eine enge Frage mit den Belegen in der Hand: die Meldung, den Trace, die Zeile und was du schon weißt.
git bisect ist einen kurzen Blick auf die Mathematik wert, weil er zeigt, warum es so schnell geht. Jeder Test halbiert die Commits, die noch in Frage kommen, also wächst die Zahl der Tests mit dem Logarithmus der Zahl der Commits (Grundlagen: Logarithmen):
ist die Zahl der Commits, die du testen musst, die Zahl der Commits zwischen dem letzten bekannten guten und dem ersten bekannten schlechten, fragt, wie oft du halbieren musst, um auf eins zu kommen, und rundet das Ergebnis auf die nächste ganze Zahl auf.
Bei neun Commits ergibt das:
Mit finden also rund Testläufe den Verursacher, und selbst Commits brauchen nur . Mit git bisect run und einem Testbefehl erledigt git die Läufe für dich: Exitcode 0 heißt gut, die meisten anderen Codes heißen schlecht, und 125 heißt "nicht testbar, überspringen"16.
Beispiel: ein Abend im Teehaus am Grieskai
Das ist das durchgerechnete Beispiel für die ganze Methode, Schritt für Schritt.
Die Änderung. Am Nachmittag hat Jana das Feature "nächstes Lieferdatum" in den drei kleinen Schritten von oben gebaut. In Schritt eins hat der Assistent eine bestehende Methode im Abo Modell geändert. Vorher stand da:
def next_renewal_on
renewed_on.next_month
end
Nach der Änderung des Assistenten, damit eine Pause das Datum nach hinten schiebt:
def next_renewal_on
[paused_until, renewed_on >> 1].max
end
Die Idee ist eh vernünftig: Nimm das spätere von beiden, das Ende einer Pause oder einen Monat nach der letzten Verlängerung. Jana hat den Diff gelesen, die Tests der Kontoseite laufen lassen, Grün gesehen und committet. Was sie übersehen hat: Auch der Verlängerungsservice ruft diese Methode auf, und sie hat den Diff nicht mit ihrer Datei zum kritischen Pfad abgeglichen. Genau das ist die Lehre, und sie kommt am Ende wieder.
Der rote Test. Um 19:40 Uhr, vor dem Push, lässt sie wie immer ihre kritischen Tests laufen. Einer scheitert:
Error:
SubscriptionRenewalTest#test_renews_a_monthly_subscription_and_schedules_the_next_renewal:
ArgumentError: comparison of Date with nil failed
app/models/subscription.rb:42:in 'Array#max'
app/models/subscription.rb:42:in 'Subscription#next_renewal_on'
app/services/subscriptions/renewal.rb:23:in 'Subscriptions::Renewal#call'
test/critical/subscription_renewal_test.rb:8:in 'block in <class:SubscriptionRenewalTest>'
bin/rails test test/critical/subscription_renewal_test.rb:5
Es wurde nichts gepusht, also ist niemand aus der Kundschaft betroffen. Das Gate hat seine Arbeit gemacht. Jetzt ist es ihre.
Lies die Meldung. "comparison of Date with nil failed", also: Der Vergleich eines Datums mit nil ist gescheitert. Irgendetwas wollte ein Datum mit nil vergleichen, dem Ruby Wort für "kein Wert".
Lies den Trace ab deinem eigenen Code. Die erste Zeile, Array#max, ist eine Methode von Ruby selbst, aber aufgerufen wurde sie aus ihrer Datei: app/models/subscription.rb, Zeile 42, in next_renewal_on. Die Zeile darunter zeigt, wer das aufgerufen hat: der Verlängerungsservice, Zeile 23. Die letzte Zeile ist der Test selbst. Die Verlängerung ist also gescheitert, weil next_renewal_on einen Fehler geworfen hat, und der Fehler entstand in max.
Reproduzier ihn. Sie öffnet die Rails Konsole mit bin/rails console und baut ein Abo, das nie pausiert war:
subscription = Subscription.new(renewed_on: Date.new(2027, 1, 31))
subscription.next_renewal_on
# => ArgumentError: comparison of Date with nil failed
Derselbe Fehler, absichtlich, in zwei Zeilen. Ein Abo, das nie pausiert war, hat paused_until auf nil. Das Array wird zu [nil, ein Datum], und max kann die beiden nicht vergleichen. Die Tests der Kontoseite liefen durch, weil ihr Fixture Abo zufällig eine Pause hatte.
Grenz ihn ein. Sie schreibt den kleinsten Test, der den Fehler zeigt, in die Testdatei des Modells und startet ihn mit bin/rails test test/models/subscription_test.rb, um ihn genau aus diesem Grund scheitern zu sehen:
test "next renewal is one month on when the subscription was never paused" do
subscription = Subscription.new(renewed_on: Date.new(2027, 1, 31))
assert_equal Date.new(2027, 2, 28), subscription.next_renewal_on
end
Find die Änderung. Der Trace zeigt auf Zeile 42, also reicht blame:
git blame -L 40,44 app/models/subscription.rb
-L 40,44 beschränkt die Ausgabe auf die Zeilen 40 bis 44. Sie zeigt, dass Zeile 42 aus dem Commit "Take pauses into account in next_renewal_on" von 15:12 Uhr stammt. Hätte der Trace nicht auf eine geänderte Zeile gezeigt, hätte sie git bisect start HEAD v58 gestartet (zuerst der schlechte Commit, dann das letzte Release, das gut war) und danach git bisect run bin/rails test test/critical/subscription_renewal_test.rb, und bei neun Commits seit diesem Release hätten rund vier Testläufe den Verursacher benannt.
Stell der KI die enge Frage. Eine Sache bleibt ihr rätselhaft: das >> an einem Datum. Das hat sie nie benutzt. Also fragt sie, mit den Belegen:
Was macht `Date#>>` in Ruby? In app/models/subscription.rb:42 steht
`renewed_on >> 1`. Mit renewed_on = 31. Jänner 2027 erwartet mein Test
den 28. Februar 2027. Liefert >> genau das, und was passiert bei der nächsten Verlängerung?
Nur erklären, keine Dateien ändern.
Der Assistent erklärt, dass >> ein Datum um eine Zahl von Monaten nach vorne schiebt, und dass, wenn der Zielmonat diesen Tag nicht hat, der letzte Tag dieses Monats genommen wird. Jana gleicht das mit der Ruby Dokumentation ab, die genau das sagt und das Beispiel mit dem 31. Jänner bringt17. Die Dokumentation zeigt auch den Haken: Vom 31. Jänner ist ein Monat später der 28. Februar, und einen Monat danach der 28. März, nicht der 31. März. Wer am 31. angefangen hat, wandert also langsam auf den 28. Das ist kein Fehler im Code, sondern eine geschäftliche Entscheidung, also schreibt Jana es als Frage an den Inhaber vom Teehaus am Grieskai auf, statt zu raten.
Der Fix, von ihr geschrieben. Die Verlängerung ist hohes Risiko, also schreibt sie den Fix selbst. Zuerst einen zweiten Test für den pausierten Fall, dann die Methode:
test "next renewal waits until the day after a pause ends" do
subscription = Subscription.new(renewed_on: Date.new(2027, 1, 31),
paused_until: Date.new(2027, 3, 14))
assert_equal Date.new(2027, 3, 15), subscription.next_renewal_on
end
def next_renewal_on
regular = renewed_on >> 1
return regular if paused_until.nil?
[paused_until.next_day, regular].max
end
Zeile für Zeile: regular ist das Datum einen Monat nach der letzten Verlängerung. Gibt es keine Pause, ist das die Antwort, und die Methode gibt sie sofort zurück, ohne irgendetwas mit nil zu vergleichen. Gibt es eine Pause, ist die nächste Verlängerung das spätere von beiden, der Tag nach dem Ende der Pause oder das reguläre Datum. Die neuen Tests laufen durch, die kritischen Tests auch, danach die ganze Suite. Außerdem trägt sie Subscription#next_renewal_on ausdrücklich in die "Code" Zeile ihrer Datei zum kritischen Pfad ein. Damit stellt der nächste Diff, der die Methode berührt, die Frage nach dem kritischen Pfad.
Die KI hat an diesem Tag zweimal geholfen: Sie hat das Feature geschrieben, und sie hat eine unbekannte Methode erklärt. Jede Entscheidung, auf die es ankam, hat Jana getroffen.
Halte deine Entscheidungen fest
Verständnis verblasst. In sechs Monaten weiß weder Jana noch sonst jemand, warum next_renewal_on bei fehlender Pause früh zurückkehrt. Das Entscheidungsprotokoll erinnert sich: Commit Nachrichten, die das Warum erklären, Release Notes, die sagen, was sich für die Kundschaft geändert hat, und ein Register, was wann live ging.
Die Dokumentation von git empfiehlt, eine Commit Nachricht mit einer kurzen Zusammenfassung von höchstens 50 Zeichen zu beginnen, dann eine Leerzeile, dann eine ausführlichere Beschreibung18. Dort steht die Begründung. Eine Commit Nachricht wie "fix" sagt niemandem etwas. In meiner eigenen Arbeit bekommt außerdem jedes Produktionsrelease eine Version in einem Release Register, und nach jedem Deploy ruft ein Smoke Test jede Seite der Website auf. Der Artikel zum Nachweis von Compliance erklärt, wie so ein Register funktioniert.
Beispiel: Janas Commit Nachricht und Release Note
Verlängerung für nie pausierte Abos repariert
next_renewal_on hat paused_until mit Array#max gegen ein Datum
verglichen. Bei einem Abo ohne Pause ist paused_until nil, der
Vergleich warf einen ArgumentError, und der Verlängerungsjob wäre
bei jedem nicht pausierten Abo gescheitert.
Die Methode gibt ohne Pause jetzt direkt das reguläre Datum zurück.
Zwei Modelltests ergänzt (nie pausiert, pausiert) und die Methode
in docs/critical_path.md unter Schritt 6 eingetragen.
Offene Frage an den Inhaber: Verlängerungen vom 31. wandern nach
dem Februar auf den 28. (Date#>> nimmt den letzten Tag des Monats).
Die Release Note für den Inhaber ist kürzer: "Das nächste Lieferdatum steht jetzt auf der Kontoseite. Ein Fehler beim Verlängerungsdatum wurde von den Tests vor dem Release gefunden und behoben. Eine Frage an dich zu Abos, die am 31. begonnen haben." Das Release Register bekommt eine neue Version mit Commit, Testlauf und Datum. Wer später fragt, kann der Spur von der Frage bis zur Codezeile folgen.
Warum das letzte Wort die Arbeit versicherbar und verantwortbar hält
Alles oben dient einer Idee. Für jede Änderung gibt es eine benannte Person, die sie verstanden und freigegeben hat. Das heißt Verantwortung in Software, und daran ändert die KI nichts. Den Assistenten kann man in keinem Meeting fragen, warum eine Verlängerung gescheitert ist, er kann kein Release unterschreiben und keine Haftung tragen.
Das zählt auch für Versicherungen und Verträge. In den USA steht Versicherern seit Jänner 2026 ein Standardausschluss für generative KI in Betriebshaftpflichtpolicen zur Verfügung, und bis Mitte 2026 waren in 49 Bundesstaaten mehr als 2.000 solcher Ausschlüsse in Kraft19. Policen in Österreich funktionieren anders und ändern sich in ihrem eigenen Takt, lies also deine eigene, aber die Richtung ist klar: Versicherer fangen an zu fragen, wie KI geschriebener Code kontrolliert wird. Eine Spur aus geprüften Diffs, Tests, Freigaben und Releases ist die Antwort, mit der sie arbeiten können. Der Artikel zur Verantwortung für KI Code geht auf Ausschlüsse und Haftung genauer ein.
Beispiel: die Frage des Inhabers vom Teehaus am Grieskai
Am nächsten Morgen liest der Inhaber die Release Note und fragt: "Wer hat die Änderung freigegeben, die die Verlängerung kaputtgemacht hat, und woher weiß ich, dass das nicht wieder passiert?"
Jana kann jeden Teil davon mit Belegen beantworten. Die Änderung war ihre, auf Basis des Entwurfs des Assistenten, im Commit "Take pauses into account in next_renewal_on" um 15:12 Uhr. Die kritischen Tests haben sie um 19:40 Uhr vor dem Release erwischt, niemandem wurde also falsch abgebucht oder eine Lieferung vorenthalten. Der Fix steht in einem eigenen Commit mit Begründung und zwei neuen Tests. Die Methode steht jetzt auf der Liste des kritischen Pfads, jede künftige Änderung daran braucht also ihre Freigabe und lässt zuerst die kritischen Tests laufen. Und die Frage zur Datumswanderung wartet auf seine Entscheidung. Diese Antwort dauert zwei Minuten, weil sie die Person geblieben ist, die versteht.
Fazit
Die KI kann den Großteil des Codes schreiben. Sie kann nicht die Person sein, die ihn versteht, über ihn entscheidet und für ihn geradesteht. Diese Rolle bleibt bei einem Menschen, und sie muss bewusst geschützt werden, denn die Forschung zeigt, dass Verständnis und kritisches Denken schrumpfen, wenn sie nicht gebraucht werden.
Die Gewohnheiten sind nicht kompliziert. Arbeite in kleinen Schritten. Lies jeden Diff mit einer Checkliste, bevor du ihn annimmst. Schreib den Code mit hohem Risiko selbst und lass die KI beraten. Halte den kritischen Pfad in einer Datei fest und seine Tests am Anfang jedes Laufs. Wenn ein Test scheitert, lies den Trace ab deinem eigenen Code, reproduzier, grenz ein, find die Änderung, und frag erst dann die KI, eng und mit Belegen. Und schreib auf, warum, in Commits und Releases, damit die nächste Person folgen kann.
So behältst du das letzte Wort. Die Tests aus dem ersten Kapitel dieser Serie sagen dir, wann etwas falsch ist. Verständnis sagt dir, warum.