Recensione del Claude Opus 5: vale la pena acquistare il nuovo modello di Anthropic?
Olivia Carter
Ultimo aggiornamento: 29/07/2026
Recensione del Claude Opus 5: vale la pena acquistare il nuovo modello di Anthropic?
Verifica dei fatti effettuata il 28 luglio 2026.
Giudizio a prima vista: Questa recensione del modello Claude Opus 5 presenta un modello di fascia alta particolarmente interessante per gli sviluppatori, i flussi di lavoro aziendali complessi e gli acquirenti che desiderano prestazioni vicine ai livelli di punta senza dover necessariamente pagare per il modello Fable 5. Il modello Anthropic applica una tariffa di $5 per milione di token in ingresso e di $25 per milione di token in uscita, mentre supporta una finestra di contesto di 1 milione di token e fino a 128.000 token in uscita nell’API Messages sincrona. Non rappresenta la scelta automatica migliore per semplici chat, brevi riassunti o richieste ad alto volume e basso valore.
L’argomento più convincente è di natura pratica piuttosto che teorica: Opus 5 combina una notevole capacità di ragionamento con costi più gestibili rispetto al livello di punta di Anthropic. Nel nostro unico test di debug, ha individuato con esattezza il bug relativo alla corrispondenza dei prefissi, ha proposto la patch più piccola, ha aggiunto un test di regressione mirato e ha fornito un comando di verifica che è stato superato a livello locale. Si tratta di una prova utile per questo compito specifico, ma non è la dimostrazione che il modello avrà la meglio in ogni attività di programmazione.
Ideale per: agenti di codifica, analisi del contesto esteso, automazione aziendale e team i cui costosi fallimenti giustificano un modello premium. Da evitare quando: La velocità e il costo unitario contano più dell'ultimo tratto del ragionamento.
Il Claude Opus 5 è il modello premium di Anthropic pensato per l'uso quotidiano, ideale per la codifica agentica complessa e le attività aziendali. Anthropic lo ha annunciato il 24 luglio 2026, descrivendolo come ben congegnato, proattivo e più efficiente rispetto ad altri modelli. Ha sostituito il Claude Opus 4.8, è diventato il modello predefinito sul Claude Max ed è diventato il modello più potente disponibile sul Claude Pro.
Il 24 luglio 2026, Anthropic ha annunciato il lancio di Claude Opus 5, precisando che sarebbe stato disponibile già da quel giorno.
La presentazione del prodotto è insolita per un lancio di Opus: non viene infatti presentato solo come un modello dall’intelligenza massima. Anthropic vuole che venga utilizzato quotidianamente, con uno sforzo regolabile e un profilo di latenza moderato. Ciò lo rende più facilmente giustificabile per agenti a esecuzione prolungata e attività di produzione complesse, mentre i carichi di lavoro più semplici possono comunque essere indirizzati verso un modello più veloce ed economico.
L'accesso dipende dal percorso. Gli utenti privati possono accedere a Opus 5 tramite i piani Claude idonei; gli sviluppatori possono utilizzarlo tramite l'API Claude e le piattaforme cloud supportate. Anche GlobalGPT dispone di una pagina dedicata al prodotto. I lettori che desiderano confrontare i livelli di abbonamento di Anthropic possono utilizzare il Confronto tra i piani Claude Free, Pro e Max prima di scegliere una modalità di fatturazione.
Claude Opus 5: Prezzo, API e specifiche principali
Il sito ufficiale Prezzo API Claude è $5 per milione di token in ingresso e $25 per ogni milione di token emessi. Si tratta delle tariffe API di base, non del prezzo di un abbonamento consumer Claude o di un piano per piattaforme di terze parti. La memorizzazione nella cache dei prompt e l'elaborazione in batch hanno tariffe distinte, quindi è opportuno confrontare l'intero modello di richiesta anziché limitarsi a moltiplicare il prezzo di base indicato.
Campo
Claude Opus 5
Cosa significa
ID API Claude
claude-opus-5
Utilizza esattamente questo valore del modello nelle richieste ufficiali all'API Claude.
Prezzo di base all'ingresso
$5 / MTok
Tasso standard dei token in ingresso prima degli sconti per la memorizzazione nella cache o per i lotti.
Prezzo base di vendita
$25 / MTok
Gli agenti che generano un volume elevato di output possono diventare rapidamente costosi.
Finestra contestuale
1 milione di token
Adatto a archivi di grandi dimensioni e raccolte di documenti, a seconda della qualità delle richieste e della strategia di recupero.
Potenza massima
128K gettoni
Si applica all'API sincrona dei messaggi; per i batch di messaggi è disponibile un percorso beta separato fino a 300K.
Soglia di affidabilità delle conoscenze
Maggio 2026
Recente rispetto agli standard del modello, ma non sostituisce il recupero dal vivo.
Latenza comparativa
Moderato
Non è il modello più veloce di Anthropic; la latenza varia comunque a seconda dello sforzo, degli strumenti e del carico di lavoro.
La piattaforma Claude identifica "claude-opus-5" come l'ID API e l'alias attuali di Opus 5.La piattaforma Claude indica per Opus 5 un valore di $5/$25 per milione di token in ingresso/uscita, con una finestra di contesto di 1 milione di token, un output massimo di 128.000 token e scadenze a maggio 2026.La piattaforma Claude prevede una finestra di contesto di 1 milione, un output massimo di 128k e scadenze a maggio 2026.
Per quanto riguarda l'accesso dei consumatori, Anthropic elenca Claude Pro a $20 su base mensile o $17 al mese quando $200 viene fatturato annualmente; Claude Max parte da $100 al mese. Anthropic indica che Opus 5 è il modello più potente su Pro e quello predefinito su Max, ma le quote del piano e le funzionalità del prodotto sono separate dall’utilizzo misurato dell’API.
Se hai bisogno di una ripartizione più dettagliata dei costi, il Piani AI Claude e guida ai prezzi delle API distingue tra abbonamenti per utenti finali, fatturazione delle API e limiti di utilizzo. Questa distinzione è importante: “incluso nel piano” non significa chiamate API illimitate, e una tariffa API non indica la quantità di accesso alla chat per gli utenti finali di cui si dispone.
Claude Opus 5 Risultati dei test di benchmark
Limite importante: le cifre riportate di seguito sono benchmark pubblicati da Anthropic, non si tratta di misurazioni indipendenti effettuate ai fini di questa recensione. Sono utili per comprendere il posizionamento previsto di Anthropic in termini di prestazioni e costi, ma non garantiscono lo stesso risultato con i vostri prompt, strumenti, repository o limiti di latenza.
Valutazione
L'affermazione pubblicata da Anthropic
Come leggerlo
Frontier-Bench v0.1
Opus 5 supera di oltre il doppio le prestazioni di Opus 4.8 a un costo per attività inferiore.
Un segnale generale relativo alle prestazioni degli agenti, non un miglioramento doppio a livello universale.
CursorBench 3.2
Al massimo sforzo, Opus 5 si attesta a soli 0,51 TP40T dal punteggio massimo di Fable 5, con un costo per attività pari alla metà.
Ottime prestazioni economiche dell’agente di codifica nell’ambito dell’impostazione di sforzo testata di Anthropic.
Zapier AutomationBench
Circa 1,5 volte la percentuale di successo del secondo miglior risultato, a parità di costo per attività.
Promettente per l'automazione end-to-end dei processi aziendali; la progettazione dei flussi di lavoro rimane comunque fondamentale.
OSWorld 2.0
Supera il miglior risultato ottenuto da Fable 5 a poco più di un terzo del costo.
In questo benchmark emerge un'efficienza nell'uso del computer davvero interessante.
Secondo Anthropic, Opus 5 si avvicina a soli 0,5% dal punteggio massimo ottenuto da Fable 5 nel test CursorBench 3.2, a metà del costo per attività.Anthropic riporta un vantaggio in termini di percentuale di superamento del test pari a 1,5 volte su Zapier AutomationBench e un vantaggio in termini di costi su OSWorld 2.0.
Lo sforzo fa parte del risultato. Anthropic indica che Opus 5 utilizza per impostazione predefinita un livello di sforzo elevato nell’API Claude e nel codice Claude, mentre i suoi confronti utilizzano anch’essi impostazioni “high”, “xhigh” o “max”. Un livello di sforzo più elevato può migliorare il successo nelle attività difficili, aumentando al contempo i token, la latenza o entrambi. Il costo di riferimento per attività è quindi più indicativo rispetto al solo prezzo per token, ma nessuna delle due metriche sostituisce una prova pilota sul proprio carico di lavoro.
Come abbiamo testato il Claude Opus 5
Abbiamo eseguito un'attività di debug compatta volta all'individuazione della causa principale su un fixture CommonJS composto da tre file. Il prompt richiedeva al modello di identificare la causa principale prima di apportare modifiche, proporre la patch più piccola possibile, aggiungere un test di regressione mirato, evitare modifiche non pertinenti e fornire il comando di verifica esatto.
Abbiamo quindi verificato la correzione in modo indipendente, anziché considerare la risposta corretta solo perché sembrava sicura. Il comando locale era node --test test/account-summary.test.cjs. Prima della correzione, la suite registrava un superamento e un fallimento. Dopo aver applicato la patch di uguaglianza esatta, ha registrato due superamenti e zero fallimenti.
Questo metodo ci fornisce informazioni utili su un flusso di lavoro di debug: diagnosi, rigore nell'applicazione delle correzioni, qualità dei test di regressione e verificabilità. Non misura invece la leadership generale nella programmazione, l'affidabilità degli agenti nel lungo periodo, la velocità o le prestazioni tra i vari linguaggi.
Recensione pratica del Claude Opus 5
Debug delle cause alla radice: corretto, minimale e verificabile
Nel nostro test, Claude Opus 5 ha individuato correttamente il difetto in normalizedQuery.startsWith(account.id.toLowerCase()). Con la query ACCT-10, il controllo del prefisso ha dato esito positivo acct-1 prima di tutto, quindi Array.prototype.find ha restituito l'account sbagliato prima di individuare l'ID esatto.
La correzione proposta ha modificato la corrispondenza dei prefissi impostandola sull'uguaglianza esatta e ha aggiunto un caso di regressione per il testo con spazi di riempimento e maiuscole/minuscole miste ACCT-10 input. Non ha riscritto codice non pertinente. Questa moderazione è importante nei repository reali, dove una “pulizia” eccessivamente ampia può comportare un carico di lavoro di revisione maggiore rispetto al bug originale.
La parte più efficace è stata il ciclo completo: individuare la causa principale, spiegare perché il test esistente non l’ha rilevata, apportare la modifica minima necessaria, aggiungere il test di regressione appropriato e indicare il comando per verificarla. Il risultato è in linea con il posizionamento di Opus 5 come ’coding-agent”, ma rimane un singolo fixture. Per una guida introduttiva più ampia al flusso di lavoro, consultare come utilizzare Claude AI per la codifica.
Prompt completi da T1 a T4, risposte e codice copiabile
T1: Analisi delle cause alla radice
Superato — individuato il difetto di corrispondenza del prefisso, proposta la patch più piccola possibile e aggiunto un test di regressione mirato.
Ha individuato la corrispondenza del prefisso come causa del difetto; ha spiegato perché il vecchio test non l'aveva rilevato; ha proposto un test di regressione basato sull'uguaglianza esatta più uno.
Visualizza il prompt e la risposta completi del T1
Prompt completo
Stai eseguendo il debug di un fixture CommonJS volutamente di piccole dimensioni. Lavora esclusivamente sui tre file riportati di seguito e sulla procedura di riproduzione indicata.
Requisiti:
1. Indica la causa principale prima di proporre qualsiasi modifica.
2. Proponi la patch più piccola possibile che risolva il bug.
3. Aggiungi un test di regressione mirato che fallisca prima della correzione e superi il test dopo di essa.
4. Indica il comando di verifica esatto da eseguire dalla radice del fixture.
5. Non riscrivere codice non correlato. Non rinominare i file, non aggiungere dipendenze e non modificare l'API pubblica.
6. Riportare esattamente queste sezioni nell’ordine: `CAUSA PRINCIPALE`, `PATCH`, `VERIFICA`, `LIMITAZIONI`.
7. Nella sezione `PATCH`, fornire un diff unificato in un blocco `diff` racchiuso tra tag. Nella sezione `VERIFICA`, fornire un comando in un blocco `text` racchiuso tra tag.
Riproduzione: `summarizeAccount(accounts, ' ACCT-10 ')` dovrebbe restituire `{ id: 'acct-10', name: 'Nimbus', seats: 24 }`, ma restituisce l’account `acct-1`.
File: `src/find-account.cjs`
```js
function findAccount(accounts, query) {
const normalizedQuery = query.trim().toLowerCase();
return accounts.find((account) =>
normalizedQuery.startsWith(account.id.toLowerCase()),
);
}
module.exports = { findAccount };
```
File: `src/account-summary.cjs`
```js
const { findAccount } = require('./find-account.cjs');
function summarizeAccount(accounts, requestedId) {
const account = findAccount(accounts, requestedId);
if (!account) return null;
return { id: account.id, name: account.name, seats: account.seats };
}
module.exports = { summarizeAccount };
```
File: `test/account-summary.test.cjs`
```js
const test = require('node:test');
const assert = require('node:assert/strict');
const { summarizeAccount } = require('../src/account-summary.cjs');
const accounts = [
{ id: 'acct-1', name: 'Atlas', seats: 5 },
{ id: 'acct-10', name: 'Nimbus', seats: 24 },
];
test('riassume l'ID esatto di un account', () => {
assert.deepEqual(summarizeAccount(accounts, 'acct-1'), {
id: 'acct-1',
name: 'Atlas',
seats: 5,
});
});
```
Claude Opus 5
CAUSA PRINCIPALE
findAccount effettua la ricerca in base al prefisso, non all'uguaglianza:
Array.prototype.find restituisce il primo elemento che soddisfa il predicato. Per ‘ACCT-10‘, la query normalizzata è ‘acct-10’, e l'ID del primo conto ‘acct-1’ ne è un prefisso, quindi startsWith restituisce true e acct-1 interrompe la ricerca prima ancora che acct-10 venga verificato. La normalizzazione effettuata con trim().toLowerCase() è corretta: gli spazi e le maiuscole/minuscole non sono il problema. summarizeAccount è una funzione di passaggio e non è da biasimare. Il test attuale non è in grado di rilevare questo caso: ‘acct-1’ è un prefisso di se stesso ed è il primo elemento, quindi per quell’input la corrispondenza per prefisso e quella esatta risultano indistinguibili.
PATCH
diff
1--- a/src/find-account.cjs2+++ b/src/find-account.cjs3@@ -1,8 +1,8 @@4 function findAccount(accounts, query) {5 const normalizedQuery = query.trim().toLowerCase();6- return accounts.find((account) =>7- normalizedQuery.startsWith(account.id.toLowerCase()),8- );9+ return accounts.find(10+ (account) => account.id.toLowerCase() === normalizedQuery,11+ );12 }1314 module.exports = { findAccount };15--- a/test/account-summary.test.cjs16+++ b/test/account-summary.test.cjs17@@ -14,3 +14,11 @@18 test('summarizes an exact account ID', () => {19 seats: 5,20 });21 });22+23+test('matches the full ID rather than a prefix, with padding and mixed case', () => {24+ assert.deepEqual(summarizeAccount(accounts, ' ACCT-10 '), {25+ id: 'acct-10',26+ name: 'Nimbus',27+ seats: 24,28+ });29+});
--- a/src/find-account.cjs
+++ b/src/find-account.cjs
@@ -1,8 +1,8 @@
function findAccount(accounts, query) {
const normalizedQuery = query.trim().toLowerCase();
- return accounts.find((account) =>
- normalizedQuery.startsWith(account.id.toLowerCase()),
- );
+ return accounts.find(
+ (account) => account.id.toLowerCase() === normalizedQuery,
+ );
}
module.exports = { findAccount };
--- a/test/account-summary.test.cjs
+++ b/test/account-summary.test.cjs
@@ -14,3 +14,11 @@
test('riassume un ID account esatto', () => {
seats: 5,
});
});
+
+test('trova una corrispondenza con l'ID completo anziché con un prefisso, con spazi di riempimento e maiuscole/minuscole miste', () => {
+ assert.deepEqual(summarizeAccount(accounts, ' ACCT-10 '), {
+ id: 'acct-10',
+ name: 'Nimbus',
+ seats: 24,
+ });
+});
Prima della correzione, il nuovo test falliva con l'oggetto acct-1 / Atlas / 5; dopo la correzione, invece, viene superato.
VERIFICA
testo
1node --test test/account-summary.test.cjs
node --test test/account-summary.test.cjs
LIMITAZIONI
• Ambito: è stato modificato un operatore. Non sono state effettuate rinominazioni, non sono state aggiunte nuove dipendenze e le firme e i tipi di ritorno delle funzioni `findAccount` e `summarizeAccount` rimangono invariati. • Comportamento preesistente che non viene modificato (non rientra nell'ambito di questo bug): • Un requestedId che non sia una stringa (null, un numero) genera comunque un'eccezione quando viene chiamato il metodo .trim(). • Gli ID degli account non vengono troncati, quindi un valore memorizzato come ‘acct-10’ continuerà a non corrispondere: viene normalizzata solo la query. • Il codice di base utilizza semplicemente la funzione toLowerCase(); non prevede né la normalizzazione Unicode né il folding in base alle impostazioni locali. • Gli ID duplicati vengono comunque risolti in base alla prima corrispondenza e la ricerca rimane di complessità O(n). • Copertura del test: il singolo test di regressione verifica esattamente la riproduzione segnalata. Il percorso non trovato (nullo) e l'input non valido non vengono verificati.
ROOT CAUSE
findAccount matches by prefix, not by equality:
```js
normalizedQuery.startsWith(account.id.toLowerCase())
```
Array.prototype.find returns the first element satisfying the predicate. For ' ACCT-10 ' the normalized query is 'acct-10', and the first account's ID 'acct-1' is a prefix of it, so startsWith is true and acct-1 short-circuits the search before acct-10 is ever tested.
The trim().toLowerCase() normalization is correct — whitespace and casing are not the problem. summarizeAccount is a pass-through and is not at fault.
The existing test cannot catch this: 'acct-1' is a prefix of itself and is the first element, so prefix matching and exact matching are indistinguishable for that input.
PATCH
```diff
--- a/src/find-account.cjs
+++ b/src/find-account.cjs
@@ -1,8 +1,8 @@
function findAccount(accounts, query) {
const normalizedQuery = query.trim().toLowerCase();
- return accounts.find((account) =>
- normalizedQuery.startsWith(account.id.toLowerCase()),
- );
+ return accounts.find(
+ (account) => account.id.toLowerCase() === normalizedQuery,
+ );
}
module.exports = { findAccount };
--- a/test/account-summary.test.cjs
+++ b/test/account-summary.test.cjs
@@ -14,3 +14,11 @@
test('summarizes an exact account ID', () => {
seats: 5,
});
});
+
+test('matches the full ID rather than a prefix, with padding and mixed case', () => {
+ assert.deepEqual(summarizeAccount(accounts, ' ACCT-10 '), {
+ id: 'acct-10',
+ name: 'Nimbus',
+ seats: 24,
+ });
+});
```
Before the fix the new test fails with the acct-1 / Atlas / 5 object; after the fix it passes.
VERIFICATION
```text
node --test test/account-summary.test.cjs
```
LIMITATIONS
• Scope: one operator changed. No renames, no new dependencies, and findAccount / summarizeAccount signatures and return shapes are unchanged.
• Pre-existing behavior left alone (out of scope for this bug):
• A non-string requestedId (null, a number) still throws on .trim().
• Account IDs themselves are not trimmed, so a stored ' acct-10' still will not match — only the query is normalized.
• Casing uses plain toLowerCase(); no Unicode normalization or locale-aware folding.
• Duplicate IDs still resolve to the first match, and lookup remains O(n).
• Test coverage: the single regression test targets exactly the reported reproduction. The not-found (null) path and malformed input remain untested.
T2: Analisi dello stato di salute dell'account
Parziale — sono state calcolate le metriche principali e sono state stabilite le priorità delle azioni, ma la risposta fornita non includeva l'indicatore "Recheck" richiesto.
Calcolato un MRR a rischio pari a $34.800 (94,31%); segnalato l'E-505 e classificate le azioni di follow-up; la risposta si è conclusa senza il marcatore di ricontrollo richiesto.
Visualizza il testo completo della domanda T2 e la risposta
Prompt completo
Analizza il file `account-health.csv` fornito come set di dati chiuso. Non utilizzare dati esterni e non inventare valori mancanti.
Regole di rischio (valutare ciascuna in modo indipendente):
- `inattività`: `days_since_login >= 30`
- `payment`: `failed_payments >= 2`
- `low_utilization`: `seats_used / seats_purchased = 80` mentre l’account è a rischio.
- `weak_health_without_risk`: `health_score = 9` e `open_tickets >= 3`.
Requisiti:
1. Calcolare i flag di rischio e i flag di contraddizione attivati per ogni account.
2. Riportare i totali del set di dati relativi ad account, MRR, account a rischio, MRR a rischio, account da segnalare, righe di contraddizione, postazioni acquistate e postazioni utilizzate.
3. Generare una tabella delle azioni con esattamente cinque colonne: `Account | Segnali di rischio | Contraddizioni | Priorità | Azione raccomandata`.
4. Inserire i valori calcolati direttamente sotto l’intestazione `Dati misurati` e le valutazioni soggettive sotto l’intestazione `Inferenza`.
5. Sotto «Ricontrollo», mostrare calcoli aritmetici sufficienti per ricontrollare in modo indipendente ogni totale e ogni limite di soglia, compreso il caso di uguaglianza a 0,50.
6. Non correggere né reinterpretare le regole in modo implicito. Se un segnale sembra controintuitivo, registrarlo come contraddizione anziché modificarne la classificazione.
`account-health.csv`:
```csv
account_id,account_name,plan,mrr_usd,days_since_login,failed_payments,seats_purchased,seats_used,health_score,nps,open_tickets
A-101,Aster,Enterprise,12000,45,0,100,82,92,9,1
B-202,Beacon,Pro,4200,4,2,20,18,70,7,0
C-303, Cinder, Pro, 3600, 12, 0, 20, 8, 65, 10, 4
D-404, Dahlia, Starter, 900, 5, 0, 5, 4, 42, 6, 0
E-505,Ember,Enterprise,15000,65,3,200,70,35,3,6
F-606,Fjord,Starter,1200,29,1,4,2,85,9,3
```
Claude Opus 5
Dati misurati
Fonte: account-health.csv, 6 righe, considerate chiuse. Nessun valore imputato.
Valutazione delle regole per singolo account
Conto giorni ≥ 30 fallito ≥ 2 util < 0,50 Conteggio dei rischi Stato A-101 Aster ✅ 45 ❌ 0 ❌ 0,82 1 a rischio B-202 Segnalatore ❌ 4 ✅ 2 ❌ 0,90 1 a rischio C-303 Cenere ❌ 12 ❌ 0 ✅ 0,40 1 a rischio D-404 Dahlia ❌ 5 ❌ 0 ❌ 0,80 0 non a rischio E-505 Ember ✅ 65 ✅ 3 ✅ 0,35 3 a rischio + segnalare F-606 Fjord ❌ 29 ❌ 1 ❌ 0,50 0 non a rischio Segnalazioni di contraddizione per account Conto salute_forte_con_rischio salute_precaria_senza_rischi promotore_con_biglietti_caricati A-101 Aster ✅ (92 ≥ 80, a rischio) ❌ ❌ (NPS 9 ✓, ticket 1 ✗) B-202 Segnalatore ❌ (70 < 80) ❌ (70 ≥ 50) ❌ (NPS 7) C-303 Cenere ❌ (65 < 80) ❌ (65 ≥ 50) ✅ (NPS 10, biglietti 4) D-404 Dahlia ❌ ✅ (42 < 50, non a rischio) ❌ (NPS 6) E-505 Ember ❌ (35 < 80) ❌ (35 < 50, ma è a rischio) ❌ (NPS 3) F-606 Fjord ❌ (85 ≥ 80 ma non a rischio) ❌ (85 ≥ 50) ✅ (NPS 9, biglietti 3) Totali del set di dati Metrico Valore Conti 6 MRR totale $36,900 Conti a rischio 4 (A-101, B-202, C-303, E-505) MRR a rischio $34.800 (94,31% del totale) Escalare gli account 1 (E-505) Righe di contraddizione 4 (A-101, C-303, D-404, F-606) Segnali di contraddizione 4 (1 "salute_buona_con_rischio", 1 "salute_precaria_senza_rischio", 2 "promotore_con_carico_biglietti") Posti acquistati 349 Posti occupati 184 Inferenza L'ordine di priorità e le azioni consigliate riportate di seguito sono frutto di valutazioni soggettive, non di regole fisse. La mia classificazione attribuisce maggiore peso, in ordine, allo stato di emergenza, poi al MRR a rischio e infine ai segnali di contraddizione. Conto Fattori scatenanti del rischio Contraddizioni Priorità Azione consigliata E-505 Ember inattività, pagamento, basso utilizzo - P0 Tutte e tre le regole si attivano per l'account più grande ($15.000 MRR). Considerarlo un caso di abbandono attivo: recuperare il metodo di pagamento, quindi effettuare una revisione da parte della direzione sui 130 posti non utilizzati. A-101 Aster inattività salute_forte_con_rischio P1 $: 12.000 MRR con 45 giorni di inattività, nonostante un punteggio di 92 e un utilizzo sano di 82%. Verificare se il periodo di inattività sia dovuto a un reale disimpegno o a un artefatto di tracciamento (SSO, utilizzo solo tramite API) prima di intervenire in base al punteggio. C-303 Cenere basso_utilizzo promotore_con_biglietti_caricati P1 Promotore (nps 10) con 4 ticket aperti e un utilizzo pari a 40%. Il carico di ticket rappresenta il principale ostacolo all'adozione; svuotare la coda, quindi procedere all'attivazione dei posti. B-202 Segnalatore pagamento - P2 Caso chiaro con causa unica: 2 pagamenti non andati a buon fine con accesso effettuato negli ultimi 4 giorni e utilizzo del codice 90%. È sufficiente un follow-up di fatturazione, non è necessario alcun intervento del servizio clienti. F-606 Fjord - promotore_con_biglietti_caricati P3 Rientra perfettamente in ogni limite (29 giorni, 1 pagamento non andato a buon fine, utilizzo pari esattamente a 0,50). Secondo le regole non è a rischio, ma un altro giorno di inattività o un altro pagamento non andato a buon fine cambierebbe la situazione. Tieni sotto controllo la situazione e risolvi i 3 ticket. D-404 Dahlia - salute_precaria_senza_rischi P3 Punteggio 42 senza alcuna regola attivata e utilizzo 80% su MRR $900. O
Dati misurati
Fonte: account-health.csv, 6 righe, considerate chiuse. Nessun valore imputato.
Valutazione delle regole per singolo account
Account
giorni ≥ 30
fallimenti ≥ 2
util < 0,50
Conteggio rischio
Stato
A-101 Aster
✅ 45
❌ 0
❌ 0,82
1
a rischio
B-202 Beacon
❌ 4
✅ 2
❌ 0,90
1
a rischio
C-303 Cinder
❌ 12
❌ 0
✅ 0,40
1
a rischio
D-404 Dahlia
❌ 5
❌ 0
❌ 0,80
0
non a rischio
E-505 Ember
✅ 65
✅ 3
✅ 0,35
3
a rischio + escalation
F-606 Fjord
❌ 29
❌ 1
❌ 0,50
0
non a rischio
Segnalazioni di contraddizione per account
Account
strong_health_with_risk
weak_health_without_risk
promoter_with_ticket_load
A-101 Aster
✅ (92 ≥ 80, a rischio)
❌
❌ (NPS 9 ✓, ticket 1 ✗)
B-202 Beacon
❌ (70 < 80)
❌ (70 ≥ 50)
❌ (NPS 7)
C-303 Cinder
❌ (65 < 80)
❌ (65 ≥ 50)
✅ (NPS 10, ticket 4)
D-404 Dahlia
❌
✅ (42 < 50, non a rischio)
❌ (nps 6)
E-505 Ember
❌ (35 < 80)
❌ (35 < 50 ma a rischio)
❌ (NPS 3)
F-606 Fjord
❌ (85 ≥ 80 ma non a rischio)
❌ (85 ≥ 50)
✅ (NPS 9, ticket 3)
Totali del set di dati
Metrica
Valore
Account
6
MRR totale
$36.900
Account a rischio
4 (A-101, B-202, C-303, E-505)
MRR a rischio
$34.800 (94,31% del totale)
Account da segnalare
1 (E-505)
Righe contraddittorie
4 (A-101, C-303, D-404, F-606)
Indicatori di contraddizione
4 (1 strong_health_with_risk, 1 weak_health_without_risk, 2 promoter_with_ticket_load)
Posti acquistati
349
Posti utilizzati
184
Conclusione
L’ordine di priorità e le azioni raccomandate riportate di seguito sono frutto di valutazioni discrezionali, non di risultati automatici. I miei pesi di classificazione danno priorità prima allo stato di escalation, poi all’MRR a rischio e infine ai segnali di contraddizione.
Account
Fattori di rischio
Contraddizioni
Priorità
Azione raccomandata
E-505 Ember
inattività, pagamento, low_utilization
—
P0
Tutte e tre le regole si attivano sull’account più grande ($15.000 MRR). Trattare come abbandono attivo: recuperare il metodo di pagamento, quindi eseguire una revisione da parte dei responsabili sui 130 posti inutilizzati.
A-101 Aster
inattività
stato_di_salute_solido_con_rischio
P1
$12.000 MRR con 45 giorni di inattività nonostante un punteggio di 92 e un utilizzo sano pari a 82%. Verificare se l’intervallo tra gli accessi sia dovuto a un reale disimpegno o a un artefatto di tracciamento (SSO, utilizzo solo tramite API) prima di agire in base al punteggio.
C-303 Cinder
basso_utilizzo
promotore_con_carico_di_ticket
P1
Promotore (NPS 10) con 4 ticket aperti e un utilizzo pari a 40%. Il carico di ticket è il probabile ostacolo all’adozione; smaltire la coda, quindi promuovere l’attivazione della postazione.
B-202 Beacon
pagamento
—
P2
Caso chiaro con causa unica: 2 pagamenti non andati a buon fine con accesso effettuato 4 giorni fa e utilizzo pari a 90%. È necessario solo un follow-up di fatturazione, non è richiesta alcuna azione da parte del servizio clienti.
F-606 Fjord
—
promoter_with_ticket_load
P3
Si trova appena entro ogni limite (29 giorni, 1 pagamento non andato a buon fine, utilizzo esattamente pari a 0,50). Non è a rischio secondo le regole, ma un altro giorno di inattività o un altro pagamento non andato a buon fine ribalterebbe la situazione. Monitorare e risolvere i 3 ticket.
D-404 Dahlia
—
weak_health_without_risk
P3
Punteggio 42 senza regole attivate e utilizzo 80% su un MRR di $900. O
T3: Generazione di interfacce utente responsive
Parziale — ha prodotto un'implementazione completa e autonoma, corredata di un controllo automatico, pur ammettendo esplicitamente di aver analizzato la pagina anziché renderizzarla in fase di esecuzione.
Ha generato una risposta completa di 21.907 caratteri; ha trattato gli aspetti relativi a desktop, dispositivi mobili, overflow e accessibilità; ha specificato chiaramente che il layout è stato ispezionato, non renderizzato in fase di esecuzione.
Visualizza il prompt T3 completo e la risposta
Prompt completo
Realizza un'interfaccia di confronto dei prodotti ben rifinita sotto forma di un unico file HTML eseguibile, utilizzando esclusivamente i dati dei prodotti riportati di seguito.
Requisiti:
1. Restituisci esattamente un blocco di codice `html` racchiuso tra tag, seguito da una sezione `SELF-CHECK`. Non suddividere il codice HTML, CSS o JavaScript in file separati.
2. Utilizza esclusivamente HTML semantico, CSS incorporato e JavaScript vanilla incorporato: nessun framework esterno, pacchetto, font, immagine, richiesta di rete o fase di compilazione.
3. Fornisci tre schede accessibili tramite tastiera (`Panoramica`, `Prezzi`, `Limiti`) con la corretta semantica di `tablist`, `tab` e `tabpanel`. I tasti freccia sinistra/freccia destra devono spostarsi e attivare le schede; i tasti Home/End devono passare alla prima/ultima scheda e attivarla. Il focus deve rimanere visibile.
4. La scheda selezionata deve essere indicata da `aria-selected`, `tabindex` e dal pannello visibile; i pannelli inattivi devono essere nascosti.
5. Dimensioni target per desktop: 1440px di larghezza. Dimensioni target per dispositivi mobili: 390px di larghezza senza overflow orizzontale della pagina, senza controlli troncati, aree di selezione alte almeno 44px e schede di confronto impilate in un’unica colonna.
6. Includere un’intestazione concisa, una raccomandazione chiara, tre schede di prodotto e una tabella di confronto compatta. Mantenere un contrasto leggibile ed evitare movimenti decorativi.
7. Utilizzare esattamente queste informazioni sui prodotti e non aggiungere affermazioni:
- Atlas: `$19/mo`, `20 progetti`, `10 GB`, `Assistenza via e-mail`, ideale per chi lavora in autonomia.
- Beacon: `$49/mo`, `Progetti illimitati`, `100 GB`, `Assistenza prioritaria`, la scelta migliore in assoluto per i team in crescita.
- Cove: `$99/mo`, `Progetti illimitati`, `1 TB`, `Assistenza dedicata`, ideale per operazioni regolamentate.
8. Assegnare a Beacon un’etichetta visibile "Migliore in assoluto" senza far sembrare disattivate le altre schede.
9. In `SELF-CHECK`, riportare esplicitamente i controlli effettuati su schede semantiche, comportamento della tastiera, layout a 1440px, layout a 390px, overflow orizzontale e dipendenze esterne. Non affermare di aver effettivamente renderizzato un viewport a meno che non sia vero; distinguere l’ispezione del codice dalla verifica in fase di esecuzione.
Fixture del prodotto (memorizzata anche come `fixtures/T3-responsive-ui/product-data.json`):
```json
{
"products": [
{"name":"Atlas","price":"$19/mo","projects":"20 projects","storage":"10 GB","support":"Assistenza via e-mail","bestFor":"lavoro individuale"},
{"name":"Beacon","price":"$49/mo","projects":"Progetti illimitati","storage":"100 GB","support":"Assistenza prioritaria","bestFor":"team in crescita","badge":"Migliore in assoluto"},
{"name":"Cove","price":"$99/mo","projects":"Progetti illimitati","spazio di archiviazione":"1 TB","assistenza":"Assistenza dedicata","idealePer":"operazioni regolamentate"}
]
}
```
Tutte le affermazioni riportate di seguito derivano esclusivamente dall’analisi del codice. Non ho aperto un browser, né visualizzato una finestra di visualizzazione, né avviato uno screen reader, né eseguito i gestori della tastiera; pertanto, nulla di quanto riportato qui è stato verificato in fase di esecuzione. Laddove un’affermazione dipenda dal comportamento del motore di layout, lo specifico espressamente. Schede semantiche — verificate, coerenti Un elemento div[role="tablist"] con aria-label="Viste di confronto dei piani" contiene tre pulsanti[type="button"][role="tab"]. Ogni scheda ha un ID univoco e un attributo `aria-controls` che punta a una sezione [role="tabpanel"]; ogni pannello presenta l'attributo `aria-labelledby` che rimanda alla propria scheda. Ho tracciato manualmente tutte e tre le coppie: `tab-overview`/`panel-overview`, `tab-pricing`/`panel-pricing`, `tab-limits`/`panel-limits`. Nessun ID duplicato, nessun riferimento non risolto. I pannelli utilizzano tabindex="0", quindi il corpo del pannello è raggiungibile dopo la scheda. Comportamento della tastiera — verificato, non eseguito Un unico listener keydown sulla tablist gestisce i tasti Freccia destra, Freccia sinistra, Home e Fine, chiama event.preventDefault() solo per quei quattro tasti e, in caso contrario, termina la procedura anticipatamente. I tasti freccia effettuano il ritorno all'inizio o alla fine dell'elenco. Poiché la funzione `activate()` aggiorna sia `aria-selected`, `tabindex` e `hidden` sia sposta il focus, i tasti freccia e Home/End spostano il focus e attivano l'elemento in un unico passaggio, il che corrisponde al modello di attivazione automatica richiesto dalle specifiche. La navigazione con Tab/Shift+Tab si basa su un tabindex variabile: esattamente un elemento ha tabindex="0", gli altri -1, valore gestito da activate(). La visibilità del focus deriva da una regola globale :focus-visible con un contorno di 3px e un offset di 2px; non ho sovrascritto né rimosso alcun contorno predefinito. Non ho verificato il funzionamento dei tasti in un browser reale. Riflessione in stato selezionato — verificata La funzione `activate()` imposta tutti e tre i segnali nello stesso ciclo, in modo che `aria-selected="true"`, `tabindex="0"` e l'assenza dell'attributo `hidden` non possano divergere. I pannelli inattivi ricevono l’attributo hidden, e [hidden] { display: none !important; } impedisce che le regole di visualizzazione lo vanifichino — questa precauzione è importante perché i pannelli contengono elementi figli con display: grid. activate(currentIndex(), false) viene eseguito al caricamento per normalizzare lo stato dal markup senza sottrarre il focus. Se JavaScript non viene eseguito, il markup viene caricato con il pannello «Panoramica» selezionato e gli altri due pannelli nascosti, in modo che la pagina sia comunque fruibile con un unico pannello leggibile. Layout a 1440px — controllato, non visualizzato .wrap ha una larghezza massima di 1120px con margin: 0 auto, quindi a 1440px il contenuto viene centrato con spazi laterali di circa 160px invece di espandersi. Le schede utilizzano `grid-template-columns: repeat(3, minmax(0, 1fr))` con uno spazio di 20px, ottenendo tre colonne uguali; `align-items: start` impedisce alle schede di espandersi fino a un'altezza condivisa, mentre `.card { height: 100% }` viene neutralizzato da questa impostazione. L’uso di minmax(0, 1fr) è intenzionale: 1fr da solo può rifiutarsi di ridursi al di sotto della larghezza del contenuto e allargare la griglia. Non ho misurato l’effettivo risultato in pixel. Layout a 390px — controllato, non visualizzato Il blocco con `max-width: 720px` imposta la griglia delle schede su `minmax(0, 1fr)`, ovvero una singola colonna, in modo che le schede si impilino. Il padding si riduce a 16px per lato, lasciando circa 358px di larghezza per il contenuto. Obiettivi di tocco: ogni [role="tab"] ha `min-height: 44px`, e il padding orizzontale si riduce a 12px anziché ridurre l’altezza, in modo che l’altezza minima di 44px rimanga invariata a larghezze ridotte. L’elenco delle schede assume il valore `flex-wrap: nowrap` con `overflow-x: auto` e figli con `flex: 1 0 auto`, in modo che tre schede si adattino o scorrano all’interno dell’elenco stesso, invece di essere troncate o avvolte a metà del controllo. È presente il tag . Non verificato con un viewport effettivo di 390px. Fuoriuscita orizzontale — ispezionata, un rotolo contenuto intenzionalmente body { overflow-x: hidden } funge da misura di sicurezza, ma ho cercato comunque di non fare affidamento su di esso. * { box-sizing: border-box } mantiene il padding all’interno delle larghezze dichiarate. Le tabelle di confronto utilizzano white-space: nowrap sulle celle, quindi la tabella "Panoramica" a sei colonne supererà i 358px sui dispositivi mobili; ciò viene contenuto da .table-scroll { max-width: 100%; overflow-x: auto }, che fa scorrere l’area della tabella anziché la pagina. Quel wrapper ha tabindex="0" e role="region" con un'etichetta, in modo che gli utenti che utilizzano la tastiera possano raggiungerlo e scorrerlo. Gli elementi figli flex e grid che altrimenti potrebbero rifiutarsi di ridursi vengono gestiti con minmax(0, 1fr) sulla griglia e flex-wrap: wrap su .card-head e .recommendation. L’unico rischio residuo che non posso escludere senza un rendering effettivo è una stringa lunga e ininterrotta in una cella della tabella, ma tutti i valori dei fixture sono brevi. Dipendenze esterne — verificate, nessuna No <link>, <script src>, <img>, @import, url(), fetch, XMLHttpRequest, web font, or CDN reference. Fonts are a system-ui stack. The badge and featured border are CSS only, no icon assets. Everything is inline in one file, so it runs from file:// with no build step. Contrasto e movimento — verificati Il testo principale #16191f su #f6f7f9 e quello secondario #4a515c su sfondo bianco superano entrambi nettamente il rapporto di 4,5:1; il badge è bianco su #10457e, mentre la scheda attiva è #10457e su sfondo bianco. Ho calcolato questi valori stimando il rapporto dai valori esadecimali, non con uno strumento di contrasto. Non ci sono transizioni, animazioni o trasformazioni da nessuna parte; il blocco `prefers-reduced-motion` è una misura di sicurezza inattiva piuttosto che una correzione per il movimento esistente. Fedeltà delle attrezzature — verificata Ciascuno dei tre piani compare in tutti e tre i riquadri, oltre che nella tabella di ciascun riquadro. Ho verificato ogni prezzo, numero di progetti, capacità di archiviazione e livello di assistenza confrontandoli con il file JSON: Atlas 19 / 20 𝑝 𝑟 𝑜 𝑗 𝑒 𝑐 𝑡 𝑠 / 10 𝐺 𝐵 / 𝐸 𝑚 𝑎 𝑖 𝑙 , 𝐵 𝑒 𝑎 𝑐 𝑜 𝑛 49/Illimitato/100 GB/Prioritario, Cove $99/Illimitato/1 TB/Dedicato. Beacon presenta il badge "Migliore in assoluto" e un bordo di contorno di 2px; Atlas e Cove mantengono il testo a opacità piena, i bordi normali e lo stesso trattamento tipografico, in modo da apparire come disponibili anziché disabilitati. I prodotti “migliori per” sono rappresentati da brevi etichette (“Ideale per il lavoro in solitaria”) — formulazione aggiunta attorno al valore del prodotto, senza nuove affermazioni sul prodotto. Lacune note Non viene effettuata alcuna verifica in fase di esecuzione. Il contenuto dei pannelli viene duplicato nei tre pannelli come markup statico anziché essere generato dal JSON; pertanto, il fixture rappresenta la fonte di riferimento per trascrizione, non tramite binding: un'eventuale modifica futura dei dati comporterà la modifica in più punti.
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Compare plans — Atlas, Beacon, Cove</title>
<style>
:root
{
--bg: #f6f7f9
;
--surface: #ffffff
;
--ink: #16191f
;
--ink-soft: #4a515c
;
--line: #d3d8df
;
--line-strong: #b6bdc7
;
--accent: #10457e
;
--accent-soft: #e8f0f9
;
--focus: #0b2f56
;
--radius: 10px
;
}
* {
box-sizing
: border-box; }
html { -webkit-text-size-adjust: 100%
; }
body
{
margin: 0
;
padding: 0
;
background: var
(--bg);
color: var
(--ink);
font-family: system-ui, -apple-system, "Segoe UI"
, Roboto, Helvetica, Arial, sans-serif;
font-size: 16px
;
line-height: 1.5
;
overflow-x
: hidden;
}
.wrap
{
width: 100%
;
max-width: 1120px
;
margin: 0
auto;
padding: 32px 24px 64px
;
}
/* ---------- Header ---------- */
.page-header { margin-bottom: 24px
; }
.page-header h1
{
margin: 0 0 8px
;
font-size: 1.75rem
;
line-height: 1.25
;
letter-spacing: -0.01em
;
}
.page-header p
{
margin: 0
;
max-width: 60ch
;
color: var
(--ink-soft);
}
/* ---------- Recommendation ---------- */
.recommendation
{
display
: flex;
flex-wrap
: wrap;
gap: 4px 10px
;
align-items
: baseline;
margin: 0 0 28px
;
padding: 14px 16px
;
background: var
(--accent-soft);
border: 1px solid #c2d5e8
;
border-left: 4px solid var
(--accent);
border-radius: var
(--radius);
}
.recommendation strong { color: var
(--accent); }
.recommendation span { color: #23405e
; }
/* ---------- Tabs ---------- */
.tabs
{
display
: flex;
flex-wrap
: wrap;
gap: 8px
;
margin: 0 0 20px
;
padding: 0
;
border-bottom: 1px solid var
(--line);
}
[role="tab"]
{
appearance
: none;
min-height: 44px
;
padding: 10px 18px
;
font
: inherit;
font-weight: 600
;
color: var
(--ink-soft);
background
: transparent;
border: 1px
solid transparent;
border-bottom: 3px
solid transparent;
border-radius: 8px 8px 0 0
;
cursor
: pointer;
}
[role="tab"]:hover { color: var(--ink); background: #eceff3
; }
[role="tab"][aria-selected="true"]
{
color: var
(--accent);
background: var
(--surface);
border-color: var(--line) var(--line) var
(--accent);
border-bottom-width: 3px
;
}
:focus-visible
{
outline: 3px solid var
(--focus);
outline-offset: 2px
;
}
[role="tabpanel"] { outline
: none; }
[role="tabpanel"]:focus-visible
{
outline: 3px solid var
(--focus);
outline-offset: 4px
;
border-radius: var
(--radius);
}
[hidden] { display: none !important
; }
.panel-intro
{
margin: 0 0 20px
;
max-width: 62ch
;
color: var
(--ink-soft);
}
/* ---------- Cards ---------- */
.card-grid
{
display
: grid;
grid-template-columns: repeat(3, minmax(0, 1
fr));
gap: 20px
;
margin: 0
;
padding: 0
;
list-style
: none;
align-items
: start;
}
.card
{
display
: flex;
flex-direction
: column;
height: 100%
;
padding: 20px
;
background: var
(--surface);
border: 1px solid var
(--line);
border-radius: var
(--radius);
}
.card.is-featured
{
border-color: var
(--accent);
border-width: 2px
;
padding: 19px
;
}
.card-head
{
display
: flex;
flex-wrap
: wrap;
gap: 8px
;
align-items
: center;
justify-content
: space-between;
margin-bottom: 4px
;
}
.card h3
{
margin: 0
;
font-size: 1.2rem
;
}
.badge
{
padding: 3px 10px
;
font-size: 0.75rem
;
font-weight: 700
;
letter-spacing: 0.02em
;
text-transform
: uppercase;
color: #ffffff
;
background: var
(--accent);
border-radius: 999px
;
white-space
: nowrap;
}
.price
{
margin: 8px 0 2px
;
font-size: 1.6rem
;
font-weight: 700
;
letter-spacing: -0.02em
;
}
.best-for
{
margin: 0 0 14px
;
font-size: 0.9375rem
;
color: var
(--ink-soft);
}
.spec-list
{
margin: 0
;
padding: 14px 0 0
;
border-top: 1px solid var
(--line);
font-size: 0.9375rem
;
}
.spec-list div
{
display
: flex;
gap: 12px
;
justify-content
: space-between;
padding: 5px 0
;
}
.spec-list dt { color: var
(--ink-soft); }
.spec-list dd
{
margin: 0
;
font-weight: 600
;
text-align
: right;
}
/* ---------- Table ---------- */
.table-section { margin-top: 36px
; }
.table-section h2
{
margin: 0 0 12px
;
font-size: 1.125rem
;
}
.table-scroll
{
max-width: 100%
;
overflow-x
: auto;
background: var
(--surface);
border: 1px solid var
(--line);
border-radius: var
(--radius);
}
table
{
width: 100%
;
border-collapse
: collapse;
font-size: 0.9375rem
;
}
caption
{
padding: 12px 14px
;
text-align
: left;
color: var
(--ink-soft);
font-size: 0.875rem
;
}
th, td
{
padding: 10px 14px
;
text-align
: left;
border-top: 1px solid var
(--line);
white-space
: nowrap;
}
thead th
{
background: #eef1f5
;
border-top
: none;
font-weight: 700
;
}
tbody th { font-weight: 600; color: var
(--ink-soft); }
th[scope="col"].is-featured { color: var
(--accent); }
/* ---------- Mobile ---------- */
@media (max-width: 720px
) {
.wrap { padding: 20px 16px 48px
; }
.page-header h1 { font-size: 1.4rem
; }
.tabs
{
gap: 4px
;
overflow-x
: auto;
-webkit-
overflow
-scrolling: touch;
flex-wrap
: nowrap;
}
[role="tab"]
{
flex: 1 0
auto;
padding: 10px 12px
;
font-size: 0.9375rem
;
}
.card-grid { grid-template-columns: minmax(0, 1
fr); }
th, td { padding: 10px 12px
; }
}
@media (prefers-reduced-motion
: reduce) {
* {
transition: none !important; animation: none !important
; }
}
</style>
</head>
<body>
<main class="wrap">
<header class="page-header">
<h1>Compare plans</h1>
<p>Three plans across projects, storage, and support. Pick a tab to focus on the details that matter to you.</p>
</header>
<p class="recommendation">
<strong>Recommended: Beacon</strong>
<span>Best overall for growing teams — $49/mo, unlimited projects, 100 GB, priority support.</span>
</p>
<div class="tabs" role="tablist" aria-label="Plan comparison views">
<button type="button" role="tab" id="tab-overview" aria-controls="panel-overview" aria-selected="true" tabindex="0">Overview</button>
<button type="button" role="tab" id="tab-pricing" aria-controls="panel-pricing" aria-selected="false" tabindex="-1">Pricing</button>
<button type="button" role="tab" id="tab-limits" aria-controls="panel-limits" aria-selected="false" tabindex="-1">Limits</button>
</div>
<!-- Overview -->
<section role="tabpanel" id="panel-overview" aria-labelledby="tab-overview" tabindex="0">
<p class="panel-intro">Every plan side by side, with the full set of published facts for each one.</p>
<ul class="card-grid">
<li class="card">
<div class="card-head"><h3>Atlas</h3></div>
<p class="price">$19/mo</p>
<p class="best-for">Best for solo work</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>20 projects</dd></div>
<div><dt>Storage</dt><dd>10 GB</dd></div>
<div><dt>Support</dt><dd>Email support</dd></div>
</dl>
</li>
<li class="card is-featured">
<div class="card-head">
<h3>Beacon</h3>
<span class="badge">Best overall</span>
</div>
<p class="price">$49/mo</p>
<p class="best-for">Best overall for growing teams</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>Unlimited projects</dd></div>
<div><dt>Storage</dt><dd>100 GB</dd></div>
<div><dt>Support</dt><dd>Priority support</dd></div>
</dl>
</li>
<li class="card">
<div class="card-head"><h3>Cove</h3></div>
<p class="price">$99/mo</p>
<p class="best-for">Best for regulated operations</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>Unlimited projects</dd></div>
<div><dt>Storage</dt><dd>1 TB</dd></div>
<div><dt>Support</dt><dd>Dedicated support</dd></div>
</dl>
</li>
</ul>
<section class="table-section">
<h2>All plans at a glance</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="Full plan comparison table, scrollable">
<table>
<caption>Published facts for Atlas, Beacon, and Cove.</caption>
<thead>
<tr>
<th scope="col">Plan</th>
<th scope="col">Price</th>
<th scope="col">Projects</th>
<th scope="col">Storage</th>
<th scope="col">Support</th>
<th scope="col">Best for</th>
</tr>
</thead>
<tbody>
<tr>
<th scope="row">Atlas</th>
<td>$19/mo</td><td>20 projects</td><td>10 GB</td><td>Email support</td><td>Solo work</td>
</tr>
<tr>
<th scope="row">Beacon</th>
<td>$49/mo</td><td>Unlimited projects</td><td>100 GB</td><td>Priority support</td><td>Growing teams</td>
</tr>
<tr>
<th scope="row">Cove</th>
<td>$99/mo</td><td>Unlimited projects</td><td>1 TB</td><td>Dedicated support</td><td>Regulated operations</td>
</tr>
</tbody>
</table>
</div>
</section>
</section>
<!-- Pricing -->
<section role="tabpanel" id="panel-pricing" aria-labelledby="tab-pricing" tabindex="0" hidden>
<p class="panel-intro">Monthly price and the audience each plan is built for.</p>
<ul class="card-grid">
<li class="card">
<div class="card-head"><h3>Atlas</h3></div>
<p class="price">$19/mo</p>
<p class="best-for">Best for solo work</p>
<dl class="spec-list">
<div><dt>Support</dt><dd>Email support</dd></div>
</dl>
</li>
<li class="card is-featured">
<div class="card-head">
<h3>Beacon</h3>
<span class="badge">Best overall</span>
</div>
<p class="price">$49/mo</p>
<p class="best-for">Best overall for growing teams</p>
<dl class="spec-list">
<div><dt>Support</dt><dd>Priority support</dd></div>
</dl>
</li>
<li class="card">
<div class="card-head"><h3>Cove</h3></div>
<p class="price">$99/mo</p>
<p class="best-for">Best for regulated operations</p>
<dl class="spec-list">
<div><dt>Support</dt><dd>Dedicated support</dd></div>
</dl>
</li>
</ul>
<section class="table-section">
<h2>Price and support</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="Pricing comparison table, scrollable">
<table>
<caption>Monthly price, support tier, and intended fit.</caption>
<thead>
<tr>
<th scope="col">Plan</th>
<th scope="col">Price</th>
<th scope="col">Support</th>
<th scope="col">Best for</th>
</tr>
</thead>
<tbody>
<tr><th scope="row">Atlas</th><td>$19/mo</td><td>Email support</td><td>Solo work</td></tr>
<tr><th scope="row">Beacon</th><td>$49/mo</td><td>Priority support</td><td>Growing teams</td></tr>
<tr><th scope="row">Cove</th><td>$99/mo</td><td>Dedicated support</td><td>Regulated operations</td></tr>
</tbody>
</table>
</div>
</section>
</section>
<!-- Limits -->
<section role="tabpanel" id="panel-limits" aria-labelledby="tab-limits" tabindex="0" hidden>
<p class="panel-intro">Project counts and storage allowances for each plan.</p>
<ul class="card-grid">
<li class="card">
<div class="card-head"><h3>Atlas</h3></div>
<p class="price">$19/mo</p>
<p class="best-for">Best for solo work</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>20 projects</dd></div>
<div><dt>Storage</dt><dd>10 GB</dd></div>
</dl>
</li>
<li class="card is-featured">
<div class="card-head">
<h3>Beacon</h3>
<span class="badge">Best overall</span>
</div>
<p class="price">$49/mo</p>
<p class="best-for">Best overall for growing teams</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>Unlimited projects</dd></div>
<div><dt>Storage</dt><dd>100 GB</dd></div>
</dl>
</li>
<li class="card">
<div class="card-head"><h3>Cove</h3></div>
<p class="price">$99/mo</p>
<p class="best-for">Best for regulated operations</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>Unlimited projects</dd></div>
<div><dt>Storage</dt><dd>1 TB</dd></div>
</dl>
</li>
</ul>
<section class="table-section">
<h2>Projects and storage</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="Limits comparison table, scrollable">
<table>
<caption>Project allowance and storage per plan.</caption>
<thead>
<tr>
<th scope="col">Plan</th>
<th scope="col">Projects</th>
<th scope="col">Storage</th>
</tr>
</thead>
<tbody>
<tr><th scope="row">Atlas</th><td>20 projects</td><td>10 GB</td></tr>
<tr><th scope="row">Beacon</th><td>Unlimited projects</td><td>100 GB</td></tr>
<tr><th scope="row">Cove</th><td>Unlimited projects</td><td>1 TB</td></tr>
</tbody>
</table>
</div>
</section>
</section>
</main>
<script>
(
function (
) {
'use strict'
;
var tablist = document.querySelector('[role="tablist"]'
);
if (!tablist) return
;
var tabs = Array.prototype.slice.call(tablist.querySelectorAll('[role="tab"]'
));
function panelFor(tab
) {
return document.getElementById(tab.getAttribute('aria-controls'
));
}
function activate(index, moveFocus
) {
if (index < 0 || index >= tabs.length) return
;
tabs.
forEach(function (tab, i
) {
var
selected = i === index;
var panel = panelFor
(tab);
tab.
setAttribute('aria-selected', selected ? 'true' : 'false'
);
tab.
setAttribute('tabindex', selected ? '0' : '-1'
);
if
(panel) {
if
(selected) {
panel.
removeAttribute('hidden'
);
}
else
{
panel.
setAttribute('hidden', ''
);
}
}
});
if (moveFocus !== false) tabs[index].focus
();
}
function currentIndex(
) {
var i = tabs.findIndex(function (tab
) {
return tab.getAttribute('aria-selected') === 'true'
;
});
return i === -1 ? 0
: i;
}
tabs.
forEach(function (tab, i
) {
tab.
addEventListener('click', function (
) {
activate
(i);
});
});
tablist.
addEventListener('keydown', function (event
) {
var last = tabs.length - 1
;
var i = currentIndex
();
var next = null
;
switch (event.key
) {
case 'ArrowRight'
:
next = i === last ?
0 : i + 1
;
break
;
case 'ArrowLeft'
:
next = i ===
0 ? last : i - 1
;
break
;
case 'Home'
:
next =
0
;
break
;
case 'End'
:
next = last;
break
;
default
:
return
;
}
event.
preventDefault
();
activate
(next);
});
// Normalize initial state from markup.
activate(currentIndex(), false
);
}());
</script>
</body>
</html>
```
SELF-CHECK
All statements below come from code inspection only. I did not open a browser, render a viewport, run a screen reader, or execute the keyboard handlers, so nothing here is runtime-verified. Where a claim depends on layout engine behavior, I say so.
Semantic tabs — inspected, consistent
One div[role="tablist"] with aria-label="Plan comparison views" holds three button[type="button"][role="tab"]. Each tab has a unique id and an aria-controls pointing at a section[role="tabpanel"]; each panel carries aria-labelledby pointing back at its tab. I traced all three pairs by hand: tab-overview/panel-overview, tab-pricing/panel-pricing, tab-limits/panel-limits. No duplicate IDs, no dangling references. Panels use tabindex="0" so the panel body is reachable after the tab.
Keyboard behavior — inspected, not executed
A single keydown listener on the tablist handles ArrowRight, ArrowLeft, Home, and End, calls event.preventDefault() for those four keys only, and returns early otherwise. Arrow keys wrap at both ends. Because activate() both updates aria-selected/tabindex/hidden and moves focus, arrow and Home/End keys move andactivate in one step, which is the automatic-activation pattern the requirement asks for. Tab/Shift+Tab traversal relies on roving tabindex: exactly one tab is tabindex="0", the rest -1, maintained by activate(). Focus visibility comes from a global :focus-visible rule with a 3px outline and 2px offset; I did not override or remove any default outline. I have not confirmed key handling in a real browser.
Selected-state reflection — inspected
activate() sets all three signals in the same loop, so aria-selected="true", tabindex="0", and the absence of hidden cannot drift apart. Inactive panels get the hidden attribute, and [hidden] { display: none !important; } guards against the display rules that would otherwise defeat it — that guard matters because the panels contain display: grid children. activate(currentIndex(), false) runs on load to normalize state from markup without stealing focus. If JavaScript does not run, the markup ships with Overview selected and the other two panels hidden, so the page degrades to one readable panel.
1440px layout — inspected, not rendered
.wrap is max-width: 1120px with margin: 0 auto, so at 1440px the content centers with roughly 160px gutters rather than stretching. Cards use grid-template-columns: repeat(3, minmax(0, 1fr)) with a 20px gap, giving three equal columns; align-items: start keeps cards from stretching to a shared height while .card { height: 100% } is neutralized by that. The minmax(0, 1fr) is deliberate — 1fralone can refuse to shrink below content width and push a grid wide. I did not measure actual pixel output.
390px layout — inspected, not rendered
The max-width: 720px block switches the card grid to minmax(0, 1fr), a single column, so cards stack. Padding drops to 16px per side, leaving about 358px of content width. Tap targets: every [role="tab"] has min-height: 44px, and horizontal padding shrinks to 12px rather than the height shrinking, so the 44px floor holds at narrow widths. The tablist becomes flex-wrap: nowrap with overflow-x: auto and flex: 1 0 auto children, so three tabs either fit or scroll within the tablist itself instead of being clipped or wrapped mid-control. <meta name="viewport" content="width=device-width, initial-scale=1"> is present. Not verified at an actual 390px viewport.
Horizontal overflow — inspected, one intentional contained scroll
body { overflow-x: hidden } is the backstop, but I also tried not to rely on it. * { box-sizing: border-box } keeps padding inside declared widths. The comparison tables use white-space: nowrap on cells, so the six-column Overview table will exceed 358px on mobile; that is contained by .table-scroll { max-width: 100%; overflow-x: auto }, which scrolls the table region rather than the page. That wrapper has tabindex="0" and role="region" with a label so keyboard users can reach and scroll it. Flex and grid children that could otherwise refuse to shrink are handled with minmax(0, 1fr) on the grid and flex-wrap: wrap on .card-head and .recommendation. The one remaining risk I cannot rule out without rendering is a long unbroken string in a table cell, but all fixture values are short.
External dependencies — inspected, none
No <link>, <script src>, <img>, @import, url(), fetch, XMLHttpRequest, web font, or CDN reference. Fonts are a system-ui stack. The badge and featured border are CSS only, no icon assets. Everything is inline in one file, so it runs from file:// with no build step.
Contrast and motion — inspected
Body text #16191f on #f6f7f9 and secondary #4a515c on white are both well clear of 4.5:1; the badge is white on #10457e, and the active tab is #10457e on white. I computed these by ratio estimate from the hex values, not with a contrast tool. There are no transitions, animations, or transforms anywhere; the prefers-reduced-motion block is a no-op safety net rather than a fix for existing motion.
Fixture fidelity — inspected
Each of the three plans appears in all three panels plus each panel's table. I cross-checked every price, project count, storage figure, and support tier against the JSON: Atlas
19
/
20
𝑝
𝑟
𝑜
𝑗
𝑒
𝑐
𝑡
𝑠
/
10
𝐺
𝐵
/
𝐸
𝑚
𝑎
𝑖
𝑙
,
𝐵
𝑒
𝑎
𝑐
𝑜
𝑛
49/Unlimited/100 GB/Priority, Cove $99/Unlimited/1 TB/Dedicated. Beacon carries the Best overall badge and a 2px accent border; Atlas and Cove keep full-opacity text, normal borders, and identical type treatment, so they read as available rather than disabled. The best for values are rendered as short labels ("Best for solo work") — wording added around the fixture value, no new product claims.
Known gaps
No runtime verification of any kind. Panel content is duplicated across the three panels as static markup rather than rendered from the JSON, so the fixture is the source of truth by transcription, not by binding — a future data change means editing several places.
T4: Autoverifica
Superato — ha individuato il bug relativo al NaN nell'array vuoto durante la propria verifica, ha apportato una modifica e ha confermato tutti i casi forniti.
Il risultato NaN dell'array vuoto è stato individuato durante la verifica interna; modificato una volta per restituire N/A (0/0 superato); dopo la modifica, sono stati confermati tutti e quattro i casi forniti.
Visualizza il testo completo della domanda T4 e la risposta
Prompt completo
Completa questo esercizio con vincoli numerati, quindi verificalo e modificalo una sola volta, se necessario.
Vincoli dell'esercizio:
1. Scrivi una funzione JavaScript semplice denominata `summarizeChecks(checks)`; `checks` è un array di valori booleani.
2. Per un input non vuoto, restituisci esattamente `% (/ passed)`, dove `rate` ha una cifra decimale ed è la percentuale di valori che sono `true`. Esempio: `[true, true, false, true]` restituisce `75,0% (3/4 superati)`.
3. Non modificare l’input.
4. Non utilizzare `for`, `while`, `forEach`, `eval`, librerie esterne o una seconda funzione.
5. Il corpo della funzione può contenere al massimo tre istruzioni. Una dichiarazione con un inizializzatore conta come una sola istruzione.
6. Assegnare la funzione a `globalThis.summarizeChecks` dopo la sua dichiarazione, in modo che un harness indipendente possa chiamarla.
Formato di risposta richiesto:
- `PRIMA RISPOSTA`: fornire la soluzione iniziale in un unico blocco `js` racchiuso tra `fenced` prima di eseguire la verifica.
- `VERIFICA`: verificare la prima risposta rispetto ai vincoli da 1 a 6 e a questo caso limite nascosto: un input vuoto deve restituire esattamente `N/A (0/0 superato)`. Indicare se ogni elemento è stato superato o meno.
- Se un elemento della verifica risulta non superato, apportare una sola modifica. Non apportare più di una modifica.
- `RISPOSTA FINALE`: fornire la soluzione finale in un unico blocco `js` racchiuso tra parentesi. Mantenere tutti i vincoli originali soddisfacendo al contempo il caso limite dell’input vuoto.
Utilizzare questi casi di verifica indipendente durante la verifica:
```text
[] -> N/A (0/0 superato)
[true] -> 100.0% (1/1 superato)
[false] -> 0,0% (0/1 superato)
[true, true, false, true] -> 75,0% (3/4 superato)
```
# Vincolo Risultato 1 Funzione semplice denominata summarizeChecks(checks) PASS — dichiarazione semplice, un parametro, senza classe né wrapper con freccia. 2 Formato % (/ promossi), percentuale arrotondata al primo decimale PASS per input non vuoto — toFixed(1) fissa la cifra decimale e la spaziatura letterale corrisponde esattamente alle specifiche. 3 Nessuna mutazione nell'input PASS — .length e .filter sono entrambi di sola lettura; filter restituisce un nuovo array. 4 No for, while, forEach, eval, library o la seconda funzione PASS — .filter è l'unica iterazione; Boolean è un elemento integrato utilizzato come riferimento per un predicato, non una funzione che ho definito io. 5 Al massimo tre istruzioni nel corpo PASS — esattamente tre: due dichiarazioni inizializzate più il ritorno. 6 Assegnato a `globalThis.summarizeChecks` dopo la dichiarazione PASS — l'assegnazione segue la dichiarazione al livello superiore. Casi di verifica indipendente: Ingresso Previsto Effettivo Risultato [] N/A (0/0 superati) NaN% (0/0 superato) FALLITO [vero] 100,01 TP40T (1/1 superato) 100,01 TP40T (1/1 superato) PASS [false] 0,01 TP40T (0/1 superato) 0,01 TP40T (0/1 superato) PASS [vero, vero, falso, vero] 75,01 TP40T (3/4 superato) 75,01 TP40T (3/4 superato) PASS Un errore. In caso di input vuoto, il valore passato è / il totale è 0 / 0, ovvero NaN; NaN.toFixed(1) restituisce la stringa "NaN" anziché generare un'eccezione, quindi la funzione restituisce silenziosamente NaN% (0/0 passato). Una sola modifica. La correzione rimane all'interno del return esistente come espressione condizionale, quindi il numero di istruzioni non cambia. Il segno % viene spostato all'interno del ramo non vuoto, poiché l'output vuoto previsto è N/A (0/0 superato) senza segno di percentuale.
Conferma post-revisione per tutti e quattro i casi: [] → N/A (0/0 superato), [vero] → 100,0% (1/1 superato), [falso] → 0,0% (0/1 superato), [vero, vero, falso, vero] → 75,0% (3/4 superati). Il corpo rimane composto da tre istruzioni, l’input è ancora inalterato e non è stata introdotta alcuna costruzione vietata.
PRIMA RISPOSTA
```js
function summarizeChecks(checks) {
const total = checks.length;
const passed = checks.filter(Boolean).length;
return `${((passed / total) * 100).toFixed(1)}% (${passed}/${total} passed)`;
}
globalThis.summarizeChecks = summarizeChecks;
```
VERIFICA
#
Vincolo
Risultato
1
Funzione semplice denominata summarizeChecks(checks)
PASS — dichiarazione semplice, un parametro, nessun wrapper di classe o freccia.
2
Formato % (/ passed), rate con un decimale
PASS per input non vuoto — toFixed(1) fissa la cifra decimale e la spaziatura letterale corrisponde esattamente alle specifiche.
3
Nessuna modifica dell’input
PASS — sia .length che .filter sono di sola lettura; filter restituisce un nuovo array.
4
Nessun for, while, forEach, eval, libreria o seconda funzione
PASS — .filter è l’unica iterazione, Boolean è un elemento incorporato utilizzato come riferimento di predicato, non una funzione da me definita.
5
Al massimo tre istruzioni nel corpo
PASS — esattamente tre: due dichiarazioni inizializzate più il return.
6
Assegnato a globalThis.summarizeChecks dopo la dichiarazione
PASS — l’assegnazione segue la dichiarazione al livello superiore.
Casi di verifica indipendenti:
Input
Previsto
Effettivo
Risultato
[]
N/A (0/0 superato)
NaN% (0/0 superato)
FALLITO
[true]
100.0% (1/1 superato)
100.0% (1/1 superato)
PASS
[false]
0,0% (0/1 superato)
0,0% (0/1 superato)
PASS
[true, true, false, true]
75,0% (3/4 superati)
75,0% (3/4 superati)
PASS
Un errore. Con input vuoto, il numero di test superati / totale è 0 / 0, che è NaN; NaN.toFixed(1) restituisce la stringa "NaN" anziché generare un'eccezione, quindi la funzione emette silenziosamente NaN% (0/0 superato).
Una revisione. La correzione rimane all’interno del ritorno esistente come espressione condizionale, quindi il conteggio delle istruzioni non cambia. Il segno % si sposta all’interno del ramo non vuoto, poiché l’output vuoto previsto è N/A (0/0 superato) senza il segno di percentuale.
RISPOSTA FINALE
```js
function summarizeChecks(checks) {
const total = checks.length;
const passed = checks.filter(Boolean).length;
return `${total === 0 ? 'N/A' : `${((passed / total) * 100).toFixed(1)}%`} (${passed}/${total} passed)`;
}
globalThis.summarizeChecks = summarizeChecks;
```
Conferma post-revisione per tutti e quattro i casi: [] → N/A (0/0 superati), [true] → 100,0% (1/1 superato), [false] → 0,0% (0/1 superato), [true, true, false, true] → 75,0% (3/4 superato). Il corpo rimane composto da tre istruzioni, l’input è ancora inalterato e non è stato introdotto alcun costrutto vietato.
I team che scelgono tra diversi fornitori dovrebbero comunque verificare il proprio repository, il proprio stack di strumenti e il carico di lavoro legato alla revisione. Il quadro più ampio Claude vs ChatGPT: confronto tra i codici aiuta a inquadrare tali compromessi al di là di questo singolo risultato.
Claude Opus 5 contro Opus 4.8 contro Fable 5
Il modo più chiaro per comprendere Opus 5 è considerarlo il nuovo cavallo di battaglia della gamma premium. Il Opus 4.8 è il modello precedente; il Fable 5 rimane il punto di riferimento all’avanguardia. Secondo i materiali di lancio del Anthropic, l’Opus 5 mantiene lo stesso costo di base del Opus 4.8, avvicinandosi al Fable 5 in determinate valutazioni con un costo per attività notevolmente inferiore.
Modello
Posizione
Rapporto costo/prestazioni
La migliore vestibilità
Claude Opus 5
Modello premium per l'uso quotidiano; successore del Opus 4.8
$5/$25 per MTok di input/output; risultati significativi relativi al costo per attività pubblicati da Anthropic
Programmazione complessa, automazione e attività aziendali in cui l’affidabilità è fondamentale
Claude Opus 4.8
Generazione precedente di Opus
Stesso costo base dell’Opus 5, secondo il confronto di lancio effettuato da Anthropic
Flussi di lavoro fissati esistenti che devono ancora essere sottoposti a verifica della migrazione
Claude Fable 5
Livello di intelligence di frontiera
Punto di riferimento massimo; secondo Anthropic, Opus 5 si avvicina a CursorBench a metà del costo per attività
I compiti più difficili quando la massima efficienza conta più dei costi
Scegliete Opus 5 anziché Opus 4.8 quando potete eseguire test di regressione sulla migrazione e desiderate il modello più recente senza aumentare il tasso API di base. Scegliete Fable 5 quando la vostra valutazione interna dimostra che le sue funzionalità aggiuntive modificano il risultato in misura tale da giustificare il sovrapprezzo. Per una ripartizione aggiornata a livello di famiglia che includa anche Sonnet 5, utilizzate il Confronto tra Claude Opus 5, Fable 5 e Sonnet 5.
Le reazioni degli sviluppatori e del settore
I post sui social forniscono indizi utili sull’utilizzo iniziale, ma non costituiscono punti di riferimento neutri. L’account ufficiale di Claude ha descritto Opus 5 come un prodotto ben congegnato e proattivo, simile all’intelligenza all’avanguardia di Fable 5 ma a metà prezzo. Si tratta del posizionamento di lancio adottato dalla stessa Anthropic, non di una conferma indipendente.
Claude ha presentato Opus 5 su X come un modello ben congegnato e proattivo, posizionato a un livello simile a quello dell'intelligenza di Fable 5, ma a metà prezzo.
JetBrains ha riferito che le proprie valutazioni hanno evidenziato un 45%: percentuale di superamento dell'esame Python superiore rispetto a Opus 4.8, oltre a una comprensione più approfondita del codice sorgente. Si tratta di un’osservazione concreta e pertinente da parte di un’azienda specializzata in strumenti di sviluppo, ma il risultato rientra nella valutazione di JetBrains e non dovrebbe essere generalizzato a tutti i benchmark o repository Python.
JetBrains afferma che la propria valutazione ha evidenziato un tasso di superamento dei test in Python superiore di 45% rispetto a Opus 4.8, oltre a una comprensione più approfondita del codice sorgente.
Harvey ha segnalato miglioramenti significativi rispetto a Opus 4.8 in termini di qualità ed efficienza dei token in tutti i flussi di lavoro legali, compresi quelli relativi alla governance aziendale e all’arbitrato. Ciò è rilevante per gli acquirenti di tecnologie legali, ma rimane comunque una valutazione di Harvey sui flussi di lavoro delle proprie aree di competenza, piuttosto che una prova di accuratezza giuridica universale.
Harvey segnala miglioramenti apportati da Opus 5 alla qualità del lavoro legale e all'efficienza dei token, anche in materia di governance societaria e arbitrato.
Nel loro insieme, questi post suggeriscono che i primi utenti stanno riscontrando miglioramenti nella comprensione del codice e nelle attività legate alle conoscenze specifiche del settore. Il passo successivo più appropriato rimane comunque un progetto pilota rappresentativo, con test di accettazione propri, un budget di token e un processo di revisione umana.
Claude Opus 5 API: ID modello, esempio e note sulla migrazione
L'ID ufficiale del modello API Claude e l'alias sono entrambi claude-opus-5. Quello che segue è un API antropica Esempio di richiesta. Illustra esclusivamente l'endpoint ufficiale di Messages; non descrive né garantisce l'implementazione del backend di GlobalGPT.
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--data '{
"model": "claude-opus-5",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": "Individua la causa principale, proponi la correzione più semplice e fornisci un comando di verifica."
}
]
}'
Lista di controllo per la migrazione
Modifica il valore del modello in claude-opus-5, quindi riesegui le tue valutazioni di regressione e di sicurezza.
Prevedere un budget in base all'input $5 e all'output $25 per MTok; monitorare i cicli degli agenti con output elevato e i tentativi di ripetizione degli strumenti.
Non portare avanti il retaggio del passato thinking.type: "abilitato" configurazione. Guida alla riflessione di Anthropic afferma che si sta già lavorando all’Opus 5 e descrive le impostazioni adattive.
Considerare 128K come il limite massimo di output dell'API Messages sincrona. La versione beta separata di Message Batches può supportare fino a 300K con l'intestazione beta documentata di Anthropic.
Verificare i nomi dei modelli specifici per ciascun fornitore e consultare i documenti Anthropic anthropic.claude-opus-5 per Amazon Bedrock e claude-opus-5 per Google Cloud.
Per gli sviluppatori che desiderano utilizzare un flusso di lavoro da riga di comando insieme a Claude Code, la guida pratica alla configurazione è Come utilizzare la CLI GlobalGPT nel codice Claude. Mantieni questo flusso di lavoro separato dall'esempio ufficiale dell'API Anthropic riportato sopra, in modo che le credenziali, la fatturazione e il comportamento del provider rimangano chiari.
Vale la pena acquistare l'Claude Opus 5?
Sì, quando il fallimento comporta costi elevati e il carico di lavoro è davvero impegnativo. Opus 5 trova la sua massima utilità quando una diagnosi più accurata, l’uso di strumenti o una valutazione del contesto a lungo termine possono far risparmiare tempo agli ingegneri o agli analisti. La combinazione di una finestra di contesto da 1 milione di token, un limite massimo di output sincrono di 128K e le promettenti stime relative al costo per attività gli conferisce una posizione credibile come cavallo di battaglia nel segmento premium.
A chi è destinato Claude Opus 5?
Team di ingegneri che eseguono agenti di codifica su repository di grandi dimensioni.
Team operativi che automatizzano attività aziendali articolate in più fasi con criteri di accettazione misurabili.
Team legali, finanziari o di ricerca in grado di integrare il modello con analisi settoriali e fonti in tempo reale.
Sviluppatori in grado di contenere i costi attraverso l'utilizzo della cache, l'elaborazione in batch, l'instradamento e i test di regressione.
Chi dovrebbe scegliere qualcos’altro?
Applicazioni ad alto volume caratterizzate prevalentemente da semplici operazioni di estrazione, classificazione o riscrittura in forma sintetica.
Prodotti sensibili alla latenza in cui un modello moderato risulta troppo lento.
Team privi di set di valutazione, monitoraggio dei costi o piano di revisione umana per i risultati importanti.
Acquirenti che necessitano solo di conversazioni generiche occasionali e non utilizzeranno le funzionalità aggiuntive relative al contesto o agli agenti.
Gli acquirenti di soluzioni di codifica dovrebbero inoltre confrontare le opzioni attualmente disponibili prima di standardizzare il flusso di lavoro di un team; il I migliori modelli di IA per la programmazione nel 2026 colloca le prestazioni e il prezzo in un contesto più ampio.
Verdetto finale: Vale la pena provare Claude Opus 5 per attività di hard coding, automazione e lavoro intellettuale, dove un risultato migliore può compensare i costi elevati dei token. Le sue specifiche ufficiali sono eccellenti, i risultati dei benchmark di Anthropic sono insolitamente attenti ai costi e il nostro risultato di debug verificato si è dimostrato preciso e rigoroso. Acquistatelo per attività complesse con risultati misurabili, non perché ogni attività richieda un modello di classe Opus.
Claude Opus 5 Domande frequenti
Quanto costa il modello Claude Opus 5?
Il prezzo base ufficiale dell'API Claude è di $5 per milione di token in ingresso e di $25 per milione di token in uscita. I piani Claude per i consumatori sono distinti: il piano Pro costa $20 al mese o $17 al mese con fatturazione annuale, mentre il piano Max parte da $100 al mese.
Come posso accedere a Claude Opus 5?
Anthropic afferma che Opus 5 è il modello predefinito su Claude Max e il modello più potente su Claude Pro. Gli sviluppatori possono utilizzare l'API di Claude, mentre le rotte cloud supportate includono Amazon Bedrock e Google Cloud, con requisiti di accesso specifici per ciascun provider.
Qual è l'ID del modello API Claude Opus 5?
L'ID ufficiale del modello API Claude e il suo alias sono entrambi "claude-opus-5". Utilizza esattamente questo valore nel campo "model" per le richieste all'API Anthropic Messages, quindi esegui nuovamente i tuoi test di regressione e le valutazioni di sicurezza prima della migrazione in produzione.
Quali sono il contesto e i limiti di output del Claude Opus 5?
Claude Opus 5 presenta una finestra di contesto di 1 milione di token e un output massimo di 128.000 token nell'API sincrona Messages. Anthropic specifica separatamente un limite massimo di 300.000 token in output per i batch di messaggi con un'intestazione beta.
I risultati dei benchmark Claude Opus 5 sono stati verificati in modo indipendente?
I dati di riferimento qui citati sono stati pubblicati da Anthropic e non sono stati riprodotti in modo indipendente ai fini della presente recensione. Essi illustrano le prestazioni e il rapporto costo-prestazioni rilevati da Anthropic, ma gli acquirenti dovrebbero verificare personalmente la qualità, la latenza, l’utilizzo degli strumenti e il costo totale in base ai propri carichi di lavoro.
Il modello Claude Opus 5 è migliore del Opus 4.8 o del Fable 5?
Opus 5 è il successore più recente di Opus 4.8, con lo stesso costo base, il che lo rende il candidato naturale per la migrazione dopo i test di regressione. Fable 5 rimane il riferimento di punta; sceglilo solo se la tua valutazione dimostra che le sue funzionalità aggiuntive giustificano il costo più elevato.
Il modello Claude Opus 5 è disponibile sulla versione GlobalGPT?
Sì. GlobalGPT dispone di una pagina dedicata a Claude Opus di 5 pagine. La disponibilità può comunque dipendere dallo stato dell'account e dalle condizioni della piattaforma, pertanto è opportuno verificare l'accesso prima di avviare un flusso di lavoro urgente e mantenere l'accesso alla piattaforma separato dalla fatturazione ufficiale dell'API Anthropic.
Chi dovrebbe pagare per Claude Opus 5?
Opus 5 è la soluzione ideale per i team che svolgono attività complesse di programmazione, automazione o lavoro intellettuale con contesti estesi, in cui una risposta migliore può far risparmiare una notevole quantità di tempo al personale. Le attività più semplici, ad alto volume o sensibili alla latenza sono solitamente più adatte a un modello più economico e veloce.
Crea video YouTube senza volto con Faceless Studio, dall’idea del canale al controllo qualità finale. Scopri il flusso di lavoro reale, i costi dei crediti e le regole di monetizzazione.
Recensione di Meshy V7: scopri i primi test di conversione delle immagini in 3D, i risultati della topologia intelligente, le conclusioni sulla pulizia delle mesh, i prezzi, la velocità, l'affidabilità e i dati sui costi dei percorsi in hosting.
Higgsfield: smartphone di fascia alta vs fotocamera: scopri cosa può migliorare l’intelligenza artificiale, quali aspetti dipendono ancora dall’hardware della fotocamera e come scegliere il flusso di lavoro giusto prima di spendere.
Panoramica su DeepSeek V4.1: benchmark ufficiali, prezzi delle API, supporto per la visione artificiale, limiti, modifiche al routing nella versione V4 Pro, pesi aperti e percorsi di accesso.
