Raphael Friedmann
← Das Log

Wie 97.000 Zeilen CUDA von einem KI-Agenten geschrieben wurden

Meine beiden imp-Posts enden mit ‚jede Zeile wurde von Claude Code geschrieben‘. Die Frage, die immer folgt: Wie funktioniert das eigentlich, und wie vertraust du dem?

Meine beiden anderen imp-Posts enden gleich: Jede Zeile des eigenen Engine-Codes wurde von Claude Code geschrieben (eingebundener Code von Dritten, etwa third_party/stb, ausgenommen). Das zieht immer dieselbe Frage nach sich, meist mit etwas Skepsis: Wie funktioniert das eigentlich, und wie vertraust du siebenundneunzigtausend Zeilen CUDA, die eine KI geschrieben hat? Diese Schlagzeilenzahl ist die rohe Zeilenzahl der Engine-Quellen (src/ und include/, Kommentare und Leerzeilen eingeschlossen) mit Stand 4. Juni, also lass mich gleich vorweg ehrlich sein: Am Tag, an dem dieser Post erschien, lag dieselbe Zählung bei 102.425, und cloc wertet davon 72.698 als tatsächlichen Code, der Rest sind Kommentare und Leerzeilen. Hier ist die ehrliche Antwort. Sie ist weniger bemerkenswert und disziplinierter, als die Leute erwarten.

1000+
Commits, jeder vom Agenten geschrieben
~97k
Zeilen C++/CUDA in der Engine
14
getaggte Releases
970+
Tests in 91 Dateien

Wer was macht#

Am wichtigsten ist die Arbeitsteilung, und die ist nicht 50/50.

Der Mensch (ich)

  • Architekturentscheidungen
  • Welche Modelle laufen, welchen Engpässen ich nachjage
  • Den Agenten steuern und antreiben
  • „Nein“ sagen und „das ist keine Woche wert“

Der Agent

  • Schreibt den ganzen Code: Kernel, Loader, Server
  • Die Tests, die CI, das Build-System
  • Lässt die Benchmarks und den Profiler laufen
  • Auch die Reverts, und nichts von einer bestehenden Engine geforkt

Ich bin der Architekt und der Qualitätsprüfer. Er ist der Implementierer. Die interessante Frage ist nicht, ob ein Agent einen CUDA-Kernel schreiben kann, das kann er offensichtlich, sondern wie du verhinderst, dass tausend solcher Commits das Ding still verrotten lassen.

Durch Lesen kommst du hier nicht raus#

Die instinktive Antwort auf „wie vertraust du dem“ ist „lies den Code“. In dieser Größenordnung geht das nicht, und die Arithmetik ist gnadenlos. Neuartiges CUDA ordentlich zu reviewen, die Sorte, bei der eine falsche Zeile ein stiller numerischer Bug ist und kein Absturz, schafft nach meiner Erfahrung vielleicht ein paar hundert Zeilen pro Stunde, wenn du ehrlich bist, was das tatsächliche Verstehen angeht. Siebenundneunzigtausend Zeilen sind dann in der Größenordnung von drei Monaten Lesen in Vollzeit, und das ist nur die Engine; obendrauf kommen rund 40k Zeilen selbst verfasster Testcode, dazu generierte Benchmark-Daten (das Roofline-JSON), die Maschinenausgabe sind und kein verfasster Code und deshalb nicht in diese Lesesumme gehören. Außerdem bewegt sich das Ganze: Mehr als tausend Commits heißen, dass du am Ende eine andere Codebasis liest als die, mit der du angefangen hast.

Zeilenweises Review kann hier also schlicht nicht die Disziplin sein, anders als bei einem Skript, das du in ein Terminal einfügst. Du prüfst, was der Code tut, nicht, was er sagt. Genau deshalb gibt es die Gates.

Die Antwort heißt Gates, nicht Vertrauen#

Du vertraust von einem Agenten geschriebenem Code nicht, weil er sich gut liest. Du schickst ihn durch Gates. Eine Änderung landet nur, wenn sie drei Prüfpunkte passiert, in dieser Reihenfolge:

  1. Build und Tests grün

    Die volle Suite, einschließlich GPU-Kernel-Tests gegen unabhängige CPU-Referenzimplementierungen, die Art Test, die einen Kernel erwischen kann, der von Anfang an falsch war.

  2. Performance-Gate

    Das Decode-Tempo muss innerhalb von 3 % einer committeten Baseline bleiben, der Prefill innerhalb von 5 %, gemessen in einer einzigen Session, weil GPU-Zahlen zwischen Sessions driften. Ein „Speedup“, der dieses Gate auslöst, ist keiner. Der Check ist scripts/verify.sh: imp-cli --bench, ein Warmup-Zyklus plus 3 Wiederholungen, gegen eine Qwen3-8B-Q8_0-Baseline von 286,41 tok/s Decode (tg128) und 12108,57 tok/s Prefill (pp512). Das Skript sperrt keine Taktraten; es liest sie mit, und ein gedrosselter Host (Speichertakt unter 13801 MHz oder Spitzenleistung unter 400 W) macht aus einem Decode-Fehlschlag eine Warnung.

  3. Kohärenz-Gate

    Eine Suite namens degen_suite läuft gegen einen Live-Server und jagt die Fehler, die Unit-Tests nicht sehen: Wiederholungsschleifen, Reasoning, das in die Antwort leckt, Prompt-Blindheit, Vergessen bei langem Kontext, Kauderwelsch über mehrere Turns.

Erst nach allen dreien wird gemergt.

Die Kriegsgeschichte, aus der das dritte Gate entstand#

Das Kohärenz-Gate gibt es wegen eines Tages, an dem etwas schiefging.

Irgendwann stiegen die Durchsatzzahlen, während die Ausgabequalität still abfiel. Eine Änderung am Attention-Kernel machte 9 von 12 Modellen faktisch prompt-blind, sie ignorierten die eigentliche Frage, während jeder einzelne Korrektheitstest grün blieb (der Revert, #512). Die Tests bestanden, weil sie auf synthetischen Eingaben liefen, die den Fehler nicht aufdecken konnten. Ein Audit danach machte es deutlich: Nur eine Minderheit der Suite hatte eine unabhängige Ground Truth, die einen von Anfang an falschen Kernel erwischen konnte.

Also entstand degen_suite, um das Modell so zu testen, wie ein Nutzer es würde, mit echten Prompts gegen einen laufenden Server, und es wurde eine Regel festgelegt: Eine Performance-Optimierung, die die Qualität verschlechtert, ist keine Performance-Optimierung. Durchsatzzahlen sagen nichts über Korrektheit. Du brauchst beide Gates, denn der Agent treibt bereitwillig die erste Zahl nach oben, während die zweite fällt, und ein Mensch, ehrlich gesagt, auch.

Und der Agent schreibt auch die Tests#

In all dem ist ein offensichtliches Loch: Der Agent schreibt auch die Gates. Die Tests, die Kohärenz-Suite, das Benchmark-Harness, alles vom Agenten geschrieben. Was hält ihn also davon ab, einen Test zu schreiben, der aus demselben falschen Grund besteht, aus dem der Code falsch ist? Nichts Automatisches. Ein Agent, der seine eigenen Hausaufgaben korrigieren darf, produziert bereitwillig eine Suite, die grün und bedeutungslos ist, und der prompt-blinde Ausfall oben war genau das: eine Wand von Tests, die auf Eingaben bestanden, bei denen sie nie hätten fehlschlagen können.

Was das rettet, sind zwei Dinge, und beide brauchen den Menschen. Erstens zählen die Tests mit einer unabhängigen Quelle der Wahrheit, die der Agent konstruktionsbedingt nicht fälschen kann: ein Kernel, geprüft gegen eine von Grund auf neu geschriebene CPU-Implementierung derselben Mathematik, eine Kohärenz-Suite, die mit einem echten Server spricht, wie ein Nutzer es täte. Ein Test, der die Engine mit sich selbst vergleicht, beweist nichts; ein Test, der sie mit einer äußeren Referenz vergleicht, kann tatsächlich fehlschlagen. Zweitens muss jemand einem grünen Lauf grundsätzlich misstrauen und fragen, was er nicht testet, und genau das war das Audit, das fand, dass nur eine Minderheit der Suite eine unabhängige Ground Truth hatte, die ihr Geld wert war.

„Die KI schreibt ihre eigenen Tests“ ist also nicht der Haken, nach dem es klingt, solange du dir merkst, dass ein Test immer nur so gut ist wie die Ground Truth dahinter und dass die Entscheidung, welche Ground Truth du verlangst, immer noch Sache eines Menschen ist.

Was er gut kann und was nicht#

Nach tausend Commits ist die Form der Zusammenarbeit klar.

Der Agent ist hervorragend darin, schnell eine große Menge korrekten, konventionellen Code zu produzieren, den Mustern zu folgen, die schon in der Codebasis stehen, und sich durch die unglamourösen Teile zu arbeiten: den Kernel, dazu seine Referenzimplementierung, dazu den Test, dazu die drei Reverts, wenn sich die clevere Version als langsamer herausstellt. Ihm wird nicht langweilig.

Wofür er noch einen Menschen braucht, ist Urteilsvermögen. Zu wissen, welcher Engpass eine Woche wert ist. Einer grünen Testsuite zu misstrauen. Ein cleveres, aber langsameres Ergebnis für tot zu erklären, das TMA-Experiment, das gebaut, gemessen und bewusst als dokumentierter Fehlschlag behalten wurde. Die ganze Architektur über tausend Commits im Kopf zu behalten. Die Reverts, so zeigt sich, zählen genauso viel wie die Erfolge.

Die echte Antwort auf „wie vertraust du dem?“ lautet also: gar nicht. Ich schicke es durch Gates. Und jedes dieser Gates, die Referenztests, die Performance-Baseline, die Kohärenz-Suite, liegt im öffentlichen Repo, für alle, die die Hausaufgaben nachprüfen wollen.