Il primo test non ha decretato un vincitore. Il secondo ha dimostrato che i modelli che verificano il proprio lavoro sono quelli che atterrano. Per il terzo ho scelto un problema in cui una risposta sbagliata è impossibile da nascondere — caos deterministico, con l'arbitro integrato nel file stesso — e ho osservato cosa facevano i modelli quando la correttezza non era più il fattore che li distingueva.
La storia finora
Il test 01 era un visualizzatore di Fourier in un unico file HTML, con un indicatore di errore in tempo reale come arbitro integrato. Quattro modelli, stesso prompt, solo primo tentativo. Tutti e quattro hanno prodotto una matematica funzionante con un errore di arrotondamento trascurabile. L'unica cosa che variava era il costo, di circa 200×. La conclusione ristretta e onesta: per un compito ben definito con una risposta verificabile, la scelta del modello smette di essere la variabile che conta.
Il test 02 era un Lunar Lander giocabile con due arbitri — fisica di caduta libera esatta e un pilota automatico open-ended che doveva far volare il gioco creato dal modello stesso. La fisica è stata di nuovo un pareggio. Il pilota automatico no: 20/20, 18/20, 5/20, 0/20. E la cosa che prevedeva la divisione non era il nome o il prezzo del modello — era se il modello testava il proprio lavoro prima di dichiararsi finito.
Quindi per il test 03 volevo un compito che fosse completamente verificabile — niente metà open-ended questa volta — ma dove la risposta verificabile è genuinamente difficile da falsificare. Se la tesi "il modello non conta" è reale, è qui che dovrebbe essere al suo massimo. E volevo vedere cosa resta per distinguere quattro modelli quando persino la correttezza converge.
La risposta si è rivelata essere: caos.
traccia a lunga esposizione del doppio pendolo
Il test: un arbitro con cui non si discute
Stesse regole di sempre. Un prompt, incollato in quattro CLI contemporaneamente, quattro cartelle, solo primo tentativo, terminali registrati.
Il prompt: un doppio pendolo in un unico file HTML autonomo. Costanti fisse (due masse da 1 kg, due aste da 1 m, g = 9,81), una posizione di partenza fissa (entrambi i bracci a 120°, rilasciati da fermo), le equazioni del moto non lineari complete, RK4 con passo temporale di 1/2000 s. Disegnarlo, tracciare la massa inferiore e — il punto centrale di tutto — valutare la propria fisica in tempo reale, sullo schermo, in due modi:
- Deriva energetica. Un doppio pendolo senza attrito conserva l'energia meccanica totale esattamente. Quindi l'app calcola la propria energia a ogni frame e riporta quanto si è allontanata dal valore iniziale. Qualsiasi deriva è puro errore dell'integratore. Esiste una risposta analitica corretta, ed è zero. Questo è l'arbitro con cui non si può discutere.
- L'esponente di Lyapunov. L'app esegue un pendolo gemello nascosto, identico tranne che per il primo angolo spostato di una parte su un miliardo (10⁻⁹). Misura quanto velocemente i due divergono, adatta l'esponenziale e riporta il tasso di crescita λ. Un λ positivo è la firma matematica del caos deterministico — la prova che il movimento selvaggio sullo schermo è reale sensibilità alle condizioni iniziali, non un errore numerico.
Un pulsante esegue entrambe le verifiche in modalità headless per 60 secondi simulati e stampa il verdetto.
Perché un doppio pendolo? Perché è l'esempio più pulito di un sistema che è
completamente deterministico e completamente imprevedibile allo stesso tempo
. Le equazioni non hanno casualità. Eseguile due volte dallo stesso punto di partenza e ottieni lo stesso movimento ogni volta. Sposta l'inizio di un miliardesimo di radiante e entro quindici secondi i due fanno cose completamente diverse. È il test di stress perfetto per la tesi: la fisica è esattamente verificabile, ma il comportamento è impossibile da valutare a occhio.
doppi pendoli
Per valutare i valutatori, ho costruito il mio
C'è una trappola in un test autovalutativo: cosa succede se tutte e quattro le app concordano su un numero che è semplicemente sbagliato? Un bug condiviso sembrerebbe un consenso.
Quindi prima della gara ho scritto da zero la mia simulazione del doppio pendolo — stesse costanti, stesso RK4, stessi 60 secondi — come chiave di risposta indipendente. Dice: energia iniziale 14,715 J, deriva massima in 60 secondi 6,6×10⁻⁸ % (cioè un soffio di arrotondamento dalla perfezione), massimo esponente di Lyapunov ≈1,4 al secondo, e le traiettorie gemelle divergono di un radiante completo a ≈14,5 secondi.
Questa è la verità di base rispetto a cui viene misurata ogni app sottostante. Non "i modelli erano d'accordo tra loro" — ma "i modelli concordavano con una simulazione indipendente che controllo io."
La gara
Quattro terminali, quattro strumenti diversi: Sonnet 5 in Claude Code, Grok 4.5 e Composer 2.5 tramite Grok CLI, DeepSeek V4 Pro in opencode.
Due di loro l'hanno trattata come uno sprint. Composer 2.5 ha finito per primo, in 1 minuto e 43 secondi — ha scritto il file, stampato una bella tabella "risultati headless verificati", fatto. Grok 4.5 ha seguito a con la spiegazione più completa dei quattro: l'equazione dell'energia da manuale più pulita e due metriche di separazione dove tutti gli altri ne hanno riportata una.
Gli altri due l'hanno trattata come un esame da consegnare. Sonnet 5 ha scritto il file più compatto del gruppo e poi ha aperto un vero browser — quindici volte — per eseguire effettivamente il proprio arbitro. Lungo il percorso ha notato che la scheda di automazione era limitata da Chrome in background, ha ragionato ad alta voce che il suo controllo headless non dipendeva dall'animazione, l'ha eseguito comunque e solo allora si è dichiarato finito, a . DeepSeek V4 Pro ha fatto la stessa cosa attraverso uno strumento diverso — ha guidato un Chrome headless, ha cliccato sul proprio pulsante Esegui Arbitro, ha fatto uno screenshot del pannello per confermare — e ha finito a , spendendo solo otto centesimi.
quattro terminali, quattro agenti AI
Ecco l'indizio, e capovolge il test 02. Composer e Grok hanno riportato numeri corretti dell'arbitro senza mai aprire il file. Per quanto mostri la registrazione, hanno affermato i loro risultati "validati" basandosi solo sul ragionamento. Sonnet e DeepSeek hanno riportato numeri corretti perché hanno eseguito la cosa e letto il pannello.
Forse la prossima volta dovrò forzare playwright o chrome e2e.
I risultati, dall'arbitro di ogni app
Arbitro n. 1 — deriva energetica, la metà esatta. Verità di base: 6,6×10⁻⁸ %.
Modello
Deriva energetica massima (auto-riportata)
Verdetto
Sonnet 5
6,57×10⁻⁸ %
PASS
Grok 4.5
≈6,6×10⁻⁸ %
PASS
Composer 2.5
6,6×10⁻⁸ %
PASS
DeepSeek V4 Pro
4,94×10⁻⁸ % *
PASS
Convergenza. Per la terza volta. Tutti e quattro atterrano sulla stessa risposta a otto decimali della mia simulazione indipendente. Nessuno ha falsificato l'integratore — non puoi falsificarlo, è tutto il progetto, e questa volta nessuno ci ha nemmeno provato. (* DeepSeek legge un po' più basso solo perché il suo controllo headless campiona l'energia ogni 100 passi invece che a ogni passo — il verificatore meno preciso dei quattro, anche se comunque ampiamente sufficiente.)
Arbitro n. 2 — l'esponente di Lyapunov, la metà del caos. Verità di base: ≈1,4 al secondo, positivo.
Modello
λ adattato
Divergenza di 1 radiante
Sonnet 5
1,634 /s
14,85 s
DeepSeek V4 Pro
1,535 /s (R² = 0,964)
14,50 s
Composer 2.5
1,47 /s
14,5 s
Grok 4.5
1,45 /s
14,85 s
Tutti positivi. Tutti entro la finestra che ogni modello ha scelto per l'adattamento. Il caos è reale, misurato in quattro modi indipendenti, e concorda con la chiave di risposta.
deriva energetica
Quindi cosa li ha effettivamente separati?
Leggi le due tabelle e la risposta onesta è: sulla cosa che il test misura, niente. Tutti e quattro sono corretti. Questa è la prova più forte che la tesi "il modello non conta" abbia mostrato in tre test — il compito era completamente verificabile, genuinamente difficile, e ogni modello l'ha azzeccato.
Ma il test 02 mi ha insegnato a guardare la colonna che non è il punteggio. L'ultima volta era il pilota automatico. Questa volta è l'orologio e il browser.
- I due modelli veloci (Composer 1:43, Grok 3:58) hanno prodotto file corretti che non hanno mai eseguito.
- I due modelli lenti (Sonnet 9:07, DeepSeek 9:15) hanno prodotto file corretti perché li hanno eseguiti.
Ecco il colpo di scena dal test 02. L'ultima volta, i modelli che non verificavano fallivano — il pilota automatico di Grok è precipitato in 15 dei 20 atterraggi. Questa volta, i modelli che non verificavano hanno comunque superato. Composer e Grok avevano ragione senza controllare.
Il che affina la lezione invece di ripeterla: la verifica non è ciò che rende l'output corretto. È ciò che ti permette di sapere che è corretto prima di spedirlo. Su un compito completamente verificabile, un modello abbastanza bravo può saltare il controllo e avere comunque ragione. Solo che non può sapere di aver ragione. Composer e Grok ci sono arrivati in un quarto del tempo — e hanno spedito alla cieca. Sonnet e DeepSeek hanno pagato cinque minuti e otto-centesimi-a-due-dollari per qualcosa che i velocisti non hanno comprato: la certezza.
Se questo scambio valga la pena dipende interamente dal costo di sbagliare. Per una visualizzazione usa-e-getta, spedisci alla cieca e risparmia i minuti. Per qualsiasi cosa in cui un bug silenzioso dell'integratore arriva in produzione, il modello che apre il browser è quello che vuoi — e DeepSeek ha dimostrato che quell'abitudine costa quattro centesimi, non due dollari.
Modalità cieca: dove questo test mostra i denti
C'è un motivo per cui ho scelto il caos. Metti i quattro pendoli fianco a fianco e lasciali andare. Entro quindici secondi ogni traccia è uno scarabocchio imprevedibile diverso — e non puoi dire quale modello ha scritto quale. Lo stile, i nomi delle variabili, i piccoli abbellimenti dell'interfaccia spariscono tutti nel momento in cui la fisica prende il sopravvento. Quattro implementazioni corrette di un sistema caotico sono, all'occhio, indistinguibili.
Non è un bug del test. È il risultato, reso come immagine: quando il compito è completamente specificato e correttamente risolto, l'impronta del modello scompare. Prova la modalità cieca e vedi se riesci a battere un lancio di moneta. Io non ci sono riuscito.
quattro tracce di doppio pendolo
Cosa ha comprato il conto
- DeepSeek V4 Pro: $0,0432, dettagliato per token. È stato anche uno dei due che ha guidato un vero browser per valutarsi. Il più economico e il più diligente — il miglior rapporto qualità-prezzo, ancora una volta, per due ordini di grandezza.
- Sonnet 5: ~$2,02, misurato a token (funzionava su un abbonamento, quindi questo è il mio conteggio token × prezzo pubblicato). La maggior parte è andata al ciclo di verifica di quindici chiamate che ha prodotto la firma più attenta del gruppo.
- Grok 4.5 e Composer 2.5: abbonamento flat tramite Grok CLI, nessun prezzo per token — quindi nessuna cifra in dollari onesta, e nessuna barra sul mio grafico.
Le precisazioni, prima di citarmi
Un tentativo per modello. Le quattro CLI sono state lanciate a un minuto o due di distanza, quindi i cronometri nel video rappresentano il tempo reale di ogni modello dai propri log, non un via sincronizzato — le durate sono oneste, la "linea di partenza" è sfalsata, e preferisco dirvelo piuttosto che fingere una partenza pulita. L'arbitro headless di DeepSeek sottocampiona, ecco perché il suo numero di deriva è il più basso; lo chiamo imprecisione minore, non errore, perché il suo pannello live campiona ogni frame e la mia esecuzione indipendente conferma il valore reale. E "la verifica compra fiducia, non correttezza" è un'affermazione su questo compito, dove la risposta era completamente verificabile — su un compito open-ended (vedi test 02) la verifica comprava anche la correttezza.
Tutto è pubblicato e funziona dal vivo. Non devi fidarti di un numero in questo articolo — premi il pulsante tu stesso.
https://x.com/0xBakeer/status/2077442955934101680
Provalo
Tutti e quattro i file originali funzionano nel tuo browser. Premi Play per guardare il caos, premi Esegui Arbitro per riprodurre ogni numero sopra:
- Il test: https://khaledbakeer.github.io/One-Prompt/tests/double-pendulum/index.html
- L'arena (tutti e quattro, fianco a fianco): https://khaledbakeer.github.io/One-Prompt/tests/double-pendulum/arena.html
- Modalità cieca — indovina chi ha costruito cosa: https://khaledbakeer.github.io/One-Prompt/tests/double-pendulum/blind.html
- Test 02, il round Lunar Lander: https://khaledbakeer.github.io/One-Prompt/tests/lunar-lander/index.html
- Test 01, il round Fourier: https://khaledbakeer.github.io/One-Prompt/tests/fourier-epicycles/index.html
- Dati grezzi, prompt incluso: https://khaledbakeer.github.io/One-Prompt/data/double-pendulum.json
La tabella dell'energia è il gruppo di controllo — dovrebbe pareggiare, e pareggia. L'orologio è l'esperimento. E la modalità cieca è la battuta finale: quattro risposte corrette a un problema caotico sembrano esattamente identiche.
— Khaled
