# Kein Oracle für eine Wiese
> Ein Satz an Claude Opus 5, 1.922 Zeilen WebGL, eine Honigbiene im Gegenlicht, keine Zahl zum Prüfen. Was tritt an die Stelle eines Tests, wenn dein Auge der einzige Richter ist?
Source: https://rfriedmann.de/de/blog/no-oracle-for-a-meadow/ · English: https://rfriedmann.de/blog/no-oracle-for-a-meadow/
Published: 2026-08-10 · Track: log · Level: Advanced
Fast jeder Post in diesem Log endet bei einer Zahl. [imps
Decode-Tempo](/de/blog/gguf-decode-beats-llama-cpp/) gegen llama.cpp. [Ein CUTLASS-Bump,
abgesichert durch ein fp64-Oracle](/de/blog/bumping-a-dependency-you-cant-read/).
[97.000 Zeilen CUDA, die ich nicht lesen kann, sicher gemacht durch Tests, die ich lesen
kann](/de/blog/writing-cuda-with-an-agent/). Das Argument ist in allen dasselbe: Du musst
nicht reviewen, was eine Maschine geschrieben hat, wenn du es *verifizieren* kannst.
Hier kommt also der Fall, an dem das Argument bricht. Ich habe
[Claude Opus 5](https://claude.com/product/claude-code) in Claude Code einen Satz
hingetippt:
> lass ein bienchen im browser durch eine schöne grüne wiese fliegen.. beste
> grafiken, letzte standards, 3D
(Biene, Wiese, Browser, beste Grafik, neueste Standards, 3D.) Alles in
[bienchen](https://github.com/kekzl/bienchen) ist daraus entstanden: Geometrie, Shader,
Flugverhalten, Kameraarbeit, Deployment. Mein einziger weiterer Beitrag war, einmal
„starte es“ zu sagen. Es läuft auf [bienchen.kekz.org](https://bienchen.kekz.org).
Das Setup „Weite“, eins von fünf, für diesen Post headless aufgenommen. Das ist das ganze Argument der Szene in einem Frame: Die Kamera schaut mit Absicht in die Sonne, und alles Dünne, also Gras, Stängel, Blütenblätter, leuchtet von hinten auf, statt in den Schatten zu fallen.
Dafür gibt es kein Oracle. Nicht „schwer zu schreiben“: Es kann keins geben. Das
Erfolgskriterium lautet *sieht das aus wie eine Sommerwiese in tiefer Sonne*, und keine
fp64-Referenz der Welt liefert das zurück. Genau das macht es zum interessanteren
Experiment: nicht was ein Agent baut, wenn er sich selbst prüfen kann, sondern wonach er
greift, wenn ihm nichts sagen kann, ob er richtig liegt.
1
Satz, die gesamte Spezifikation
1.922
Zeilen JavaScript in zwölf Modulen, in einem Commit
233.000
Grashalme auf der höchsten Qualitätsstufe
0
Tests, Build-Schritte und Netzwerk-Requests zur Laufzeit
## Wonach es zuerst gegriffen hat
Bei „beste Grafiken“ und keinen weiteren Vorgaben gibt es einen naheliegenden Weg, das
Budget auszugeben: mehr Features. Shadow Maps, Screen-Space Reflections, volumetrische
Lichtstrahlen, ein physikalisch basiertes Material auf allem. Die Feature-Zahl ist das,
was eine Grafik-Demo üblicherweise optimiert, weil sich Features eben auflisten lassen.
So lief es nicht. Die erste Entscheidung in der Codebasis ist eine *Licht*-Entscheidung,
und jede andere Entscheidung richtet sich danach. `config.js`:
```js
export const SUN = {
elevation: 4.2, // degrees above the horizon
azimuth: 168,
};
```
Vier Komma zwei Grad. Die Sonne steht praktisch auf dem Horizont, das heißt, fast nichts
in der Szene wird von vorn beleuchtet, es wird von *hinten* beleuchtet, durch Blätter
und Blütenblätter hindurch. Das README bringt die These in einer Zeile: „Gegenlicht ist
das ganze Konzept.“
Jede Oberfläche der Wiese trägt einen Term dafür. Im Fragment-Shader des Grases ist der
ganze Effekt zwei Zeilen lang:
```glsl
// backlight through the leaf
float back = pow(clamp(dot(V, -L), 0.0, 1.0), 3.0);
col += uTransCol * uSunColor * back * pow(vSway, 1.5) * sh * uTrans;
```
`dot(V, -L)` bedeutet „wie direkt schaut die Kamera in die Sonne“, und `vSway` sagt, wie
weit oben am Halm du bist. Ein Halm glüht also an der Spitze stärker als an der Basis,
und stärker, wenn du ins Licht starrst. Die Blumen nutzen denselben Term mit einer
artspezifischen Stärke, die in ein Vertex-Attribut gebacken ist, und der des Mohns ist
mit `1.7` der höchste der Szene, gegen `1.3` bei der Kornblume und `0.35` bei Stängeln.
Der Mohn ist außerdem die einzige gesättigte Farbe der gesamten Palette. Ein Akzent, und
das Licht so gewählt, dass dieser Akzent brennt.
Das Setup „Halmspitzen“, knapp über dem höchsten Halm geparkt. Vier Arten sind in diesem Frame, und nur eine davon darf laut sein: Die Margeriten sind fast weiß, die Kornblumen sitzen dunkel vor dem Gras, und der Mohn trägt sowohl die stärkste Farbe als auch die stärkste Transmissionskonstante.
## Die Kamera weiß, wo die Sonne steht
Das hier habe ich nicht erwartet. Eine *Szene* im Gegenlicht ist eine Shader-Entscheidung.
Dafür zu sorgen, dass die Kamera tatsächlich im Gegenlicht steht, ist eine Entscheidung
der **Kameraführung**, und sie steckt als ausführbarer Code in `director.js`:
```js
// The angle from which the camera looks into the sun, seen from the subject
const INTO_SUN = Math.atan2(-sun.z, -sun.x);
/** Random azimuth, scattered `spread` radians around the backlit direction. */
function backlitAngle(spread) {
return INTO_SUN + (Math.random() - 0.5) * 2 * spread;
}
```
Drei der fünf Kamera-Setups positionieren sich mit `backlitAngle()`. Die
Verfolgungsfahrt sitzt auf der Flugbahn hinter der Biene und erbt also, was auch immer
die Biene gerade tut. Und die Flankenaufnahme würfelt ihre Seite gar nicht aus, sie
*berechnet*, auf welcher Seite sie sitzen muss, damit die Sonne gegenüber steht:
```js
// The side isn't rolled, it's chosen so the sun stands opposite.
cut(s, c) { s.side = (c.right.x * -sun.x + c.right.z * -sun.z) >= 0 ? 1 : -1; },
```
Das ist ein Skalarprodukt, das den Job eines Kameramanns macht. Niemand hat danach
gefragt. „Beste Grafiken“ impliziert das nicht. Das tust du, wenn dein eigentliches Ziel
eine Einstellung ist, die gut aussieht, und nicht ein Renderer, der Häkchen sammelt.
Derselbe Instinkt zeigt sich in dem, was die Kamera *verweigert*. Sie schneidet hart
zwischen den Setups, keine weiche Interpolation, keine Kranfahrten, und der Kommentar
sagt, warum: Ein weiches Herüberfahren „würde die Kamera zum Thema machen statt der
Biene“. Die Grammatik eines Tierfilms, gewählt und dann verteidigt.
## Maßstab aus der Natur, nicht nach Gefühl
Der billigste Realismus in jeder 3D-Szene sind korrekte Proportionen, und genau die
liegen in Hobby-Szenen fast immer daneben, weil Größen nach Augenmaß schneller gehen als
Nachschlagen. Eine Welteinheit ist hier ein Zentimeter, und die Größen sind echte:
Was die Szene tatsächlich macht
Bienenkörper ~1,4 cm, eine echte Apis mellifera-Arbeiterin misst 12-15 mm
Nahes Gras 34 cm Grundhöhe, ×0,72-1,28 Zufall, ×0,86-1,14 Büschelbildung
Mohn ~9 cm Blütendurchmesser, Kornblumenstängel 38 cm, Löwenzahn 23 cm
Biene auf 22-64 cm Höhe gehalten, knapp über einer Grasdecke von 25-50 cm
Was stattdessen meist gebaut wird
Größen so lange getunt, bis der Frame „ausgewogen aussieht“
Einheitliche Grashöhe, sodass das Feld wie gemähter Teppich wirkt
Blumen vergrößert, weil man sie sonst schlecht sieht
Fluggeschwindigkeit so gewählt, dass sie die Einstellung füllt, nicht passend zum Tier
Das README sagt unverblümt, was davon zählt: Die Größenverhältnisse stammen „aus der
Natur, nicht aus dem Gefühl“, und „das trägt mehr zum Eindruck bei als jeder Shader“.
Ich halte das für richtig, und ich halte es für den nützlichsten Satz im ganzen
Repository.
Die Büschelbildung ist das Detail, das ich ausgelassen hätte. Die Platzierung des Grases
ist zufällig, aber die Höhe wird mit einem weichen Rauschfeld multipliziert, mit dem
Kommentar „sonst wirkt es gemäht“. Wirklich gleichmäßiger Zufall wirkt künstlich, weil
echte Wiesen in Flecken wachsen. Diesen Fehlermodus kennst du nur, wenn du dir mal ein
Feld angesehen hast.
## Die Zahlen, die stattdessen vom Display kommen
Zwei Maße in der Szene sind absichtlich falsch, und sie sind die interessantesten
Entscheidungen im Repo. Die schärfere steckt in `bee.js`:
```js
const FLAP_HZ = 17.5;
```
Eine Honigbiene schlägt ihre Flügel mit rund 230 Hz. Das hier liegt um mehr als den
Faktor zehn daneben, und das muss es auch. Ein 60-Hz-Display kann Bewegung nur bis 30 Hz
darstellen, bevor Aliasing einsetzt; bei 230 Hz würden die Flügel nicht verwischen, sie
würden stroboskopieren, einfrieren und scheinbar rückwärts laufen, derselbe
Wagenrad-Effekt, den du beim Filmen eines drehenden Propellers bekommst.
Ein Flügelschlag, den du nicht rendern kannst
[diagram omitted — see the page for the chart]
Fast jedes Maß in der Szene stammt vom Tier. Dieses hier stammt vom Display, weil physikalische Genauigkeit an dieser Stelle schlicht schlechter aussähe.
Und dann geht es noch einen Schritt weiter, und das ist der Teil, den ich wirklich
bewundere. Die Flügel zu verlangsamen behebt das Aliasing, verliert aber die Verwischung:
Die Flügel einer echten Biene wirken wie ein durchscheinender Bogen, nicht wie zwei
massive Paddel. Deshalb wird jeder Flügel dreimal gezeichnet, und die Kopien hängen im
Schlagzyklus hinterher und blenden aus:
```js
// Stragglers in the stroke cycle: they draw the arc instead of strobing
const GHOSTS = [
{ lag: 0.0, alpha: 1.0 },
{ lag: 0.70, alpha: 0.36 },
{ lag: 1.35, alpha: 0.19 },
];
```
Die zwei Details, die laut Code den ganzen Eindruck tragen: der additive Flaum-Saum, den es nur gibt, weil das Licht hinter dem Tier steht, und Flügel, die als Fächer statt als Paddel wirken. Auf der niedrigen Qualitätsstufe aufgenommen, hier also ohne Tiefenschärfe und ohne Antialiasing.
Das ist Motion Blur, von Hand aus drei transparenten Kopien gebaut und nur auf das eine
Objekt der Szene angewandt, das es braucht. Die Kosten sind zwei zusätzliche Flügel-Quads
pro Flügel, bei einem vierflügeligen Insekt. Ein allgemeines Post-Process-Motion-Blur
hätte einen Vollbild-Pass gekostet und den gesamten Frame verschmiert, um ein einziges
bewegtes Teil zu reparieren.
Die zweite Abweichung ist leiser, und das Repo erwähnt sie nie. Die Reisegeschwindigkeit
in `flight.js` beträgt 105 cm/s; eine echte Sammlerin schafft eher 6,5 m/s. Der
Flugradius der Szene ist 140 cm, bei der ehrlichen Geschwindigkeit würde die Biene also
die gesamte Wiese in unter einer halben Sekunde durchqueren, und jede Einstellung wäre
ein Schemen, der aus dem Bild verschwindet. Derselbe Tausch wie bei den Flügeln, nur
stillschweigend.
Die Regel lautet also nicht „kopiere die Natur“. Sie lautet: Kopiere die Natur *überall
dort, wo sie den Kontakt mit einem 60-Hz-Rechteck überlebt*, und weiche nur dort ab, wo
sie es nicht tut. Das ist eine viel schwerere Regel, weil du dafür wissen musst, was was
ist.
Eine ehrliche Warze, wo ich schon dabei bin: `FLAP_HZ` ist in `bee.js` definiert und
steht dann noch einmal als nacktes `17.5` in `flight.js:141`, für das Wippen des Körpers.
Zwei Kopien einer Tatsache. Der [Post über den
Dependency-Bump](/de/blog/bumping-a-dependency-you-cant-read/) auf dieser Seite dreht
sich komplett darum, genau das nicht zu tun. Niemand hat es bemerkt, weil hier nichts es
bemerken *kann*.
## Die Kommentare sind das Artefakt
Lies genug von diesem Repo, und ein Muster zeigt sich. Die Kommentare beschreiben nicht,
was der Code tut. Sie beschreiben, wie es aussah, als es falsch war:
- Zum Grasbogen: Die Instanzmatrix skaliert nur Y, also muss die Eigenkrümmung des Halms
von Hand mit der Halmhöhe multipliziert werden, „ohne das stehen die Halme wie
Nadeln“.
- Zum Flaum der Biene: Ohne Rauschen wäre das „ein sauberer Lichtring statt Behaarung“,
also bekommt der additive Saum zwei miteinander multiplizierte fbm-Schichten, die ihn
in Büschel aufbrechen.
- Zur tiefen Kamera: Tiefer geht nicht, denn „im Bestand steht bei dieser Dichte immer
ein Halm direkt vor dem Objektiv“.
- Zum Himmel: HDR-Werte rund um eine 4°-Sonne werden so groß, dass das ACES-Tonemapping
sie nicht mehr abrollt und „das halbe Bild frisst aus“, daher ein Verstärkungsfaktor,
der direkt in die Shader-Ausgabe gepatcht ist.
- Zu den Folgekameras, der schärfste von allen:
```js
/* A damped follow lags permanently by v/follow — at 105 cm/s that's more than
the nominal distance. The lead compensates, but is capped at 60% of the
nominal distance: without the cap it shoves the camera through the bee. */
```
Das ist ein Regelungstechnik-Bug (ein Verzögerungsglied erster Ordnung hat bei konstanter
Geschwindigkeit einen bleibenden Regelfehler ungleich null), sein Fix und der *eigene*
Fehlermodus des Fixes, in drei Zeilen. So etwas schreibst du nicht aus ersten Prinzipien.
Das schreibst du, nachdem du zugesehen hast, wie eine Kamera hinter einer Biene
zurückfällt, einen Lead-Term eingebaut hast und dann zugesehen hast, wie die Kamera durch
die Biene fliegt.
Hier muss ich vorsichtig sein, denn die ehrliche Antwort lautet: Das kann ich nicht
beweisen. Das Repository hat zwei Commits, 86 Sekunden auseinander, und der zweite ändert
nur das README. In der History ist keine Iteration sichtbar: Die ganze Szene landet in
einem einzigen Commit. Ich sehe also die Rückstände einer Schleife aus Schauen, Fixen,
Schauen, aber ich kann „es lief, schaute und fixte“ nicht von „es hat diese Fehlermodi im
Voraus vorhergesagt“ unterscheiden. Die Git-History hält schlicht nicht fest, was in der
Session passiert ist. Was ich sagen kann: Die in diesen Kommentaren benannten Fehlermodi
sind echt, spezifisch und meist nicht offensichtlich, und eine blind geschriebene
Codebasis dokumentiert normalerweise nicht die Fehler, die sie nicht macht.
## Dann habe ich es dort laufen lassen, wo es noch nie lief
Alles oben ist Ermessenssache. Hier ist der eine Teil, aus dem ein tatsächlicher,
prüfbarer Defekt wurde, und er kam nur ans Licht, weil ich etwas getan habe, was der
Autor nie getan hat.
Um die Bilder für diesen Post zu bekommen, habe ich die Szene headless gerendert:
Chromium ganz ohne GPU, WebGL2 auf SwiftShader, ein reiner Software-Rasterizer. Das ist
ein ganz anderer Stack als der Browser, in dem das hier gebaut und angeschaut wurde. Es
startete, zeichnete die Wiese und loggte das hier:
```
THREE.WebGLProgram: Shader Error 0 - VALIDATE_STATUS false
Material Type: ShaderMaterial
Program Info Log: Fragment shader is not compiled.
ERROR: 0:123: 'patch' : Illegal use of reserved word
```
`terrain.js` nennt eine lokale Variable `patch`:
```glsl
float patch = fbm(vWorld.xz * 0.012);
```
`patch` ist ein Keyword in den Tessellation-Stages späterer GLSL-ES-Versionen, und der
Shader-Translator in ANGLE, dem Layer, den Chrome zwischen WebGL und das Darunterliegende
setzt, lehnt es als reserviert ab. Das Terrain-Material lässt sich nicht linken, und der
Boden fällt aus der Szene.
Ich sollte vorsichtig sein, was das beweist. Die Ablehnung kommt von ANGLEs Translator,
nicht vom Software-Rasterizer dahinter, und Chrome leitet WebGL auch auf Windows und
macOS durch ANGLE. Es gibt also zwei Möglichkeiten, und ich kann sie von hier aus nicht
unterscheiden: Entweder nimmt der Stack des Autors einen Pfad, der das Wort akzeptiert,
oder der Boden wurde noch nie für irgendwen gezeichnet und niemand hat es gemerkt, was
durchaus plausibel ist, denn bei 233.000 Halmen gibt es sehr wenig sichtbaren Boden, den
man vermissen könnte. Ich habe hier keine Maschine, die das klären kann. So oder so ist
der Fix eine Umbenennung von einem Wort, und so oder so gilt: *Das Wort ist kein legales
GLSL ES.* Die Bilder in diesem Post entstanden mit dieser lokal angewandten Umbenennung;
ohne sie gibt es keinen Boden unter dem Gras.
Der Bug ist trivial. Seine Form nicht:
Was kein noch so genaues Hinsehen gefunden hätte
Es sieht auf der Maschine, auf der es gebaut wurde, richtig aus
Der Shader-Quelltext sieht völlig gewöhnlich aus
Es gibt keinen Test, den man dafür hätte schreiben können
1.922 Zeilen zu lesen hätte es nicht aufgedeckt
Was es in einem Lauf gefunden hat
Ein zweites Setup mit strengerem Shader-Compiler
Null Domänenwissen nötig
Gesamtaufwand: das Ding woanders laufen lassen
Die Fehlermeldung nennt Zeile und Wort
Das ist [das Argument des CUTLASS-Posts](/de/blog/bumping-a-dependency-you-cant-read/) in
anderen Kleidern. Dort war es ein fp64-Oracle, das eine unlesbare Änderung sicher gemacht
hat. Hier gibt es kein Oracle zu bauen, aber „dieselbe Eingabe durch eine zweite,
unabhängige Implementierung“ funktioniert trotzdem, denn ein zweiter GLSL-Compiler *ist*
eine zweite Implementierung. In einem Bereich, in dem Korrektheit undefiniert ist, lohnt
es sich trotzdem, das Stückchen davon zu ernten, das definiert bleibt, und es ist billig.
## Was ich nicht verifiziert habe
Der übliche Abschnitt, und diesmal ist er länger als sonst.
Jeder Frame in diesem Post stammt aus einem Software-Rasterizer auf einer Cloud-VM, auf
der mittleren Qualitätsstufe (124.000 von möglichen 233.000 Halmen; die Makroaufnahme auf der niedrigen), mit 4 bis 30 Frames
pro Sekunde je nach Setup und mit der `patch`-Umbenennung, damit der Boden gezeichnet
wird. Die Bilder sind also dunkler, gröber und niedriger aufgelöst als dieselbe Szene auf
einer GPU, und sie sind nicht das Artefakt, das der Autor beschreibt. Ich habe das hier
nicht auf der Hardware laufen sehen, für die es gebaut wurde. Ich habe auch keinerlei
Performance-Zahlen erhoben: Die Frameraten oben sagen etwas über SwiftShader und nichts
über die Szene.
Auch die Geschmacksaussagen habe ich gegen nichts als mein eigenes Auge geprüft, und das
ist der ganze Punkt dieses Posts und zugleich seine größte Schwäche. „Gegenlicht ist die
richtige Entscheidung“ ist keine falsifizierbare Aussage. Was *sich* prüfen lässt und was
ich geprüft habe: dass der Code tut, was das README sagt. Die Sonne steht wirklich bei
4,2°, drei der fünf Einstellungen orientieren sich wirklich an `backlitAngle()`, der Mohn
trägt wirklich die höchste Transmissionskonstante, und die Halmzahl in der
Bildschirmanzeige ist wirklich die Summe der beiden Gras-Instanzzahlen für die aktive
Qualitätsstufe. Prosa und Code stimmen überein. Das ist eine niedrigere Latte als „es ist
schön“, aber eine, an der viele README-Dateien scheitern.
Und die ästhetischen Entscheidungen kann ich niemandem mit Gewissheit zuschreiben.
Three.js bringt Beispiele mit, die Trainingsdaten enthalten sehr viel Shader-Code, und
„tiefe Sonne, Gras im Gegenlicht“ ist ein etablierter Look, keine Erfindung. Was ich
behaupte, ist enger als Originalität: dass bei einem unterspezifizierten Satz das Budget
in Art Direction und physikalische Proportionen floss statt in die Feature-Zahl. So viel
ist im Diff sichtbar.
## Das Prinzip
Wo ein Oracle existieren kann, bau es, und dann musst du den Code nie lesen: Das ist imp,
und das ist der Großteil dieser Seite. Worauf ich keine gute Antwort hatte, war der
andere Fall, und das hier ist das Nächste, was ich dazu habe.
Wenn sich nachgelagert nichts testen lässt, ist der Ersatz nicht Testen. Er besteht darin,
früh und hart genug eine kleine Zahl von Vorgaben festzulegen, sodass alles danach
*gegen diese* prüfbar wird. Leg die Sonne auf 4,2° fest, und schon hat jede Kamera eine
richtige und eine falsche Seite, jedes Material schuldet einen Transmissionsterm, und die
Palette hat einen gesättigten Akzent statt eines Streits. Leg eine Einheit auf einen
Zentimeter fest, und jede Größe ist entweder die echte oder ein Bug. Nichts davon macht
die Szene schön. Es macht sie *konsistent*, und Konsistenz ist der Teil, den eine
Maschine über 1.922 Zeilen halten kann, während du wegschaust.
Der Rest, nämlich ob eine Wiese in tiefer Sonne überhaupt die richtige Idee war, bleibt
deine Sache. Es ist nur eine viel kleinere Aufgabe als vorher.
Das Ganze sind [neunzehnhundert Zeilen in einem öffentlichen
Repo](https://github.com/kekzl/bienchen), ohne Build-Schritt. Klon es, `docker compose up`,
und drück `O`, um die Kamera dem Regisseur wegzunehmen.