Anthropic ha appena rilasciato il modello più potente mai costruito, e il balzo nei benchmark è quasi la parte meno interessante.
Claude Fable 5.1 sembra meno un chatbot migliorato e più un nuovo tipo di operatore. Può rimanere su un problema per ore, riprendersi quando un piano fallisce, coordinare altri agenti, ispezionare il proprio output e continuare ad andare avanti senza bisogno che qualcuno lo salvi ogni dieci minuti.
I numeri lo confermano. Nelle valutazioni pubblicate da Anthropic, Fable 5.1 ha più che raddoppiato Fable 5 nella ricerca scientifica agentica, è passato dal 17,1% al 31,4% nell'automazione aziendale e ha raggiunto il 73,4% su CursorBench. Ha anche superato Fable 5, Opus 5 e GPT-5.6 Sol nella maggior parte dei test di coding, automazione, uso del computer e knowledge work riportati da Anthropic.
https://x.com/claudeai/status/2094848581425377479
Appena uscito dalla scatola, è eccezionale nel coding difficile, nel lavoro a lungo termine, nella ricerca, nella pianificazione, nell'uso del computer e nella produzione di deliverable completi. Ma l'opportunità più grande è ciò che accade quando smetti di usarlo come la persona che esegue ogni compito e lo metti a capo del sistema che fa il lavoro.
Questo è ciò che copre questo corso: dove Fable 5.1 è veramente diverso, come metterlo al posto di comando, come costruire i lavoratori sotto di lui, come dargli prompt senza soffocarlo, come usare obiettivi e loop, e i cinque flussi di lavoro in cui la differenza può trasformarsi in denaro reale.
Se non ti interessano terminali, file degli agenti e orchestrazione e vuoi semplicemente trasformare un'idea in un'app funzionante, ecco a cosa serve Shipper.
in cosa questo modello è davvero eccezionale
Prima dei metodi, conosci la macchina. Queste sono le cinque abilità che rendono Fable 5.1 diverso dai modelli precedenti.
rimane coerente per esecuzioni incredibilmente lunghe
Dagli un lavoro che richiede ore ed è molto meno probabile che perda il filo a metà strada.
Un primo tester ha riportato un'esecuzione automatica di machine learning di 38 ore in cui Fable ha diagnosticato un risultato precedente errato, lo ha corretto, ha lanciato sei esperimenti in parallelo ed è tornato con i risultati e i passaggi successivi. Un altro ha detto che ha tenuto i propri registri, ha ri-priorizzato quando le condizioni sono cambiate e ha ripreso da dove aveva interrotto.
La finestra di contesto da 1 milione di token aiuta, ma la dimensione del contesto non è il vero aggiornamento. L'aggiornamento è che il modello può continuare a prendere decisioni utili all'interno di quel contesto invece di limitarsi a ricordare che l'informazione esiste.
cerca la causa principale, non la soluzione più veloce
Gli agenti precedenti spesso trovavano la prima soluzione che faceva sparire un errore. Fable 5.1 è più disposto a continuare a scavare finché non capisce perché l'errore esisteva.
Nei test di lancio di Anthropic, Millennium gli ha dato un crash che si verificava circa una volta ogni milione di esecuzioni ed era rimasto inspiegato per quattro o cinque anni. Fable 5.1 ha smontato una libreria esterna, l'ha collegata al core dump e ha tracciato il crash fino al bug reale. Ogni altro modello che avevano provato, incluso Fable 5, lo aveva mancato.
Questo è importante ben oltre il debugging. Lo stesso istinto si manifesta nella ricerca, nella strategia, nell'analisi finanziaria e nelle operazioni: non ottimizzare il sintomo quando il sistema sottostante è sbagliato.
può vedere, agire e verificare
Fable 5.1 può ispezionare screenshot, grafici, PDF, interfacce e documenti, poi usare ciò che vede per guidare l'azione successiva.
Ciò significa che può ricostruire un'interfaccia da riferimenti, leggere le cifre sepolte all'interno di un documento finanziario, operare un browser, confrontare la sua implementazione con il design originale e cogliere problemi visivi prima di dichiarare il lavoro finito.
Il suo punteggio OSWorld per l'uso del computer è salito al di sopra sia di Fable 5 che di Opus 5 nei test di Anthropic. Ancora più importante, il modello è sempre più in grado di usare la visione come parte di un ciclo di verifica, non solo per descrivere l'immagine che gli hai dato.
restituisce il lavoro, non una lezione sul lavoro
Dagli una cartella di documenti e chiedi un memo di investimento, una presentazione, un prototipo funzionante o un'analisi, ed è molto più probabile che restituisca l'artefatto stesso.
I primi tester hanno riportato i migliori risultati PowerPoint di Anthropic fino ad oggi, un richiamo delle citazioni più forte sui documenti finanziari, redline contrattuali più concise e un migliore completamento di richieste complesse in più parti. Un ingegnere di MongoDB ha descritto un'esecuzione prototipo di tre giorni in cui il modello ha ricercato i servizi esistenti, progettato il sistema, lo ha implementato in fasi automatiche e ha restituito walkthrough visivi con prove che ogni fase funzionava.
La differenza pratica è semplice: passi meno tempo a convertire una risposta in lavoro utilizzabile.
è stato costruito per guidare
Fable 5.1 è più prezioso quando decide cosa dovrebbe succedere dopo.
Claude Code può già dargli subagenti, sessioni in background, team di agenti, flussi di lavoro dinamici, obiettivi, loop, browser, terminali e file di progetto. Fable ha abbastanza profondità di pianificazione e contesto per mantenere quei pezzi puntati verso un unico traguardo per molto più tempo di quanto i modelli precedenti potessero.
Ecco perché la configurazione qui sotto funziona, e perché il corso inizia togliendo Fable dal posto di lavoro.
la cabina di pilotaggio: tutti i comandi di cui hai davvero bisogno
Aggiorna Claude Code prima di fare qualsiasi altra cosa. Secondo l'attuale documentazione sulla configurazione del modello, la versione 2.1.255 o successiva fa sì che l'alias fable punti a Fable 5.1, e le versioni recenti includono i controlli goal, loop, background-agent ed effort usati qui sotto.
Poi seleziona il modello e il livello di effort:
/model fable
/effort high
High è l'impostazione predefinita sensata per lavori sostanziali. Scendi a medium per passaggi più economici e veloci. Passa a xhigh o max solo quando il problema è abbastanza difficile da giustificare più pensiero. Il pensiero adattivo di Fable è sempre attivo, quindi l'effort è il controllo che conta.
I controlli rimanenti sono semplici:
/plan o Shift+Tab: lascia che ispezioni e pianifichi prima di modificare i file
/goal: continua a lavorare tra un turno e l'altro finché una condizione verificabile non è soddisfatta
/loop: riesegue un prompt secondo una pianificazione mentre la sessione rimane attiva
/tasks: vedi cosa stanno facendo i lavoratori in background
/context: vedi cosa sta consumando la finestra di contesto
Questa è la cabina di pilotaggio.
Il resto del corso è sapere quale controllo usare e quando.
l'evento principale: rendi Fable il leader, non il lavoratore
L'aggiornamento singolo più grande è un cambio di ruolo.
Smetti di dare a Fable ogni compito da tastiera. Fallo definire il lavoro, suddividerlo in corsie pulite, inviare quelle corsie ad agenti più economici e giudicare ciò che torna indietro.
La configurazione è questa:
Fable modella il piano:
mettilo in modalità piano e lascia che ispezioni il progetto prima di proporre modifiche. Se la richiesta è ancora vaga, usa la
collezione di skills di Matt Pocock per interrogare l'idea, trasformare la conversazione in una specifica e suddividere la specifica in ticket.
Fable delega il lavoro isolato:
l'implementazione va a subagenti Opus o Sonnet, con ogni lavoratore che possiede una corsia delimitata. Codex può essere un altro lavoratore se lo usi già, ma dovrebbe seguire le stesse regole di confine dei file e di evidenza.
Un agente separato verifica:
il lavoratore non valuta i propri compiti. Un verificatore nuovo legge il piano, ispeziona il diff, esegue i controlli e supera la fase o la restituisce con un fallimento concreto.
Tu guidi ai checkpoint:
approva il piano, rivedi i compromessi significativi e ispeziona le prove alla fine. Non hai bisogno di guardare ogni comando.
Perché funziona: il modello costoso spende i suoi token in architettura, prioritizzazione, recupero e giudizio. I modelli più economici spendono i loro in esecuzione delimitata.
L'economia funziona solo quando le corsie sono veramente indipendenti. Con l'attuale prezzi API di Anthropic, Fable 5.1 costa $10 per milione di token di input e $50 per milione di token di output, mentre Opus 5 costa la metà e Sonnet 5 un quinto. Fable 5.1 ha anche ridotto le letture della cache a $0,25 per milione di token, il che rende le sessioni lunghe con un contesto di progetto stabile molto più pratiche.
Non parallelizzare per teatro. Cinque agenti che modificano gli stessi file creeranno cinque fatture e un problema di merge. Parallelizza ricerca, moduli isolati, test, documentazione e altre corsie che possono finire senza aspettarsi a vicenda.
costruisci i tuoi lavoratori
Il leader ha bisogno di una piccola squadra, e un lavoratore personalizzato è solo un file Markdown dentro .claude/agents/.
Inizia con un lavoratore di implementazione:
name: implementation-worker
description: Implementa una fase isolata da un piano approvato. Usa solo quando la fase possiede file distinti.
model: opus
tools: Read, Grep, Glob, Edit, Write, Bash
maxTurns: 25
Possiedi solo la fase che ti è stata assegnata.
Prima di modificare, identifica i file esatti e i criteri di accettazione nella tua corsia.
Non modificare file posseduti da un altro lavoratore.
Implementa la soluzione completa più piccola, poi esegui i test pertinenti.
Restituisci:
- file modificati
- controlli eseguiti e il loro output reale
- tutto ciò che è ancora incerto
Non dichiarare successo senza prove da questa esecuzione.
Poi crea il lavoratore che conta di più, il verificatore:
name: verifier
description: Verifica in modo indipendente una fase completata rispetto al suo piano e ai criteri di accettazione. Usa dopo ogni fase di implementazione.
model: opus
tools: Read, Grep, Glob, Bash
maxTurns: 15
Tratta il riepilogo dell'implementazione come un'affermazione non attendibile.
Leggi il piano e ispeziona il diff effettivo. Esegui tu stesso i test pertinenti.
Controlla correttezza, regressioni, ambito e ogni criterio di accettazione.
Restituisci PASS o FAIL.
Per ogni fallimento, includi le prove e la correzione minima richiesta.
Non modificare mai l'implementazione che stai valutando.
Occhi nuovi colgono ciò che l'autore normalizza. Una fase controllata immediatamente è molto più economica di un difetto scoperto dopo che altre quattro fasi dipendono da essa.
Quattro regole mantengono la squadra veloce:
un lavoratore, una corsia, con proprietà esplicita dei file
lavoro parallelo solo quando le corsie non dipendono l'una dall'altra
Fable rimane al posto di comando mentre Opus o Sonnet gestisce il lavoro
ogni affermazione di completamento viene verificata rispetto ai file, ai test o al risultato live
segreto 1: non prescrivere il percorso
La maggior parte dei consigli sui prompt è stata scritta per impedire ai modelli più deboli di vagare.
Procedure lunghe, elenchi di passaggi rigidi e blocchi di regole enormi aiutavano quando il modello non poteva pianificare. Con Fable 5.1, quella stessa impalcatura può forzarlo lungo un percorso peggiore di quello che avrebbe trovato da solo.
Il trucco è essere severi sulla destinazione e flessibili sul percorso.
Dagli quattro cose:
il risultato:
cosa deve esistere quando il lavoro è finito
i vincoli:
cosa non può rompere, spendere, esporre o modificare
il motivo:
per chi è e quale decisione o lavoro il risultato deve supportare
la prova:
quale evidenza osservabile conterà come finito
Quest'ultima parte cambia tutto. "Fai funzionare il checkout" invita a un'affermazione plausibile. "Completa un acquisto di prova nella sandbox e mostra la riga dell'ordine risultante" dà al modello un traguardo che non può aggirare con le parole.
Non chiedere una performance di catena di pensiero nascosta. Chiedi il piano, le decisioni importanti, le prove e l'incertezza rimanente. Il pensiero di Fable è già sempre attivo. Ciò che conta per te è se il risultato sopravvive all'ispezione.
E non continuare a ricordargli che il budget sta scomparendo. Metti invece il confine nel sistema: limita i turni dei lavoratori, definisci la spesa consentita e digli cosa fare quando il limite viene raggiunto.
segreto 2: mantieni CLAUDE.md leggero
CLAUDE.md viene caricato all'inizio di ogni sessione di Claude Code. Questo lo rende utile, ma significa anche che ogni riga irrilevante tassa ogni attività futura.
Anthropic ora raccomanda di mantenere ogni file sotto le 200 righe. In pratica, il tuo può di solito essere molto più corto.
Tre sezioni coprono la maggior parte dei progetti:
cos'è questo progetto:
il prodotto, l'architettura e i confini importanti
come verificare il lavoro:
i comandi per build, test, lint e anteprima locale
cosa sbaglia ripetutamente:
convenzioni specifiche del progetto ed errori ricorrenti
Le procedure che contano solo a volte appartengono alle skills. Le regole che si applicano solo a certi file appartengono alle regole con ambito di percorso. Le note storiche appartengono alla documentazione, non al prompt di ogni sessione.
Apri il tuo CLAUDE.md stasera e sfida ogni riga: se rimuoverla non causerebbe un vero errore, rimuovila.
Il file più leggero è di solito quello più forte.
segreto 3: abusa di obiettivi e loop
Qui è dove Fable smette di essere una conversazione e diventa un processo che può continuare a muoversi mentre fai altro.
Obiettivi: /goal dà alla sessione una condizione di completamento verificabile. Dopo ogni turno, un modello separato e piccolo controlla se la condizione è soddisfatta. Se non lo è, Fable inizia un altro turno invece di restituire il controllo a te. L'obiettivo termina quando viene superato, diventa impossibile, incontra un errore irreversibile o lo cancelli.
L'arte è scrivere un traguardo che non può falsificare:
esigi prove osservabili: "tutti i test di autenticazione passano e l'output è allegato" è più forte di "sistema l'autenticazione"
definisci il percorso di fallimento: se un vero blocco rende l'obiettivo impossibile, segnala il blocco e le prove invece di inventare progressi
limita le parti rischiose: usa maxTurns per i lavoratori, limiti di spesa per i servizi a pagamento e confini espliciti intorno a distribuzioni o dati di produzione
mantieni una regola di onestà in ogni brief: ogni affermazione di progresso deve puntare a un risultato prodotto o ispezionato durante questa esecuzione
Esegui gli obiettivi in modalità automatica solo all'interno di confini che ti senti di lasciare incustoditi. Un agente più intelligente ha un raggio di esplosione più ampio quando il brief è sbagliato.
Loop: /loop riesegue un prompt a intervalli. Usa /loop 15m controlla la distribuzione e indaga su qualsiasi fallimento per una cadenza fissa, o ometti l'intervallo e lascia che Claude scelga quando controllare di nuovo.
I loop all'interno di Claude Code sono limitati alla sessione e alla fine scadono. Usali per build, pull request, migrazioni e monitoraggio temporaneo. Usa una routine persistente o un'attività pianificata del desktop per il lavoro che deve sopravvivere dopo la chiusura della sessione o della macchina.
Tra obiettivi e loop, puoi tenere Fable al lavoro per tutto il tempo che il lavoro richiede veramente, con le prove che ti aspettano alla fine invece di un altro paragrafo sicuro di sé.
come realizzare un progetto reale in un colpo solo
Ora assembla l'intero sistema intorno a una build.
L'esempio è una landing page con una lista d'attesa funzionante. Sostituisci il progetto e la stessa sequenza vale.
passo 1, scrivi il brief
Invia un messaggio:
Sto lanciando [prodotto] per [pubblico]. Hanno bisogno di una landing page che faccia una promessa chiara e catturi
email. Costruisci una pagina reattiva con un modulo funzionante che memorizzi le iscrizioni.Vincoli: nessun framework da dover gestire, nessuna dipendenza a pagamento, veloce su mobile e nessuna distribuzione finché non la approvo.Finito significa che la pagina viene eseguita localmente, un'email di test appare nell'archivio, il layout mobile è verificato a 390px e il risultato viene mostrato con output di test e screenshot.Ispeziona il progetto e pianifica prima. Delega solo fasi indipendenti. Verifica ogni fase completata.
Il brief gli dà una destinazione senza progettare l'implementazione per suo conto.
passo 2, approva il piano
Entra in modalità piano con /plan o Shift+Tab prima che modifichi qualcosa.
Se l'idea è poco specificata, installa la collezione di Matt Pocock con /plugin install mattpocock-skills, esegui /setup-matt-pocock-skills una volta e usa /grill-with-docs prima di trasformare il risultato in una specifica.
Leggi il piano. Taglia le funzionalità di cui non hai bisogno. Assicurati che ogni fase abbia una condizione di superamento osservabile. Poi approvalo.
passo 3, lascia lavorare la squadra
Fable assegna la prima fase isolata al lavoratore di implementazione. Il verificatore controlla il diff effettivo e l'output del test. Una fase dipendente inizia solo dopo che la precedente è stata superata.
Puoi lasciare il terminale. Usa /tasks quando vuoi vedere cosa è ancora in esecuzione.
passo 4, imposta il traguardo
Usa un obiettivo che nomini lo stato e la prova:
/goal la pagina viene eseguita localmente, il modulo memorizza un'iscrizione di test e il layout funziona a 390px, dimostrato dal vero output del test, dal record memorizzato e da uno screenshot corrente. Se un vero blocco rende questo impossibile, fermati e segnala le prove invece di dichiarare successo.
Quella condizione è molto più difficile da soddisfare con le sole parole.
passo 5, rivedi il risultato
Torna al diff, all'output del test, all'iscrizione memorizzata e agli screenshot.
Rivedi il prodotto come un utente, non come il manager del modello. Chiedi le modifiche che puoi effettivamente vedere, esegui un ultimo passaggio di verifica indipendente e distribuisci quando le prove corrispondono al brief.
La prima esecuzione sembrerà elaborata.
La seconda volta, noterai che la stessa sequenza funziona per quasi tutti i progetti che stavi rimandando.
i cinque flussi di lavoro in cui fa soldi veri
Ora punta la configurazione verso un lavoro abbastanza prezioso da giustificare il modello.
Questi sono i cinque flussi di lavoro in cui Fable 5.1 può creare una differenza misurabile.
Il lavoro sul codebase che nessuno vuole: la migrazione stimata in tre settimane, il raro guasto di produzione, il problema di prestazioni distribuito su otto servizi. Fable mappa il sistema, i lavoratori prendono fette isolate, il verificatore controlla ogni fase e i progressi sono legati ai test piuttosto che all'ottimismo.
Ricerca di livello decisionale: una domanda entra, i lavoratori di ricerca raccolgono da fonti primarie in parallelo, un revisore scettico attacca ogni affermazione importante e il leader trasforma ciò che sopravvive in un memo. Questo può alimentare un'acquisizione, un lancio, una decisione di mercato o una tesi di investimento.
Operazioni aziendali: dagli accesso agli strumenti giusti e lascia che riconcili i dati, indaghi le anomalie, prepari report, monitori un processo o lavori attraverso un arretrato operativo. Fable 5.1 ha quasi raddoppiato il punteggio di Fable 5 su AutomationBench di Anthropic, che è uno dei salti pratici più chiari del rilascio.
Lavoro sul prodotto guidato da riferimenti: dagli screenshot dell'esperienza che vuoi, le risorse effettive e l'accesso all'app in esecuzione. Può implementare rispetto al riferimento, aprire il risultato, confrontare i due e continuare finché il divario visibile non si chiude. Tu fornisci il gusto. Lui fornisce gli occhi, le mani e la pazienza.
Un sistema di conoscenza che si accumula: puntalo verso tutto ciò che vale la pena preservare nella tua azienda e lascia che trasformi documenti sparsi in una fonte di verità mantenuta e collegata. Un copywriter può costruirne uno da grandi pagine di vendita, un'agenzia dai suoi case study e un'azienda SaaS da chiamate con i clienti, decisioni, esperimenti e cronologia del supporto. Ogni futuro agente inizia più intelligente perché il contesto utile esiste già.
Ognuno di questi era un tempo un progetto da fare un giorno.
Fable 5.1 rende molti di loro progetti da fare questa settimana, a patto che tu dia al sistema un vero traguardo e un modo per dimostrare di averlo superato.
l'intera configurazione in un blocco
esegui Fable 5.1 come leader: pianifica, delega, rivede e decide
usa Opus o Sonnet per il lavoro delimitato, con un lavoratore per corsia indipendente
dagli risultato, vincoli, motivo e prova, poi lascia che scelga il percorso
mantieni CLAUDE.md corto e sposta le procedure occasionali nelle skills
usa gli obiettivi per il completamento verificabile e i loop per i controlli programmati
controlla i costi con livelli di effort, lavoratori più economici, contesto memorizzato nella cache e confini rigidi
punta il sistema verso codebase, ricerca, operazioni, lavoro sul prodotto e conoscenza che si accumula
Il modello è la parte più visibile della configurazione, ma non è l'intero vantaggio.
Il vantaggio è dare a un modello così capace una destinazione chiara, una squadra competente, accesso alla realtà e nessun modo per confondere una risposta convincente con un lavoro finito.
