L'esperimento
Ho preso 10 compiti di programmazione reali — il tipo di compiti che gli sviluppatori svolgono effettivamente ogni giorno — e ho inviato lo stesso identico prompt sia a GPT-5.4 che a Claude Opus 4.6. Stesso prompt di sistema, stesso contesto, stessi criteri di valutazione.
Nessun benchmark sintetico. Nessun esempio selezionato ad arte. Solo compiti reali valutati su tre dimensioni:
- Correttezza (funziona senza modifiche?)
- Qualità del codice (leggibilità, tipi, gestione degli errori, casi limite)
- Efficienza (utilizzo di tokens, tempo di risposta, numero di prompt di follow-up necessari)
Ogni dimensione è valutata da 1 a 10. Punteggio massimo possibile per compito: 30.
L'accesso ai modelli è avvenuto tramite le rispettive API ai prezzi standard: GPT-5.4 a $2.50/$15 per million tokens e Claude Opus 4.6 a $15/$75 per million tokens.
Ecco i 10 compiti e cosa è successo esattamente.
Task 1: Creare un Endpoint API REST
Prompt: "Create a POST /api/users endpoint in Express.js with TypeScript. Validate email format and password strength (min 8 chars, 1 uppercase, 1 number). Hash the password with bcrypt. Store in PostgreSQL via Prisma. Return the user without the password field. Handle duplicate emails with a 409 status."
Risultato GPT-5.4
Codice pulito e pronto per la produzione. Lo schema di validazione Zod era preciso. L'hashing bcrypt ha utilizzato una costante corretta per i salt round. La query Prisma ha utilizzato select per escludere il campo password a livello di database invece di eliminarlo dall'oggetto della risposta — una pratica di sicurezza sottile ma importante. I tipi TypeScript erano rigorosi.
Risultato Claude Opus 4.6
Anche questo pulito e corretto. Ha utilizzato un approccio di validazione Zod simile, ma ha aggiunto un middleware di rate limiting per l'endpoint e ha incluso un commento spiegandone il motivo. L'esclusione della password ha utilizzato la funzione omit di Prisma. Ha aggiunto un try/catch con tipi di errore specifici per le violazioni dei vincoli di unicità di Prisma.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 10 | 10 |
| Qualità del codice | 9 | 9 |
| Efficienza | 9 | 8 |
| Totale | 28 | 27 |
Vincitore: GPT-5.4 (di poco, per velocità e concisione)
Entrambi gli output sono stati eccellenti. GPT-5.4 è stato più veloce e ha utilizzato meno tokens. Opus ha aggiunto il middleware di rate limiting senza che fosse richiesto — utile ma non sollecitato. Per compiti API ben definiti, i modelli sono essenzialmente intercambiabili.
Task 2: Creare un componente React
Prompt: "Create a React component called DataTable that accepts generic typed data, supports sortable columns, pagination (client-side), a search filter, and row selection with checkboxes. Use TypeScript generics. No UI library — just HTML/CSS with CSS modules. Include proper ARIA attributes."
Risultato GPT-5.4
Ha fornito un componente generico ben strutturato. I generics di TypeScript sono stati usati correttamente per la definizione delle colonne e i tipi di dati. La logica di ordinamento era pulita con un hook personalizzato useSortable estratto. La paginazione ha utilizzato useMemo per le prestazioni. Gli attributi ARIA erano corretti — role="grid", aria-sort sugli header ordinabili, aria-selected sulle checkbox.
Risultato Claude Opus 4.6
Struttura simile ma con alcune differenze. Opus ha creato un hook useDataTable che incapsulava la logica di ordinamento, paginazione e filtraggio — una separazione più pulita ma con maggiore astrazione. I generics di TypeScript erano altrettanto corretti. Mancava aria-sort sulle celle dell'header. Il modulo CSS includeva un layout responsive che passava alla visualizzazione a schede su mobile, il che non era richiesto ma è stata un'aggiunta ponderata.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 10 | 9 |
| Qualità del codice | 9 | 9 |
| Efficienza | 9 | 8 |
| Totale | 28 | 26 |
Vincitore: GPT-5.4
L'implementazione ARIA di GPT-5.4 è stata più completa, il che è fondamentale per un componente che verrà utilizzato in tutta l'applicazione. Come notato dal confronto di MindStudio, GPT-5.4 eccelle nella generazione di boilerplate, inclusi componenti React e interfacce TypeScript.
Task 3: Scrivere una query SQL complessa
Prompt: "Write a PostgreSQL query that returns the top 10 customers by lifetime value (total order amount) who have placed at least 3 orders in the last 12 months, including their most recent order date, average order value, and the percentage change in their spending compared to the previous 12-month period. Use CTEs for readability."
Risultato GPT-5.4
Tre CTE: una per l'aggregazione del periodo corrente, una per l'aggregazione del periodo precedente, una per il calcolo della percentuale. Pulito, corretto, ben formattato. Ha utilizzato COALESCE per gestire i clienti senza dati nel periodo precedente. Ha aggiunto un commento con un suggerimento per l'indice.
Risultato Claude Opus 4.6
Quattro CTE con una struttura leggermente diversa: ha separato il calcolo della "data dell'ultimo ordine" in una propria CTE per evitare una subquery correlata. Ha aggiunto un NULLIF per prevenire la divisione per zero nel calcolo della percentuale — un vero caso limite che GPT-5.4 ha mancato. Ha incluso un'alternativa con window function in un blocco di commento.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 9 | 10 |
| Qualità del codice | 8 | 9 |
| Efficienza | 9 | 8 |
| Totale | 26 | 27 |
Vincitore: Claude Opus 4.6
Il caso limite della divisione per zero ha fatto la differenza. In un SQL di produzione, questo tipo di bug causa una corruzione silenziosa dei dati. Opus individua costantemente i casi limite che contano nelle pipeline di dati del mondo reale.
Task 4: Debuggare una Race Condition
Prompt: Ho fornito 3 file (~200 righe totali) di un'applicazione Node.js con un fallimento intermittente dei test. Il bug era una race condition in un livello di caching in cui cache miss simultanei potevano innescare query duplicate al database e uno stato incoerente. "Find the bug, explain why it only manifests intermittently, and provide a fix."
Risultato GPT-5.4
Ha identificato il percorso corretto del codice per la cache miss. Ha suggerito di aggiungere un lock mutex utilizzando async-mutex. La soluzione era corretta ma trattava il sintomo piuttosto che la causa principale — serializzava tutti gli accessi alla cache, il che avrebbe danneggiato le prestazioni sotto carico.
Risultato Claude Opus 4.6
Ha identificato lo stesso percorso di codice ma ha anche tracciato l'incoerenza dello stato fino a un secondo problema: l'aggiornamento della cache non era atomico — c'era una finestra tra il controllo di lettura e la scrittura dove un'altra richiesta poteva inserirsi. Opus ha suggerito un pattern "single-flight" (accorpando richieste identiche simultanee) piuttosto che un mutex globale. La soluzione era più chirurgica e preservava la concorrenza per le chiavi di cache non in conflitto.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 7 | 10 |
| Qualità del codice | 7 | 9 |
| Efficienza | 8 | 8 |
| Totale | 22 | 27 |
Vincitore: Claude Opus 4.6
Un divario netto. Opus ha compreso il modello di concorrenza abbastanza profondamente da suggerire una soluzione mirata. Questo è in linea con il punteggio dell'80.8% di Claude Opus 4.6 su SWE-bench Verified, che testa esattamente questo tipo di risoluzione di bug nel mondo reale.
Task 5: Revisione del codice
Prompt: Ho fornito una pull request di 350 righe che aggiungeva un nuovo modulo di elaborazione dei pagamenti. "Review this PR for bugs, security issues, performance problems, and code quality. Prioritize findings by severity."
Risultato GPT-5.4
Ha trovato 5 problemi: un controllo null mancante sulla risposta del pagamento, una promise rejection non gestita, un timeout hardcoded che dovrebbe essere configurabile, una chiave di idempotenza mancante e un suggerimento per estrarre i magic numbers in costanti. Organizzato per gravità. Chiaro e attuabile.
Risultato Claude Opus 4.6
Ha trovato 8 problemi: gli stessi 5 trovati da GPT-5.4 più altri tre — una vulnerabilità TOCTOU (time-of-check-time-of-use) nella validazione dell'importo, una potenziale fuga di informazioni nella risposta di errore che esponeva stack traces interni, e un problema sottile in cui la logica di retry poteva causare un doppio addebito se la prima richiesta avesse avuto successo ma la risposta fosse andata persa. Ogni scoperta includeva il numero di riga specifico e una soluzione suggerita.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 8 | 10 |
| Qualità del codice | 8 | 10 |
| Efficienza | 9 | 8 |
| Totale | 25 | 28 |
Vincitore: Claude Opus 4.6
Le tre scoperte aggiuntive erano tutte critiche per la sicurezza. Il bug del doppio addebito da solo potrebbe costare a un'azienda una quantità significativa di denaro e reputazione. Il 76% di Opus su MRCR v2 (ragionamento multi-file) si traduce direttamente in una migliore revisione del codice su moduli complessi.
Task 6: Scrivere una Suite di Test
Prompt: "Write comprehensive tests for this authentication middleware using Vitest. Cover: valid tokens, expired tokens, malformed tokens, missing authorization header, revoked tokens, rate limiting, and concurrent authentication requests." Ho fornito il file sorgente del middleware (~120 righe).
Risultato GPT-5.4
Ha generato 18 casi di test organizzati in blocchi describe puliti. Ogni scenario del prompt è stato coperto. Ha aggiunto tre casi limite extra: token stringa vuota, token con algoritmo errato e header di autorizzazione contenente solo spazi bianchi. I mock erano ben strutturati utilizzando vi.mock. Le descrizioni dei test erano chiare e seguivano il pattern "should X when Y".
Risultato Claude Opus 4.6
Ha generato 15 casi di test. Tutti gli scenari richiesti sono stati coperti. La struttura del test utilizzava una helper factory per creare tokens con diverse proprietà — intelligente ma ha aggiunto complessità. Mancava il test per "richieste di autenticazione simultanee" che era stato esplicitamente richiesto. I mock erano più puliti ma il numero di test era inferiore.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 10 | 8 |
| Qualità del codice | 9 | 9 |
| Efficienza | 9 | 8 |
| Totale | 28 | 25 |
Vincitore: GPT-5.4
GPT-5.4 ha seguito il prompt più fedelmente e ha aggiunto casi limite significativi. Come notato da molteplici confronti, la generazione di test di GPT-5.4 è tra le migliori, scrivendo suite complete con una forte copertura dei casi limite.
Task 7: Rifattorizzare un modulo monolitico
Prompt: Ho fornito un modulo Python di 500 righe che gestiva la gestione degli utenti — registrazione, autenticazione, aggiornamenti del profilo, reset della password e notifiche email, tutto in un unico file. "Refactor this into a clean module structure following SOLID principles. Maintain backward compatibility with the existing public API."
Risultato GPT-5.4
Diviso in 5 moduli: auth.py, registration.py, profile.py, password.py, notifications.py. Ha aggiunto un __init__.py che riesportava le funzioni pubbliche originali per la compatibilità all'indietro. Separazione pulita. Ogni modulo era autonomo.
Tuttavia, ha dimenticato di aggiornare la dipendenza circolare tra registration.py e notifications.py — la registrazione invia un'email di benvenuto e il modulo di notifica aveva bisogno di un riferimento ai dati utente. Il codice sarebbe andato in crash all'importazione.
Risultato Claude Opus 4.6
Diviso in 6 moduli con la stessa suddivisione più un types.py per le classi di dati condivise. Fondamentalmente, ha identificato il problema della dipendenza circolare e lo ha risolto introducendo un pattern basato su eventi — la registrazione emette un evento "user_created" e il modulo di notifica si iscrive ad esso. L'__init__.py per la compatibilità all'indietro era identico nell'approccio.
Opus ha anche aggiunto un breve commento in cima a ogni modulo spiegando cosa vi appartiene e cosa no — fungendo da guida per i futuri sviluppatori.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 6 | 10 |
| Qualità del codice | 8 | 10 |
| Efficienza | 8 | 7 |
| Totale | 22 | 27 |
Vincitore: Claude Opus 4.6
Il bug della dipendenza circolare avrebbe causato un fallimento in produzione. Questo è il tipo di ragionamento multi-file in cui Opus eccelle — comprende le dipendenze tra file e le implicazioni architettoniche prima di generare codice.
Task 8: Scrivere documentazione tecnica
Prompt: "Write API documentation for this payment processing SDK. Include: overview, authentication, rate limits, error codes, 5 endpoint descriptions with request/response examples, a webhook section, and a migration guide from v1 to v2." Ho fornito il codice sorgente dell'SDK.
Risultato GPT-5.4
Documentazione completa che copre tutte le sezioni richieste. Le descrizioni degli endpoint erano dettagliate con esempi curl e schemi di risposta. La sezione dei codici di errore era ben organizzata in una tabella. La guida alla migrazione era chiara con esempi di codice prima/dopo. Formattazione markdown pulita.
Risultato Claude Opus 4.6
Anch'esso completo, con una struttura leggermente diversa — è iniziato con una sezione "Quick Start" prima dei documenti dettagliati, che è un buon pattern per la documentazione per sviluppatori. La sezione webhook era più dettagliata, includendo il comportamento di retry, il codice di verifica della firma e una guida al test. La guida alla migrazione includeva una cronologia di deprecazione che non era nel codice sorgente — l'ha dedotta dai pattern di versionamento.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 9 | 9 |
| Qualità del codice | 9 | 9 |
| Efficienza | 9 | 8 |
| Totale | 27 | 26 |
Vincitore: Pareggio (GPT-5.4 per un punto sull'efficienza)
Entrambi hanno prodotto un'ottima documentazione. La differenza di qualità è trascurabile. GPT-5.4 è stato leggermente più veloce. Per i compiti di documentazione, entrambi i modelli funzionano bene — questo concorda con i rapporti degli sviluppatori secondo cui la qualità della documentazione è paragonabile tra i modelli di frontiera.
Task 9: Progettare l'architettura di un sistema
Prompt: "Design the architecture for a real-time collaborative document editor supporting 10,000 concurrent users. Cover: data model, conflict resolution strategy (CRDTs vs OT), WebSocket infrastructure, storage layer, presence system, and deployment topology. Provide a diagram in Mermaid syntax."
Risultato GPT-5.4
Ha scelto OT (Operational Transformation) con un server centrale. Architettura ragionevole con Redis per la presenza, PostgreSQL per l'archiviazione dei documenti e un gateway WebSocket dietro un load balancer. Il diagramma Mermaid era pulito. L'analisi era competente ma seguiva un copione standard — non ha analizzato a fondo i tradeoff tra CRDTs e OT per questa scala specifica.
Risultato Claude Opus 4.6
Ha iniziato ponendo una domanda chiarificatrice sul modello del documento (rich text vs. plain text vs. dati strutturati), a cui ho risposto come "rich text". Quindi ha raccomandato i CRDTs (nello specifico Yjs) rispetto a OT, con una spiegazione dettagliata del perché i CRDTs siano superiori a questa scala — la consistenza eventuale senza un sequencer centrale elimina il single point of failure.
L'architettura includeva un dettaglio innovativo: un livello "document gateway" che gestisce le operazioni di merge dei CRDTs e funge sia da terminatore WebSocket che da livello di persistenza dello stato. Il diagramma Mermaid includeva frecce di flusso dati con annotazioni di protocollo. La sezione di deployment raccomandava una strategia di partizionamento specifica (shard per ID documento) con ragionamenti sulle hot partitions.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 8 | 10 |
| Qualità del codice | 7 | 10 |
| Efficienza | 8 | 7 |
| Totale | 23 | 27 |
Vincitore: Claude Opus 4.6
L'architettura è dove il divario di profondità di ragionamento tra questi modelli è più visibile. Opus ragiona in modo più esplicito sul problema prima di generare l'output, analizzando i casi limite e ponendo domande chiarificatrici quando i requisiti sono genuinamente ambigui.
Task 10: Scrivere uno script di deployment DevOps
Prompt: "Write a GitHub Actions workflow that: builds a Docker image, runs tests, pushes to ECR, deploys to ECS Fargate with blue-green deployment, runs a smoke test against the new deployment, and rolls back automatically if the smoke test fails. Use OIDC for AWS authentication — no hardcoded credentials."
Risultato GPT-5.4
Un file di workflow completo con tutti i passaggi richiesti. La configurazione OIDC era corretta utilizzando aws-actions/configure-aws-credentials con il role ARN. Il blue-green deployment ha utilizzato l'aggiornamento del servizio ECS con il controller di deployment CODE_DEPLOY. Lo smoke test era un health check basato su curl. Il rollback veniva attivato dal codice di uscita dello smoke test. Ben commentato, pronto per la produzione.
Risultato Claude Opus 4.6
Anche questo completo e corretto. Ha utilizzato lo stesso approccio OIDC. La differenza principale era nello smoke test — Opus ha creato un test più approfondito che controllava non solo l'endpoint di salute ma verificava anche che il deployment stesse servendo la versione corretta controllando un endpoint /version. Il rollback includeva un passaggio di notifica Slack. Tuttavia, il workflow era notevolmente più prolisso — il 40% di righe in più per funzionalità simili.
Punteggi
| Dimensione | GPT-5.4 | Opus 4.6 |
|---|---|---|
| Correttezza | 10 | 10 |
| Qualità del codice | 9 | 9 |
| Efficienza | 9 | 7 |
| Totale | 28 | 26 |
Vincitore: GPT-5.4
Per lo scripting DevOps, la concisione di GPT-5.4 è un vantaggio. Il workflow è più facile da mantenere e modificare. Le aggiunte di Opus (notifica Slack, verifica della versione) sono carine ma non erano state richieste e hanno aggiunto complessità. GPT-5.4 guida su Terminal-bench (75.1% contro 65.4%), e questo vantaggio si manifesta nei compiti orientati al terminale.
La classifica finale
| Task | GPT-5.4 | Opus 4.6 | Vincitore |
|---|---|---|---|
| 1. Endpoint API REST | 28 | 27 | GPT-5.4 |
| 2. Componente React | 28 | 26 | GPT-5.4 |
| 3. Query SQL | 26 | 27 | Opus 4.6 |
| 4. Debug race condition | 22 | 27 | Opus 4.6 |
| 5. Revisione del codice | 25 | 28 | Opus 4.6 |
| 6. Suite di test | 28 | 25 | GPT-5.4 |
| 7. Rifattorizzare modulo | 22 | 27 | Opus 4.6 |
| 8. Documentazione | 27 | 26 | Pareggio |
| 9. Design architettura | 23 | 27 | Opus 4.6 |
| 10. Script DevOps | 28 | 26 | GPT-5.4 |
| Totale | 257 | 266 | Opus 4.6 |
Punteggio finale: Claude Opus 4.6 vince 266 a 257.
Ma il punteggio aggregato nasconde la vera storia.
Il pattern che conta più del punteggio
Guarda dove vince ogni modello:
GPT-5.4 vince su:
- Endpoint API (compiti ben definiti e circoscritti)
- Componenti React (boilerplate con specifiche chiare)
- Scrittura di test (copertura completa da una specifica)
- Script DevOps (orientati al terminale, output conciso)
Claude Opus 4.6 vince su:
- Casi limite SQL (individuazione di bug sottili nei dati)
- Debugging (comprensione delle cause principali in sistemi complessi)
- Revisione del codice (ricerca di problemi di sicurezza e correttezza)
- Rifattorizzazione (gestione delle dipendenze tra file)
- Architettura (ragionamento profondo sui tradeoff)
Il pattern è chiaro: GPT-5.4 è il modello più veloce, economico e migliore per compiti di programmazione ben definiti. Claude Opus 4.6 è il modello più profondo e attento per compiti che richiedono ragionamento attraverso la complessità.
Questo concorda con quanto rilevato dall'analisi di DataCamp: GPT-5.4 è il miglior modello tuttofare, mentre Opus 4.6 eccelle specificamente in compiti agentici e di programmazione profonda.
Il fattore costo
Il divario di punteggio (9 punti) è relativamente piccolo. Il divario di costo no.
| Metrica | GPT-5.4 | Claude Opus 4.6 |
|---|---|---|
| Prezzo input | $2.50/MTok | $15/MTok |
| Prezzo output | $15/MTok | $75/MTok |
| Velocità | 73.4 tok/s | 40.5 tok/s |
| Context window | 1M (sovrapprezzo >272K) | 1M (prezzo fisso) |
| Risparmio ricerca tool | ~47% riduzione token | N/A |
Per questo test di 10 compiti, il costo totale dell'API è stato di circa $4.20 per GPT-5.4 e $31.50 per Opus 4.6. Si tratta di una differenza di costo di 7.5 volte per un divario di qualità del 3.5%.
Per un team che esegue centinaia di compiti di programmazione assistita da AI al giorno, i calcoli favoriscono fortemente GPT-5.4 per la maggior parte del lavoro, riservando Opus per quel 10-20% ad alta posta in gioco dove la sua profondità di ragionamento fa una differenza sostanziale.
La strategia intelligente: usarli entrambi
La maggior parte degli sviluppatori attivi nel 2026 non sceglie un solo modello — sceglie quando usare ciascuno. Il pattern emerso da questo test corrisponde a ciò che usiamo in ZBuild:
Per l'uso quotidiano: GPT-5.4 (tramite Codex CLI o API)
- Scrittura di nuovi endpoint, componenti e script
- Generazione di test dalle specifiche
- Debugging rapido su problemi isolati
- Automazione DevOps e CI/CD
Per i compiti pesanti: Claude Opus 4.6 (tramite Claude Code o API)
- Rifattorizzazione multi-file con dipendenze complesse
- Revisione di codice critico per la sicurezza
- Sessioni di progettazione architettonica
- Debugging di problemi non ovvi in grandi codebase
Questo approccio a due modelli cattura il 95% dei punti di forza di entrambi i modelli, mantenendo i costi gestibili. La guida di Portkey per scegliere tra questi modelli raccomanda lo stesso approccio ibrido.
Cosa dicono i benchmark (per contesto)
I risultati compito per compito sopra riportati si allineano con i benchmark formali:
| Benchmark | GPT-5.4 | Opus 4.6 | Cosa misura |
|---|---|---|---|
| SWE-bench Verified | ~80% | 80.8% | Risoluzione di problemi GitHub reali |
| SWE-bench Pro | 57.7% | ~46% | Compiti di programmazione più difficili e rigorosi |
| Terminal-bench 2.0 | 75.1% | 65.4% | Compiti di sistema e terminale |
| HumanEval | 93.1% | 90.4% | Generazione di codice a livello di funzione |
| GPQA Diamond | 92.0-92.8% | 87.4-91.3% | Ragionamento a livello esperto |
| ARC-AGI-2 | 73.3% | 68.8-69.2% | Ragionamento innovativo |
Fonti: Benchmark di MindStudio, Analisi di Evolink, Anthropic
GPT-5.4 guida sulla maggior parte dei benchmark. Opus 4.6 guida su SWE-bench Verified — il benchmark più strettamente legato alla correzione di bug nel mondo reale — il che spiega il suo vantaggio nel debugging e nella rifattorizzazione nei miei test.
Il verdetto
Se puoi scegliere un solo modello: GPT-5.4. Gestisce l'80% dei compiti di programmazione con qualità uguale o superiore, costa 6-7 volte meno ed è l'80% più veloce. Il 20% dei compiti in cui Opus è migliore (debugging, rifattorizzazione, architettura) può spesso essere gestito con prompt più dettagliati su GPT-5.4.
Se puoi usarli entrambi: Fallo. GPT-5.4 per la programmazione quotidiana, Opus 4.6 per il lavoro complesso. Questo non è un compromesso — è la strategia ottimale.
Se il costo non conta e vuoi la massima qualità in ogni compito: Claude Opus 4.6. Ha vinto il punteggio complessivo e le sue vittorie sono state nei compiti in cui la qualità conta di più (i bug costano più del boilerplate).
I risultati non sono stati quelli che mi aspettavo perché pensavo che il modello più costoso avrebbe dominato. Non è stato così. I due modelli hanno punti di forza genuinamente diversi, e la strategia migliore è sapere di quale forza hai bisogno per il compito che hai davanti.
Fonti
- OpenAI — Introducing GPT-5.4
- OpenAI — API Pricing
- Anthropic — Introducing Claude Opus 4.6
- Anthropic — Claude Pricing
- MindStudio — GPT-5.4 vs Claude Opus 4.6 vs Gemini 3.1 Pro Benchmarks
- MindStudio — Which AI Model Is Right for Your Workflow
- Portkey — GPT-5.4 vs Claude Opus 4.6 Guide
- DataCamp — GPT-5.4 vs Claude Opus 4.6 for Agentic Tasks
- Artificial Analysis — GPT-5.4 vs Claude Opus 4.6
- Bind AI — GPT-5.4 vs Claude Opus 4.6 for Coding
- Evolink — SWE-bench Verified 2026: Claude vs GPT
- DEV Community — ChatGPT vs Claude for Coding 2026
- Claude 5 — Opus 4.6 Benchmark Analysis