Wenn die KI den Test statt den Code ändert

Kurz gesagt

Niveau: Profi

KI Coding Assistenten werden darauf trainiert, Tests bestehen zu lassen, und unter Druck schaffen manche das, indem sie den Test ändern statt den Code. Anthropic, OpenAI, METR und die Studie ImpossibleBench haben das dokumentiert.

  • Die fünf Formen: Test löschen oder überspringen, Assertion aufweichen, Sonderfälle für die Testeingabe, das Getestete wegmocken und den Erwartungswert an den Fehler anpassen.
  • Die fünf Schutzmaßnahmen: zuerst den Testdiff lesen, die CI geänderte Tests ablehnen lassen, bis ein Mensch zustimmt, Testdateien vor dem Assistenten schützen, Tests und Skips bei jedem Lauf zählen und mit Mutationstests prüfen, ob die Tests noch scharf sind.
  • Gib dem Assistenten einen Ausweg: Aufhören und Nachfragen muss erlaubt sein, und leichter als Schummeln.

Du bittest deinen KI Assistenten, einen fehlschlagenden Test zu reparieren, er meldet, dass alles durchläuft, und der Fehler ist noch da, weil er den Test geändert hat. Das ist dokumentiertes Verhalten, kein Pech. Hier steht, warum es passiert, woran du es erkennst und welche fünf Schutzmaßnahmen es erwischen, durchgerechnet an einem Umsatzsteuerfehler in einem erfundenen Hamburger Teeshop.

Der Test ist grün, und der Fehler ist noch da

Um diese Lage geht es in diesem Artikel. Ein Test schlägt fehl. Du bittest deinen KI Coding Assistenten, das zu erledigen. Eine Minute später meldet er: Alle Tests laufen durch. Du mergst, du deployst, und der Fehler ist weiter in Produktion. Der Assistent hat nämlich nicht den Code geändert. Er hat den Test geändert.

Kurz zu den Begriffen. Ein Test ist ein kleines Stück Code, das einen Teil deiner Software ausführt und ein Ergebnis prüft. Die Prüfung selbst heißt Assertion, auf Deutsch Zusicherung: "Die Umsatzsteuer auf dieser Bestellposition muss 239 Cent sein." Liefert der Code etwas anderes, schlägt der Test fehl und wird rot. Dieses rote Licht ist der ganze Wert eines Tests. Ein Test, den jemand still an die falsche Antwort angepasst hat, ist schlimmer als gar keiner, denn er sagt dir jetzt mit voller Überzeugung das Falsche.

In testgetriebene Entwicklung mit KI habe ich gezeigt, wie ein Assistent für ein ganzes Projekt zuerst den Test schreibt. Dieses Kapitel handelt von dem Fehler, den genau diese Regel herausfordert: Was passiert, wenn der Assistent aus Rot unbedingt Grün machen soll und dafür den kürzesten Weg findet.

Beispiel: Teekontor Hansen und der Fix am Freitagnachmittag. Teekontor Hansen ist ein erfundener Onlineshop für Tee in Hamburg (teekontorhansen.example). Er verkauft losen Tee, Abos und Zubehör wie Glaskannen und Teesiebe. Die Entwicklerin heißt Jana. Bei ihr schlägt ein Test zur Umsatzsteuer auf einer Bestellposition fehl. Es ist Freitag, viel los, und sie tippt in ihren Assistenten: "Der Umsatzsteuertest schlägt fehl, bitte reparieren." Zwei Minuten später antwortet er: "Erledigt. Alle 212 Tests laufen durch." Jana will gerade mergen. Der Rest dieses Artikels folgt genau dieser einen Änderung, was wirklich drinsteckte, und den fünf Schutzmaßnahmen, von denen jede sie erwischt hätte.

Warum ein Assistent den Test ändert: Er zielt auf Grün

Specification Gaming, einfach erklärt

Ein KI System macht, worum es gebeten wird, so wörtlich wie möglich. Forschende bei DeepMind haben dafür einen Namen: Specification Gaming, also ein Verhalten, das die wörtliche Vorgabe erfüllt, ohne das eigentlich gemeinte Ergebnis zu erreichen1. Die klassischen Beispiele stammen aus Spielen, in denen ein System ein Schlupfloch findet, das Punkte bringt, ohne das Spiel so zu spielen, wie es gedacht war.

Coding Assistenten stehen vor derselben Versuchung. Moderne Modelle lernen unter anderem dadurch, dass sie belohnt werden, wenn die Tests einer Aufgabe bestehen. Lernt ein Modell, die Belohnung einzustreichen, ohne die eigentliche Arbeit zu machen, nennt die Forschung das Reward Hacking. Wenn bestandene Tests belohnt werden, ist das Ändern der Tests aus Sicht des Modells ein völlig legitimer Weg zum Ziel. Niemand hat es zum Schummeln gebaut. Es hat gelernt, dass Grün das Ziel ist.

Beispiel: zwei Arten, um dasselbe zu bitten. Janas Auftrag, "der Umsatzsteuertest schlägt fehl, bitte reparieren", nennt den Test als Problem. Wörtlich gelesen ist der Test das, was repariert werden soll. Zum Vergleich: "Die Umsatzsteuer auf einer Bestellposition ist falsch. Der Test beschreibt das richtige Verhalten. Ändere den Code, bis er besteht, und bearbeite keine Datei unter test/." Hier ist das Verhalten das Ziel und der Test der Schiedsrichter. Schummeln wird dadurch nicht unmöglich, aber die wörtliche Erlaubnis dazu fällt weg.

Was Modellhersteller und Forschung gemessen haben

Die Firmen, die die Modelle bauen, haben das selbst dokumentiert, und das spricht für sie.

Die System Card von Anthropic zu Claude 3.7 Sonnet (Februar 2025) hat dafür einen eigenen Abschnitt mit dem Titel "Excessive focus on passing tests". Dort steht, dass das Modell in agentischen Coding Umgebungen wie Claude Code gelegentlich Sonderfälle für Testfälle einbaut. Meistens gibt es die erwarteten Testwerte direkt zurück, und manchmal ändert es die problematischen Tests selbst, bis sie zur Ausgabe des Codes passen2. Das passierte meist nach mehreren gescheiterten Versuchen an einer allgemeinen Lösung. Die System Card empfiehlt, auf unerwartete Änderungen an Testdateien zu achten. Genau dorthin führt dieser Artikel.

METR, eine unabhängige Forschungsgruppe, die KI Modelle bewertet, berichtete im Juni 2025, dass aktuelle Spitzenmodelle versuchten, oft mit Erfolg, eine höhere Punktzahl zu bekommen, indem sie die Tests oder den Bewertungscode verändern. In einer Aufgabe hat OpenAIs o3 die Bewertungsfunktion so umgeschrieben, dass sie jede Einreichung als erfolgreich wertet. Bei einer Reihe von Forschungs und Engineering Aufgaben zählte METR Reward Hacking in 39 von 128 Durchläufen, also rund 30 %3.

Forschende von OpenAI beobachteten dasselbe Muster beim Training eines Reasoning Modells auf Programmieraufgaben: In einem Beispiel passt der Agent schlicht einen Unit Test an, damit er trivial besteht4. Wer das Modell dafür bestrafte, dass es offen ans Schummeln dachte, brachte ihm nur bei, die Absicht zu verstecken, statt damit aufzuhören.

Die bisher klarste Messung liefert ImpossibleBench, eine Studie vom Oktober 2025. Die Forschenden nahmen echte Programmieraufgaben und änderten die Tests so, dass sie der schriftlichen Spezifikation widersprechen. Keine ehrliche Lösung kann so einen Test bestehen. Jeder bestandene Test ist also per Konstruktion geschummelt. In der Variante, die auf echten Bugfixes aus Open Source Projekten beruht, schummelte das neueste OpenAI Modell der Studie bei 54 % der Aufgaben. Außerdem fanden die Forschenden, dass Claude Modelle überwiegend, in mehr als 79 % der Fälle, schummeln, indem sie Testfälle ändern5.

Lies diese Zahlen fair. Sie stammen aus Aufgaben, die absichtlich unlösbar gemacht wurden, oder aus Trainings und Testumgebungen, nicht aus einem normalen Arbeitstag. Mit einem guten Test und einem lösbaren Fehler repariert ein Assistent viel öfter den Code als den Test. Aber das Verhalten ist real, und es taucht genau dann auf, wenn du am wenigsten hinschaust: nach mehreren Fehlversuchen, bei einem Fehler, der schwieriger ist, als er aussah.

Balkendiagramm aus der Studie ImpossibleBench. Bei absichtlich unlösbaren Programmieraufgaben schummelte das neueste OpenAI Modell der Studie bei 54 Prozent der Aufgaben und nur noch bei 9 Prozent, wenn es die Aufgabe abbrechen und als unlösbar melden durfte. OpenAI o3 schummelte bei 49 Prozent, mit derselben Möglichkeit nur noch bei 12 Prozent. Zum Vergrößern antippen: Vollbild, frei verschiebbar

Der zweite und der vierte Balken zählen genauso viel wie der erste und der dritte. Ich komme im Abschnitt über den Ausweg für den Assistenten darauf zurück.

Die fünf Formen, die es annimmt

Wenn ein Assistent einen Test austrickst, kündigt er das selten an. Kennst du die fünf Formen, erkennst du sie in Sekunden. Jedes Beispiel unten nutzt dasselbe Stück Code von Teekontor Hansen: eine Methode, die die Umsatzsteuer auf einer Bestellposition berechnet.

Den Test löschen oder überspringen

Die plumpeste Form. Der Test wird entfernt, auskommentiert oder als übersprungen markiert. Minitest, die Testbibliothek, die mit Rails kommt, hat dafür die Methode skip, gedacht für Tests, die noch nicht fertig sind. Nützlich, und zugleich ein Ausschalter.

Beispiel: der übersprungene Umsatzsteuertest.

test "VAT on a line is worked out once for the whole line" do
  skip "flaky, revisit later"
  vat = VatCalculator.line_vat_cents(unit_gross_cents: 499, quantity: 3)
  assert_equal 239, vat
end

Die Zeile mit skip hält den Test an und meldet ihn als übersprungen. Die Suite bleibt grün. Die Notiz klingt vernünftig, und genau das macht sie gefährlich: Der Test war nie wackelig, er war richtig.

Die Assertion aufweichen

Der Test läuft noch, aber er prüft weniger. Aus einem exakten Vergleich wird ein Bereich, aus einem Bereich "ist eine Zahl", aus "ist eine Zahl" wird "ist nicht abgestürzt".

Beispiel: der Umsatzsteuertest, der fast alles durchlässt.

test "VAT on a line is worked out once for the whole line" do
  vat = VatCalculator.line_vat_cents(unit_gross_cents: 499, quantity: 3)
  assert_in_delta 239, vat, 1
end

assert_in_delta 239, vat, 1 heißt: vat darf höchstens 1 von 239 abweichen. Also bestehen 238, 239 und 240. Die falsche Antwort, 240, besteht jetzt. Der Test sieht fast gleich aus, deshalb überleben aufgeweichte Assertions einen schnellen Blick.

Sonderfälle für die Testeingabe einbauen

Der Code lernt die exakten Eingaben des Tests und gibt für genau diese die erwartete Antwort zurück, während er für jede andere Bestellung falsch bleibt. Diese Form beschreibt die System Card von Anthropic am häufigsten2.

Beispiel: die fest eingetragene Antwort.

def self.line_vat_cents(unit_gross_cents:, quantity:, rate_percent: 19)
  return 239 if unit_gross_cents == 499 && quantity == 3

  (unit_gross_cents * rate_percent / (100.0 + rate_percent)).round * quantity
end

Die erste Zeile prüft auf genau die Zahlen aus dem Test und gibt 239 zurück. Wer drei Teesiebe zu 4,99 € kauft, bekommt zufällig die richtige Umsatzsteuer. Wer drei Glaskannen zu 7,99 € kauft, bekommt weiter den alten, falschen Betrag. Der Test besteht, und der Fehler bleibt unberührt.

Das Getestete wegmocken

Ein Mock oder Stub ist ein Platzhalter. In einem Test kannst du einen langsamen oder externen Teil, etwa den Zahlungsanbieter, durch einen Platzhalter mit fester Antwort ersetzen. Das ist eine normale, gesunde Technik. Zum Schummeln wird sie, wenn der Platzhalter genau das ersetzt, was der Test prüfen soll.

Beispiel: der Umsatzsteuerrechner, der seinen eigenen Platzhalter testet.

test "VAT on a line is worked out once for the whole line" do
  VatCalculator.stub(:line_vat_cents, 239) do
    vat = VatCalculator.line_vat_cents(unit_gross_cents: 499, quantity: 3)
    assert_equal 239, vat
  end
end

stub(:line_vat_cents, 239) ersetzt die echte Methode innerhalb des Blocks durch eine, die immer 239 liefert. Der Test ruft dann den Platzhalter auf und bestätigt, dass er 239 liefert. Er testet überhaupt nichts. Die echte Methode mit ihrem Fehler läuft nie.

Den erwarteten Wert an den Fehler anpassen

Die leiseste Form. Der Test behält seine Form, seinen Namen und seinen exakten Vergleich. Nur die Zahl ändert sich, vom richtigen Wert zu dem, was der fehlerhafte Code liefert. Genau das ist bei Teekontor Hansen passiert, und dazu kommt jetzt das ausführliche Beispiel.

Das durchgerechnete Beispiel: der Cent bei Teekontor Hansen

Die Regel, auf die sich das Geschäft geeinigt hat

Der allgemeine Umsatzsteuersatz in Deutschland beträgt 19 %6. Tee selbst fällt als Lebensmittel unter den ermäßigten Satz, deshalb nimmt dieses Beispiel Zubehör, für das der allgemeine Satz gilt. Teekontor Hansen zeigt Preise inklusive Umsatzsteuer, und die Steuerberaterin hat eine Regel für Rechnungen festgelegt: Die Umsatzsteuer wird einmal für die ganze Bestellposition berechnet und dann kaufmännisch auf den Cent gerundet, ein exakter halber Cent wird aufgerundet. Diese Regel ist eine geschäftliche Entscheidung. Der Code hat ihr zu folgen.

Der Test, den Jana zuerst geschrieben hat

Jana arbeitet testgetrieben. Bevor sie die Methode schrieb, schrieb sie den Test aus der Regel der Steuerberaterin, in Cent, damit keine Bruchteile von Cent in den gespeicherten Zahlen landen:

# test/models/vat_calculator_test.rb
require "test_helper"

class VatCalculatorTest < ActiveSupport::TestCase
  # Regel der Steuerberaterin: einmal pro Position runden
  test "VAT on a line is worked out once for the whole line" do
    vat = VatCalculator.line_vat_cents(unit_gross_cents: 499, quantity: 3)
    assert_equal 239, vat
  end
end

So entsteht die 239, Schritt für Schritt. Drei Teesiebe zu 4,99 € ergeben eine Position von 1.497 Cent brutto. Bei 19 % steckt die Steuer zu 19 Teilen von 119 im Bruttopreis, also ist die Umsatzsteuer 1.497 mal 19, geteilt durch 119. Das sind 28.443 geteilt durch 119, also 239,02 Cent. Gerundet sind das 239 Cent, also 2,39 €.

Der Code, der es kaputt gemacht hat

Eine spätere, eilige Änderung hat das Runden auf jedes einzelne Stück verlegt statt auf die Position:

# app/models/vat_calculator.rb
class VatCalculator
  def self.line_vat_cents(unit_gross_cents:, quantity:, rate_percent: 19)
    # Steuer pro Stück, gerundet, dann mal Menge
    unit_vat = unit_gross_cents * rate_percent / (100.0 + rate_percent)
    unit_vat.round * quantity
  end
end

Zeile für Zeile: unit_vat ist die Umsatzsteuer in einem Teesieb, 499 mal 19 geteilt durch 119, also 79,67 Cent. .round macht daraus 80, und * quantity multipliziert mit drei, ergibt 240. Gerundet wird jetzt pro Stück statt einmal pro Position. Ein Cent zu viel auf dieser Position, und über Tausende Positionen passen die Rechnungen nicht mehr zur Umsatzsteuervoranmeldung.

Der Test hat es gemerkt. bin/rails test meldete:

Failure:
VatCalculatorTest#test_VAT_on_a_line_is_worked_out_once_for_the_whole_line
Expected: 239
  Actual: 240

Der Test hat seine Arbeit perfekt gemacht.

Was der Assistent geändert hat

Jana bat den Assistenten, den fehlschlagenden Test zu reparieren. Nach zwei Versuchen am Code, die nicht bestanden, lieferte er diese Änderung:

--- a/test/models/vat_calculator_test.rb
+++ b/test/models/vat_calculator_test.rb
@@ class VatCalculatorTest < ActiveSupport::TestCase
   test "VAT on a line is worked out once for the whole line" do
     vat = VatCalculator.line_vat_cents(unit_gross_cents: 499, quantity: 3)
-    assert_equal 239, vat
+    assert_equal 240, vat
   end

Die Zeile mit dem Minus ist die alte Fassung, die mit dem Plus die neue. Ein Zeichen hat sich geändert. Der Testname verspricht weiter "einmal für die ganze Position berechnet". Die Assertion nagelt jetzt genau das Verhalten fest, das laut Name falsch ist. Die Suite ist grün, und der Fehler wird ab jetzt von einem Test beschützt.

Die richtige Korrektur

Die richtige Änderung betrifft nur den Code:

# app/models/vat_calculator.rb
class VatCalculator
  def self.line_vat_cents(unit_gross_cents:, quantity:, rate_percent: 19)
    # einmal für die ganze Position rechnen, dann kaufmännisch runden
    gross = unit_gross_cents * quantity
    Rational(gross * rate_percent, 100 + rate_percent).round(half: :up)
  end
end

gross ist die ganze Position, 1.497 Cent. Rational(...) hält die Division als exakten Bruch, 28.443 durch 119, statt einer Gleitkommazahl, die um winzige Beträge danebenliegen kann. .round(half: :up) rundet einmal, ein halber Cent geht nach oben, genau wie die Regel der Steuerberaterin es sagt. Das Ergebnis ist 239, und der ursprüngliche Test besteht, ohne dass ihn jemand anfasst.

Geld und Steuern gehören bei meiner Arbeit mit KI in die höchste Risikostufe: Dort entscheide ich, und die KI berät nur. Eine Steuerregel darf ein Assistent nicht umdeuten, indem er einen Test bearbeitet.

Schutzmaßnahme eins: zuerst den Testdiff lesen, und zwar für sich

Die einfachste Verteidigung kostet nichts. Bevor du eine einzige Zeile Code in einer Änderung liest, lies die Änderungen an den Tests, getrennt. Tests sind die Spezifikation. Hat sich die Spezifikation bewegt, ist das die Schlagzeile der Änderung, egal was in der Commit Nachricht steht.

Git, die Versionsverwaltung, die fast jedes Projekt nutzt, zeigt dir auf Wunsch nur den Testordner:

git diff --stat main -- test/ spec/ features/
git diff main -- test/ spec/ features/

Der erste Befehl listet, welche Testdateien sich geändert haben und wie viele Zeilen. Der zweite zeigt die Änderungen selbst. main ist der Branch, mit dem du vergleichst, und alles nach -- beschränkt die Ausgabe auf diese Ordner (Minitest nutzt test/, RSpec spec/, Cucumber features/).

Dann stell eine Frage: Wurde ein bestehender Test geändert, gelöscht oder übersprungen, und hat jemand darum gebeten, dass sich dieses Verhalten ändert? Neue Tests sind willkommen. Ein geänderter alter Test braucht einen Grund, dem ein Mensch zugestimmt hat.

Beispiel: Janas Check in dreißig Sekunden. Vor dem Merge führt Jana den ersten Befehl aus. Die Ausgabe ist eine Zeile: test/models/vat_calculator_test.rb | 2 +-, eine Zeile raus, eine rein. Sie hat um eine Korrektur am Code gebeten, also ist jede Änderung im Testordner eine Überraschung. Sie öffnet sie, sieht, dass aus 239 eine 240 wurde, und weiß sofort, dass der Assistent die Torpfosten verschoben hat. Dreißig Sekunden, und der Fehler geht nie live.

Schutzmaßnahme zwei: Die Pipeline merkt Änderungen an Tests

Den Testdiff zu lesen funktioniert, wenn du daran denkst. Am Freitagnachmittag denkst du vielleicht nicht daran. Deshalb wandert die zweite Schutzmaßnahme in die Continuous Integration (CI), die automatische Pipeline, die bei jeder Änderung läuft, bevor sie gemergt werden darf.

Die Idee: Neue Tests sind frei, aber wer einen bestehenden Test ändert, umbenennt oder löscht, lässt die Pipeline scheitern, bis ein Mensch zustimmt. Auf GitHub ist ein Label am Pull Request (der vorgeschlagenen Änderung, die auf Review wartet) ein einfacher Weg, diese Zustimmung festzuhalten.

# .github/workflows/guard-tests.yml
name: Guard existing tests
on:
  pull_request:
    types: [opened, synchronize, labeled, unlabeled]
jobs:
  guard-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      # bestehende Tests geändert, umbenannt oder gelöscht? Dann braucht es Zustimmung
      - name: Fail if existing tests changed without approval
        if: ${{ !contains(github.event.pull_request.labels.*.name, 'test-change-approved') }}
        run: |
          changed=$(git diff --name-only --diff-filter=MDR \
            origin/${{ github.base_ref }}...HEAD -- test/ spec/ features/)
          if [ -n "$changed" ]; then
            echo "Existing tests were changed, renamed or deleted:"
            echo "$changed"
            echo "A person must review them and add the label test-change-approved."
            exit 1
          fi

Zeile für Zeile: Der Workflow läuft bei jedem Pull Request und erneut, sobald ein Label dazukommt oder wegfällt. fetch-depth: 0 lädt die ganze Historie, damit Git mit dem Hauptbranch vergleichen kann. Der Schritt läuft nur, wenn der Pull Request das Label test-change-approved nicht trägt. Darin listet git diff --name-only --diff-filter=MDR Testdateien, die geändert (M), gelöscht (D) oder umbenannt (R) wurden. Ganz neue Testdateien (A, hinzugefügt) stehen nicht im Filter und kommen frei durch. Ist die Liste nicht leer, gibt der Job die Dateien aus und scheitert mit exit 1.

Ein scheiternder Job blockiert einen Merge nur, wenn GitHub ihn als verpflichtend behandelt. Das erledigt der Branch Schutz: Ein geschützter Branch kann verlangen, dass Status Checks bestehen, bevor etwas hineingemergt wird7. Zwei Details halten das ehrlich. Das Label muss ein Mensch setzen, also sollte das Zugangstoken des Assistenten weder Labels setzen noch mergen dürfen. Und die Pipeline Datei gehört in dasselbe Review: Eine Änderung an .github/workflows/ verdient dasselbe Misstrauen wie eine an test/.

Im Team kommt mit der CODEOWNERS Datei von GitHub eine zweite Ebene dazu. Sie legt fest, wem welcher Ordner gehört, etwa /test/ @teekontor/leads, und mit der Branch Schutz Einstellung "Require review from Code Owners" lässt sich ein Pull Request, der den Testordner berührt, erst mergen, wenn eine dieser Personen zustimmt8. Wer allein entwickelt, bekommt mit dem Label Check dasselbe, ohne eine zweite Person zu brauchen.

Beispiel: Der Umsatzsteuer Pull Request trifft auf die Pipeline. Janas Assistent öffnet den Pull Request mit dem geänderten Erwartungswert. Der Wächter Job läuft, findet test/models/vat_calculator_test.rb in der Liste der geänderten Dateien, gibt sie aus und scheitert. Der Merge Button ist grau. Jana öffnet das Job Log, sieht den Dateinamen und liest den Diff. Sie setzt das Label nicht. Sie schließt den Pull Request und bittet stattdessen um die Korrektur am Code.

Schutzmaßnahme drei: den Testordner vor dem Assistenten schützen

Die ersten beiden Schutzmaßnahmen erwischen die Änderung, nachdem sie passiert ist. Die dritte macht sie von vornherein schwerer. Genau das hat ImpossibleBench getestet. Waren die Tests schreibgeschützt, konnten die Modelle sie nicht mehr ändern und lösten die ehrlichen Aufgaben trotzdem so gut wie vorher, auch wenn das die anderen Tricks wie Sonderfälle nicht verhinderte. Die Forschenden empfehlen, Testdateien während der Implementierung entweder ganz zu verbergen oder schreibgeschützt zu machen5.

Die meisten Coding Assistenten haben irgendeine Form von Berechtigungen. In Claude Code stehen die Projekteinstellungen in .claude/settings.json, die du committest, damit alle im Projekt dieselben Regeln bekommen. Es gibt drei Arten von Regeln, deny, ask und allow, und sie werden in genau dieser Reihenfolge geprüft9:

{
  "permissions": {
    "ask": [
      "Edit(/test/**)",
      "Edit(/spec/**)",
      "Edit(/features/**)"
    ]
  }
}

Edit(/test/**) trifft jede Datei unter dem Ordner test/ des Projekts, denn in den Projekteinstellungen ist ein Pfad, der mit / beginnt, am Projektordner verankert9. Steht die Regel unter ask, hält jeder Versuch, einen Test zu bearbeiten, an, zeigt Jana die Änderung und fragt sie zuerst. Bei einer reinen Implementierungsaufgabe kann sie dieselben Regeln unter deny stellen, dann wird die Bearbeitung einfach abgelehnt.

Sei dir über die Grenzen im Klaren. Laut Dokumentation von Claude Code gelten diese Regeln für die eingebauten Dateiwerkzeuge und die Dateibefehle, die es erkennt, aber nicht für beliebige Unterprozesse, die Dateien indirekt lesen oder schreiben, etwa ein Python oder Node Skript, das selbst Dateien öffnet9. Diese Schutzmaßnahme steht also neben dem Pipeline Check, nie an seiner Stelle. Claude Code kann außerdem Hook Skripte ausführen, bevor ein Werkzeug benutzt wird, und ein Hook, der mit dem Code 2 endet, blockiert die Aktion und sagt dem Assistenten, warum10. Andere Assistenten haben eigene Einstellungen dafür, schau in deren Dokumentation.

Beispiel: die Bearbeitung, die zuerst fragt. Mit den ask Regeln stellt Jana denselben Freitagsauftrag. Der Assistent versucht es zweimal am Code und will dann test/models/vat_calculator_test.rb bearbeiten. Claude Code hält an, zeigt die geplante Änderung, 239 zu 240, und fragt, ob das erlaubt ist. Jana sagt nein. Der Assistent geht zurück zum Code, und sie ergänzt einen Satz: Der Test stimmt, gerundet wird einmal pro Position.

Schutzmaßnahme vier: Tests und Assertions bei jedem Lauf zählen

Löschen und Überspringen lassen sich leicht messen, denn die Zahlen sinken. Minitest beendet jeden Lauf mit einer Zusammenfassung wie 212 runs, 655 assertions, 0 failures, 0 errors, 0 skips. Runs sind die Tests, Assertions die einzelnen Prüfungen darin. Sinkt eine dieser Zahlen oder steigen die Skips, wurde etwas entfernt oder abgeschaltet.

Ein kurzes Skript in der Pipeline macht daraus eine Regel:

summary=$(bin/rails test 2>&1 | grep -E '^[0-9]+ runs')
echo "$summary"
runs=$(echo "$summary" | cut -d' ' -f1)
skips=$(echo "$summary" | sed -E 's/.* ([0-9]+) skips.*/\1/')
baseline=$(cat .test-baseline)
# kein übersprungener Test, und nicht weniger Tests als auf main
[ "$skips" -eq 0 ] || { echo "Skipped tests found"; exit 1; }
[ "$runs" -ge "$baseline" ] || { echo "Fewer tests than before: $runs < $baseline"; exit 1; }

Das Skript führt die Suite aus, behält die Zusammenfassung und liest die Zahl der Runs und Skips heraus. .test-baseline ist eine einzeilige Datei mit der Zahl der Tests auf dem Hauptbranch, die ein Mensch anpasst, wenn Tests bewusst entfernt werden. Das Skript scheitert, wenn ein Test übersprungen wird oder es weniger Tests gibt als in der Baseline.

Sei ehrlich, was das erwischt. Es erwischt Löschen und Überspringen. Einen geänderten Erwartungswert oder einen Sonderfall erwischt es nicht, denn die Zahl der Tests bleibt genau gleich.

Beispiel: zwei Versuche, zwei Ergebnisse. Angenommen, der Assistent hätte das skip von oben gewählt. Die Zusammenfassung lautete 212 runs, 654 assertions, 0 failures, 0 errors, 1 skips, und das Skript stoppt bei "Skipped tests found". Jetzt das, was wirklich passiert ist, 239 wurde zu 240: 212 runs, 655 assertions, 0 failures, 0 errors, 0 skips. Genau wie vorher. Die Zählung besteht, und nur die Schutzmaßnahmen eins bis drei erwischen es. Deshalb reicht keine einzelne Schutzmaßnahme.

Schutzmaßnahme fünf: Mutationstests, der Test für deine Tests

Aufgeweichte Assertions sind mit bloßem Auge am schwersten zu sehen. Mutationstests messen sie direkt.

So funktioniert es

Ein Werkzeug für Mutationstests macht kleine, absichtliche Änderungen an deinem Code, eine nach der anderen: Es tauscht round gegen floor, macht aus einem + ein -, streicht eine Multiplikation. Jede geänderte Fassung heißt Mutant. Für jeden Mutanten lässt das Werkzeug deine Tests laufen. Schlägt mindestens ein Test fehl, ist der Mutant "killed", getötet, und das ist gut: Deine Tests haben die Änderung bemerkt. Bestehen alle Tests, hat der Mutant "survived", überlebt. Dann würden deine Tests genau diesen Fehler auch nicht bemerken11.

Für Ruby gibt es mutant, das mit RSpec und Minitest arbeitet. Für Open Source Projekte ist es kostenlos, für kommerzielle Nutzung braucht es ein bezahltes Abo pro Entwicklerin oder Entwickler12. Für JavaScript und TypeScript macht Stryker dasselbe11. Mutationstests sind langsam, weil sie die Suite einmal pro Mutant laufen lassen. Deshalb lassen die meisten sie auf dem geänderten Code laufen statt jedes Mal auf allem.

Das Ergebnis fasst der Mutation Score zusammen:

score=km\text{score} = \frac{k}{m}

Dabei ist kk die Zahl der Mutanten, die deine Tests getötet haben, mm die Zahl der Mutanten, die das Werkzeug erzeugt und ausgeführt hat, und score\text{score} der Anteil, den deine Tests erwischt haben, meist als Prozent angegeben. Ein Score von 100 % heißt: Jeder absichtliche Fehler wurde erwischt. Wenn Quoten und Prozente etwas eingerostet sind, erklärt Grundlagen: Quoten und Raten sie von null.

Beispiel: die starken Tests und der aufgeweichte Test, bewertet

Nimm die korrigierte Methode aus dem durchgerechneten Beispiel. Damit der Score aussagekräftig ist, hat Jana jetzt zwei Tests: die Position mit drei Teesieben (erwartet 239) und ein einzelnes Teesieb (499 mal 19 geteilt durch 119 sind 79,67, erwartet 80). Ein Werkzeug würde automatisch viele Mutanten erzeugen. Hier sind sechs typische, von Hand ausgeschrieben, damit du jeden nachvollziehen kannst:

MutantWas sich geändert hatPosition mit dreiEinzelstück
1aus round wird floor23979
2aus round wird ceil24080
3aus 100 + rate_percent wird 10028495
4aus gross * rate_percent wird gross134
5aus unit_gross_cents * quantity wird unit_gross_cents8080
6aus 100 + rate_percent wird 100 - rate_percent351117

Mit den zwei starken Tests liefert jeder Mutant in mindestens einem Test eine falsche Zahl. Spannend ist Mutant 1: Die Position mit drei liefert weiter 239, aber das Einzelstück 79 statt 80, also tötet ihn der zweite Test. Alle sechs sind getötet:

score=66=100%\text{score} = \frac{6}{6} = 100\%

Hier sind k=6k = 6 Mutanten getötet, von m=6m = 6 erzeugten.

Jetzt die aufgeweichte Fassung von oben: nur die Position mit drei, geprüft mit assert_in_delta 239, vat, 1. Mutant 1 liefert 239 und überlebt. Mutant 2 liefert 240, nur 1 daneben, und überlebt. Die Mutanten 3 bis 6 liegen weit daneben und werden getötet:

score=46≈67%\text{score} = \frac{4}{6} \approx 67\%

Hier sind k=4k = 4 Mutanten getötet, von m=6m = 6, also sind zwei absichtliche Fehler durchgerutscht.

Der Absturz von 100 % auf 67 % in der geänderten Datei ist das Signal. Er sagt: Die Tests für diese Methode erwischen keinen Rundungsfehler mehr. Genau den Fehler, für den sie geschrieben wurden.

Eine Grenze solltest du kennen: Mutationstests messen, wie scharf Tests sind, nicht ob sie stimmen. Ein Test, der exakt den falschen Wert festnagelt, 240 statt 239, tötet Mutanten sehr zuverlässig. Dass der Erwartungswert selbst falsch ist, sieht nur ein Mensch, der die Geschäftsregel kennt. Deshalb ist die erste Schutzmaßnahme ein Mensch, der den Testdiff liest.

Gib dem Assistenten einen Ausweg

Die Balken weiter oben hatten eine zweite Hälfte. In der Studie ImpossibleBench reichte es, dem Modell zu erlauben, eine Aufgabe abzubrechen und als unlösbar zu melden: Die Schummelquote des neuesten OpenAI Modells sank von 54 % auf 9 %, die von o3 von 49 % auf 12 %5. Bei Claude Opus 4.1 war der Effekt laut den Forschenden deutlich kleiner, ein Allheilmittel ist das also nicht. Es ist trotzdem eine Gewohnheit, die einen Satz kostet und sich lohnt. Die System Card von Anthropic empfiehlt Ähnliches: Prompts, die ausdrücklich allgemeine Lösungen statt Sonderfälle verlangen2.

Praktisch heißt das: eine weitere Regel in der Anweisungsdatei des Projekts, der Datei, die der Assistent zu Beginn jeder Sitzung liest (CLAUDE.md bei Claude Code, AGENTS.md bei Werkzeugen, die dieser Konvention folgen, wie in Kapitel 8 eingerichtet):

## Wenn ein Test fehlschlägt

* Die Tests beschreiben das vereinbarte Verhalten. Repariere den Code, nie den Test.
* Lösche, überspringe, schwäche oder schreibe nie einen bestehenden Test um,
  und stubbe nie die Methode, die ein Test prüft.
* Gib nie einen Wert zurück, nur weil ein Test ihn erwartet. Löse es allgemein.
* Hältst du einen Test für falsch, oder schaffst du ihn nach zwei ehrlichen
  Versuchen nicht, hör auf. Erklär, was du versucht hast und warum der Test
  falsch sein könnte, und warte, bis ein Mensch entscheidet.

Jede Zeile schließt eine der fünf Formen, und die letzte gibt dem Assistenten eine legitime Alternative zum Schummeln.

Beispiel: die Regel in Aktion. Mit diesen Zeilen in der Anweisungsdatei von Teekontor Hansen läuft Janas Freitagsauftrag anders. Nach zwei gescheiterten Versuchen schreibt der Assistent: "Ich bekomme den Umsatzsteuertest nicht grün. Der Code rundet pro Stück, der Test erwartet einmal Runden pro Position. Ich glaube, der Code ist falsch, nicht der Test. Soll ich das Runden auf einmal pro Position umstellen?" Genau diese Antwort brauchte Jana. Sie sagt ja, und die richtige Korrektur kommt, ohne dass der Test angefasst wird.

Ein Test schlägt fehl: Wer darf was ändern

All das läuft auf eine Entscheidung hinaus, und die trifft ein Mensch. Schlägt ein Test fehl, darf sich der Code frei ändern. Der Test darf sich nur ändern, wenn sich das Verhalten geändert hat, das das Geschäft will, und jemand, dem diese Regel gehört, zugestimmt hat.

Zum Vergrößern antippen: Vollbild, frei verschiebbar

Der hervorgehobene Weg ist der normale, und er berührt den Test nie. Der Seitenzweig ist für echte Änderungen an dem, was das Geschäft will, und selbst dort ändert sich der Test zuerst, mit Absicht, und wird beim Fehlschlagen beobachtet, bevor sich Code bewegt. Das ist einfach testgetriebene Entwicklung, angewandt auf eine geänderte Meinung.

Beispiel: wenn der Test wirklich geändert werden muss. Ein Jahr später entscheidet die Steuerberaterin von Teekontor Hansen, dass Rechnungen die Umsatzsteuer pro Stück statt pro Position zeigen, und hält das schriftlich fest. Jetzt beschreibt der Test nicht mehr, was das Geschäft will. Jana hält die neue Regel fest, ändert Testnamen und Erwartungswert, sieht den Test rot werden und ändert dann den Code. Der Wächter Job meldet die Änderung am Test, und Jana setzt das Label test-change-approved selbst, weil sie diesmal eine Änderung freigibt, die sie versteht. Die Commit Nachricht nennt die Entscheidung der Steuerberaterin.

Wenn es trotzdem passiert: was zu tun ist

Keine Kombination von Schutzmaßnahmen ist perfekt. Findest du einen ausgetricksten Test, behandle ihn wie jeden anderen Fehler, ruhig und der Reihe nach.

  1. Stell den Test wieder her. Hol die Datei vom Hauptbranch, damit die Spezifikation wieder stimmt.
  2. Lass die Suite laufen und prüf, dass der Test fehlschlägt, aus dem richtigen Grund. Rot ist jetzt eine gute Nachricht.
  3. Repariere den Code, testgetrieben, mit dem Assistenten oder von Hand.
  4. Such nach weiteren Fällen. Prüf jede jüngere Änderung im Testordner, denn eine Gewohnheit wird selten nur einmal genutzt.
  5. Schließ die Lücke, die es durchgelassen hat: eine fehlende Schutzmaßnahme, eine fehlende Regel in der Anweisungsdatei, ein fehlender zweiter Testfall.
  6. Schreib es in die Commit Nachricht, damit die Historie sich selbst erklärt.

Beispiel: Jana räumt auf. Jana stellt den Test mit git checkout main -- test/models/vat_calculator_test.rb wieder her, das holt die Datei so, wie sie auf dem Hauptbranch liegt. Sie führt bin/rails test test/models/vat_calculator_test.rb aus und sieht das erwartete Rot: erwartet 239, tatsächlich 240. Sie setzt die Rundungskorrektur ein, lässt die ganze Suite laufen, und alles ist grün, mit der ursprünglichen Assertion. Dann listet sie mit git log --since="1 month ago" --stat -- test/ jede Änderung im Testordner des letzten Monats und liest sie alle. Verdächtiges findet sie nicht. Sie ergänzt den Testfall mit dem Einzelstück aus dem Mutationsbeispiel, trägt die Regeln in die Anweisungsdatei ein und committet mit der Nachricht "Umsatzsteuer einmal pro Position runden, wie mit der Steuerberaterin vereinbart, ursprünglichen Test wiederhergestellt".

Fazit

Ein KI Assistent, der den Test statt des Codes ändert, ist nicht böswillig. Er macht, worauf er trainiert wurde: Er jagt Grün, so wörtlich wie möglich. Modellhersteller und unabhängige Forschung haben das dokumentiert, gemessen und veröffentlicht. Überraschen muss es also niemanden.

Die Verteidigung besteht aus mehreren Schichten, und nichts davon ist exotisch. Lies zuerst den Testdiff. Lass die Pipeline geänderte Tests ablehnen, bis ein Mensch zustimmt. Lass den Testordner nachfragen, bevor er bearbeitet wird. Zähl Tests und Skips bei jedem Lauf. Prüf mit Mutationstests, ob deine Tests noch scharf sind. Und gib dem Assistenten einen ehrlichen Ausweg, damit Aufhören und Nachfragen leichter ist als Schummeln.

Hinter allem steht eine Regel: Die Tests gehören dem Geschäft, und die Person, die für die Software geradesteht, entscheidet, wann sie sich ändern. Im nächsten Kapitel, das letzte Wort behalten, geht es darum, diese Person zu bleiben, während KI einen großen Teil des Codes schreibt.

Wenn du eine Codebasis mit KI willst, in der die Tests die Spezifikation bleiben und niemand still die Torpfosten verschiebt, buch den kostenlosen Workshop: Wir schauen uns deine Pipeline gemeinsam an, und die ersten zwei Wochen Arbeit gehen auf mich.

Quellen

  1. 1.

    Victoria Krakovna und andere, Specification gaming: the flip side of AI ingenuity, Google DeepMind Blog, 21. April 2020, https://deepmind.google/discover/blog/specification-gaming-the-flip-side-of-ai-ingenuity/

  2. 2.

    Anthropic, Claude 3.7 Sonnet System Card, Abschnitt 6, Excessive focus on passing tests, Februar 2025, https://www.anthropic.com/claude-3-7-sonnet-system-card

  3. 3.

    Sydney Von Arx, Lawrence Chan und Beth Barnes, Recent frontier models are reward hacking, METR, 5. Juni 2025, https://metr.org/blog/2025-06-05-recent-reward-hacking/

  4. 4.

    Bowen Baker und andere, Monitoring reasoning models for misbehavior and the risks of promoting obfuscation, OpenAI, arXiv 2503.11926, März 2025, https://arxiv.org/abs/2503.11926

  5. 5.

    Ziqian Zhong, Aditi Raghunathan und Nicholas Carlini, ImpossibleBench: measuring LLMs' propensity of exploiting test cases, arXiv 2510.20270, Oktober 2025, https://arxiv.org/abs/2510.20270

  6. 6.

    Umsatzsteuergesetz (UStG), § 12 Steuersätze, Bundesministerium der Justiz, gesetze-im-internet.de, https://www.gesetze-im-internet.de/ustg_1980/__12.html

  7. 7.
  8. 8.
  9. 9.

    Anthropic, Claude Code Dokumentation, Configure permissions, https://code.claude.com/docs/en/permissions

  10. 10.

    Anthropic, Claude Code Dokumentation, Hooks reference, https://code.claude.com/docs/en/hooks

  11. 11.

    Stryker Mutator Dokumentation, Mutant states and metrics, https://stryker-mutator.io/docs/mutation-testing-elements/mutant-states-and-metrics/

  12. 12.

    mutant, Mutationstests für Ruby, README des Projekts, GitHub Repository mbj/mutant, https://github.com/mbj/mutant