GPT-6 Astra contre Claude Fable 5.1 : une tempête en three.js, même prompt, un seul passage

Depuis le 4 septembre 2026, Codex tourne avec GPT-6 Astra, depuis le 1^er septembre, Claude Code démarre par défaut sur Claude Fable 5.1. Les comparatifs publiés cette semaine se contentent de citer les fiches techniques. Celui-ci fait autre chose : un prompt, deux agents, un seul passage chacun, et les deux fichiers livrés s’exécutent ci-dessous, dans un bac à sable, avec leurs mesures.

Pourquoi une scène three.js plutôt qu’un exercice de code classique ?

Un test de refactoring se juge à la relecture d’un diff, ce qui laisse beaucoup de place à l’interprétation. Une scène 3D se juge en la regardant : la mer bouge ou non, les lanternes vacillent ou non, l’éclair illumine la scène ou non. Le prompt impose treize points précis (mer animée, écume, nuit, nuages, pluie, éclairs à délai aléatoire, bateau en primitives, tangage, au moins trois lanternes, contrôles orbitaux, redimensionnement, texte d’aide, un seul fichier) et une contrainte de forme, un index.html autonome chargeant three.js r170 ou plus récent depuis un CDN. C’est assez long pour départager deux modèles, assez court pour être relu en entier, et le résultat se vérifie sans être expert.

Comment le test a été mené

Le prompt, en français, est reproduit intégralement dans le banc ci-dessous. Personne n’a échangé avec les agents après l’envoi, personne n’a corrigé leur fichier avant la capture. Chaque agent a travaillé dans un dossier vide et devait livrer un seul fichier :

• Codex, modèle gpt-6-astra, effort de raisonnement xhigh.
• Claude Code, modèle claude-fable-5-1, effort de raisonnement xhigh.

Ce qui a été mesuré : la durée de génération, les tokens consommés (entrée, cache et sortie), la taille et le nombre de lignes du fichier, le respect point par point du prompt (vérifié dans le code, puis à l’écran), la syntaxe (node --check sur le module extrait), le rendu dans Chrome sans interface (SwiftShader, 1280 × 720, à 4, 12 et 20 secondes de temps réel après le chargement), les erreurs de console au chargement, et un comptage d’images en cinq secondes en rendu logiciel. Le banc ci-dessous mesure en plus les images par seconde sur votre propre machine, avec votre carte graphique : c’est la seule mesure de performance qui vaille, et elle est à vous.

Crée une scène 3D en three.js, dans un seul fichier index.html autonome, sans build ni dépendance locale (three.js chargé depuis un CDN par import map en module ES, version r170 ou plus récente).

Sujet : un voilier de pêche navigue de nuit sur une mer agitée, en pleine tempête.
- Mer : surface animée avec des vagues (déplacement de vertex), reflets sombres, écume discrète sur les crêtes si possible.
- Ciel : nuit noire, nuages bas, pluie visible (particules) poussée par le vent.
- Éclairs : toutes les quelques secondes, un éclair illumine brièvement toute la scène (flash, fort contraste, silhouette des nuages), avec un délai aléatoire entre deux éclairs.
- Bateau : coque, pont, mât, gréement et voile, modélisés uniquement avec des primitives three.js (aucun modèle externe, aucune texture externe). Il tangue et roule en suivant les vagues.
- Lanternes : au moins trois lanternes accrochées au bateau, lumière chaude et vacillante, qui éclairent le pont et l'eau autour du bateau.
- Caméra : contrôles orbitaux (OrbitControls) avec une position de départ qui met le bateau en valeur.
- Performance : viser 60 images par seconde sur un ordinateur portable ; le redimensionnement de la fenêtre est géré.
- Interface : aucune, à part un petit texte discret en bas à gauche indiquant les commandes.

Contraintes : tout le code (HTML, CSS, JavaScript) dans index.html ; pas de fichiers supplémentaires ; le fichier doit fonctionner en l'ouvrant directement dans un navigateur moderne (Chrome, Firefox, Safari). Ne pose pas de question, livre le fichier complet.

Ce que chaque candidat a livré

Les deux fichiers passent node --check, chargent three.js 0.170.0 par import map depuis jsdelivr avec OrbitControls, n’utilisent aucune texture externe et ne produisent aucune erreur de console au chargement. Sur les treize points du prompt, les deux cochent tout. La seule nuance est la pluie de Claude, faite de 5 500 traînées de ligne plutôt que de points, animées entièrement dans le vertex shader et teintées par les lanternes quand elles tombent près du bateau.

Deux idées valent d’être retenues, une de chaque côté. Claude n’anime pas sa pluie depuis JavaScript : chaque traînée est déplacée, rebouclée dans une boîte autour du bateau et étirée dans le sens du vent par le vertex shader, le processeur n’y touche jamais :

vec3 p = position + uVel * uTime;
p.x = mod(p.x + uBox.x * 0.5, uBox.x) - uBox.x * 0.5;
p.z = mod(p.z + uBox.z * 0.5, uBox.z) - uBox.z * 0.5;
p.y = mod(p.y, uBox.y);
p -= normalize(uVel) * tip * 1.6; // le second sommet dessine la traînée

Codex, lui, mesure ses propres images par seconde et baisse la définition quand la machine ne suit pas, une idée que Claude reprend aussi, en plus court :

if (frameCount >= 150) {
  const fps = frameCount / sampleTime;
  if (fps < 48 && pixelRatio > 1) {
    pixelRatio = Math.max(1, pixelRatio - 0.2);
    renderer.setPixelRatio(pixelRatio);
    spray.material.uniforms.uPixelRatio.value = pixelRatio;
  }
  frameCount = 0; sampleTime = 0; performanceSamples++;
}

Ce que l’on voit à l’écran

Les captures ci-dessous viennent de Chrome sans interface, en rendu logiciel, douze secondes après le chargement, sans intervention sur la caméra. Le banc plus haut vous donne la scène réelle, avec votre carte graphique et votre souris.

La différence saute aux yeux et tient à une lecture du prompt. Claude a pris « nuit noire » au pied de la lettre : hors des éclairs, la scène est presque monochrome, le bateau se lit à ses quatre lanternes et à leurs reflets sur l’eau, la pluie n’est visible que dans leur halo. Les nuages, l’écume et la silhouette du gréement n’apparaissent qu’au moment du flash, qui les révèle d’un coup avant de les rendre à la nuit. C’est cohérent et c’est dramatique, mais un lecteur pressé ne verra pas la moitié du travail. Codex a construit une scène plus lisible : houle grise, écume sur les crêtes, plafond nuageux, gréement complet avec ses enfléchures, quatre lanternes dont les reflets suivent la surface. Il a aussi ajouté ce que personne n’avait demandé, un texte d’aide adapté au mobile, un attribut d’accessibilité sur le canevas et une touche de pause, sans sortir du fichier unique.

Sur la mécanique, les deux bateaux tanguent et roulent avec la houle, celui de Claude en échantillonnant la hauteur de l’eau en quatre points autour de la coque avec un peu d’inertie. Les deux pluies sont poussées par le vent, les deux éclairs arrivent à intervalle aléatoire et illuminent toute la scène. Aucun des deux ne triche.

Temps, tokens et coût

Codex a été plus rapide, 13 min 33 s contre 20 min 37 s. Sur les tokens, les deux colonnes se lisent de la même façon : l’entrée compte tout le contexte relu à chaque tour de raisonnement, et l’essentiel en est servi depuis le cache, 85 % chez Codex, 98 % chez Claude. La sortie est le chiffre qui parle : 52 008 tokens pour Claude contre 23 563 pour Codex, soit 2,2 fois plus, à effort de raisonnement identique. Le fichier de Claude est pourtant le plus léger, de seize kilooctets, soit 37 % de moins, pour un cahier des charges rempli.

En prix catalogue, les deux modèles partent du même tarif de base : 10 $ par million de tokens en entrée et 50 $ en sortie. La différence se joue sur le cache, lu à 0,25 $ le million chez Anthropic contre 1 $ chez OpenAI. Au tarif de l’API, la génération de Claude vaudrait environ 4,70 $, dont 2,60 $ pour la seule sortie, celle de Codex environ 2,20 $, dont 1,18 $ de sortie. Les deux ont été payées par un abonnement, Claude et ChatGPT, qui les décompte en quota plutôt qu’en dollars : ces montants disent ce que coûterait le même passage à l’API, pas ce qui a été débité.

Lequel choisir, pour quoi ?

• Pour livrer une scène présentable du premier coup, Codex avec GPT-6 Astra : la scène la plus complète et la plus lisible, avec des attentions de finition qui ne figuraient pas dans le prompt.
• Pour une base légère à retravailler, Claude Fable 5.1 : un fichier plus court, des shaders compacts qui partagent leurs variables, une pluie qui ne coûte rien au processeur, et une direction artistique plus tranchée qu’il faudra parfois éclaircir.
• Pour la reproductibilité, ni l’un ni l’autre sans précaution : un prompt, un passage et un jour donnent une scène, le même test relancé demain en donnera une autre. C’est pourquoi le banc reste en ligne, avec le prompt et les deux fichiers téléchargeables.

Le banc sera rejoué à chaque changement de modèle par défaut dans l’un des deux outils. Pour situer ces deux agents parmi les autres, le panorama des agents de code en ligne de commande les compare sur les skills, MCP, les hooks et le bac à sable. Pour ce que ce bac à sable bloque vraiment, voir Cloisonner Claude Code et Codex. Et si la facture de Claude Code vous inquiète, la méthode de Spotify s’applique ici aussi.

Ce qu’il faut retenir

• Même prompt, un seul passage : les deux agents ont rempli les treize points demandés et livré un fichier valide, sans erreur de console.
• Codex avec GPT-6 Astra a livré en 13 min 33 s la scène la plus lisible et la plus complète, pour 23 563 tokens en sortie.
• Claude Fable 5.1 a livré en 20 min 37 s un fichier 37 % plus léger, pour 52 008 tokens en sortie, avec une nuit si noire qu’elle cache une partie du travail hors des éclairs.
• Le rendu logiciel donne 91 images en 5 s contre 44 : la scène de Claude est deux fois plus légère à calculer. Votre carte graphique donnera le vrai chiffre dans le banc.
• Le résultat vaut pour un prompt, un passage et un jour : le banc reste en ligne et sera rejoué à chaque changement de modèle.