# 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?
Source: https://rfriedmann.de/de/blog/writing-cuda-with-an-agent/ · English: https://rfriedmann.de/blog/writing-cuda-with-an-agent/
Published: 2026-06-09 · Track: log · Level: Advanced
Meine beiden anderen [imp](https://github.com/kekzl/imp)-Posts enden gleich: Jede Zeile
des eigenen Engine-Codes wurde von [Claude Code](https://claude.com/product/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
## 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](/de/blog/llms-in-the-terminal/). 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:
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.
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.
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](https://github.com/kekzl/imp/pull/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](/de/blog/optimizing-kernels-consumer-blackwell/), 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](https://github.com/kekzl/imp), für alle,
die die Hausaufgaben nachprüfen wollen.