Come utilizzare Claude Fable 5 senza andare in bancarotta

Fable 5 è il miglior modello AI che abbia mai usato.

È anche incredibilmente costoso.

Nelle mie prime ore di test, ho quasi bruciato l'intero limite di utilizzo.

E non stavo nemmeno facendo niente di folle.

Fable costa il doppio di Opus 4.8.

Ed essendo così intelligente, tende a pensarci troppo — esegue loop e brucia token in modi che nessun modello precedente di Claude ha mai fatto.

La maggior parte delle persone lo usa in modo completamente sbagliato.

Ecco il sistema esatto che ho costruito per ridurre i miei costi di token di Fable del 50%+.

Niente nuovi strumenti. Niente output ridotto. Solo routing più intelligente.

L'errore che tutti commettono il primo giorno

Apri Claude Code.

Fable è ora il modello predefinito.

Inizi a chattare.

Gli chiedi di correggere un typo. Gli chiedi di formattare del JSON. Gli chiedi di rinominare una variabile.

Fable pensa per 12 secondi, brucia 8.000 token di ragionamento, restituisce la risposta.

Costo: $0,60 per un compito che Haiku avrebbe risolto per $0,02.

Stai pagando tariffe da chirurgo per delle chiacchiere.

Fable è un architetto.

Non un coinquilino.

Nel momento in cui interiorizzi questo, tutto cambia.

Il Sistema 10-80-10 (Il framework esatto che usano gli ingegneri Anthropic stessi)

Ogni progetto con Fable ha tre fasi.

La maggior parte delle persone esegue tutte e tre su Fable.

La mossa intelligente è eseguirne solo due su Fable.

Il primo 10% — Pianificazione

Qui è dove Fable guadagna il suo prezzo.

Prima di iniziare qualsiasi progetto, usa Fable per definire:

→ La struttura e l'approccio → I criteri di successo → I vincoli e i casi limite → Cosa potrebbe andare storto

Pensa a costruire una casa.

L'errore più costoso è dare ai costruttori un progetto sbagliato.

Ottieni prima l'architettura giusta.

Fable è straordinario in questo.

L'80% centrale — Esecuzione

Qui è dove vengono bruciati la maggior parte dei token.

Il vai e vieni. L'iterazione. I loop di implementazione. Il lavoro pesante per completare effettivamente i compiti.

Fable non ha bisogno di essere qui.

Passa a Opus 4.8 per il lavoro standard. Usa Haiku per i compiti leggeri. Usa Codex o GPT-5.5 per l'esecuzione meccanica.

Ottieni un'architettura di qualità Fable senza pagare i prezzi di Fable per ogni token di esecuzione.

Il 10% finale — Revisione

Riporta Fable in gioco.

Fagli rivedere l'output rispetto al piano originale:

→ Il risultato corrisponde all'architettura?

→ Ci sono lacune o casi limite mancati?

→ C'è qualcosa da sistemare prima del rilascio?

Poiché Fable rivede un output finito invece di generarlo da zero, usa una frazione dei token che avrebbe bruciato facendo l'intero compito.

[INSERT IMAGE 2 — PROMPT BELOW]

La tabella di routing in CLAUDE.md (Un file che controlla tutto)

Questa è la svolta più grande.

Mantieni una singola tabella di routing nel tuo CLAUDE.md.

Lascia che Fable agisca come orchestratore che la legge e assegna automaticamente il lavoro al modello giusto.

Ecco la tabella di routing esatta che uso:

1## Tabella di Routing dei Modelli
2
3### Fable 5 (solo orchestratore)
4Usa per: pianificazione, architettura, revisione dell'output finale
5Non usare mai per: compiti meccanici, generazione in blocco, boilerplate
6Livello di sforzo: alto (mai xhigh — è un forno con output peggiori)
7
8### Opus 4.8 (esecutore di ragionamento profondo)
9Usa per: debug complesso, ragionamento multi-step, tutto ciò
10         che richiede pensiero reale ma non è architettura
11Livello di costo: standard
12
13### Sonnet 5 (esecutore di lavoro meccanico)
14Usa per: generazione di codice, refactoring, lavoro su funzionalità standard
15Livello di costo: economico
16
17### Codex / GPT-5.5 (esecutore peer)
18Usa per: compiti di implementazione, verifica UI/UX,
19         lavoro di esecuzione ben specificato
20Nota: Fable può imparare a guidare Codex — insegnagli come fare una volta
21Livello di costo: spesso gratuito con il piano Codex
22
23### Haiku (esecutore in blocco)
24Usa per: formattazione, lint, modifiche semplici, boilerplate,
25         refactoring di rinomina, scaffolding di test
26Non generare mai ulteriori sotto-agenti da Haiku
27Livello di costo: il più economico
28
29### Kimi / GLM-5.2 (esecutore a contesto lungo)
30Usa per: leggere file enormi, analisi del repository a lungo termine
31         così Fable non spende mai token per questo
32Livello di costo: molto economico
33
34### DeepSeek / Qwen (lavoro pesante a costo irrisorio)
35Usa per: boilerplate, scrittura di test, pulizia dei dati,
36         traduzioni, bozze di documentazione, generazione in blocco
37Livello di costo: quasi gratuito

Fable non tocca mai direttamente il lavoro economico.

Pianifica, delega al livello giusto, poi verifica i risultati rispetto al piano.

Il cervello costoso spende token solo per decidere.

Questo singolo file è il motivo per cui la mia fattura è DIMINUITA mentre il mio output è AUMENTATO.

La configurazione esatta di CLAUDE.md che mi ha risparmiato il 70% dei token

Ecco la sezione di orchestrazione completa che ho inserito nel mio CLAUDE.md:

1## Flusso di Lavoro di Orchestrazione
2
3Tu (Fable) sei l'orchestratore. Pianifica, scomponi, sintetizza.
4NON eseguire compiti meccanici da solo.
5
6### Regole di delega:
7- Fasi che richiedono ragionamento → deep-reasoner (Opus 4.8)
8- Lavoro meccanico → fast-worker (Sonnet/Haiku)
9- Analisi del codebase / file enormi → Kimi (contesto lungo)
10- Boilerplate / blocco → DeepSeek o Qwen
11- Revisione paritaria da una prospettiva diversa → Codex
12
13### Codex è un pari, non un revisore:
14Tratta Codex come un ingegnere senior fenomenale con una prospettiva
15diversa. Per decisioni ad alto rischio: assegna a Opus + Codex
16lo stesso problema in parallelo, sintetizza il meglio di
17entrambi senza mostrare all'uno la risposta dell'altro.
18
19### Disciplina del contesto:
20Mantieni il tuo contesto snello.
21Non rileggere mai file che hai già elaborato.
22Riassumi gli output degli strumenti prima di reinserirli nel contesto.
23Chiedi ai modelli di restituire conclusioni concise su cui puoi agire.
24
25### Livelli di sforzo:
26- Pianificazione e architettura: sforzo alto
27- Passaggi di revisione: sforzo medio
28- Non usare mai xhigh/max per impostazione predefinita — costa di più, spesso è peggio

Ora dai un prompt a Fable come fossi un tech lead:

1Obiettivo: [cosa vuoi]
2Contesto: [file, vincoli, di cosa hai paura]
3
4Sei il lead.
5Delega il ragionamento a deep-reasoner (Opus).
6Delega il lavoro pesante a fast-worker (Sonnet/Haiku).
7Usa Codex per problemi con una prospettiva nuova.
8
9Mostrami prima il tuo piano, poi esegui.

Tutto qui.

Fable pianifica. Tutto il resto esegue. La fattura rimane invariata.

Installare il plugin Codex — la mossa moltiplicatrice

Questa è la configurazione che la maggior parte delle persone salta.

Codex + Fable insieme è 10 volte meglio di Fable da solo.

Fable fa l'architettura. Codex esegue con qualità GPT-5.5. Tocchi a malapena i tuoi limiti di Claude.

Configurazione in meno di 5 minuti:

Passo 1: Installa Codex CLI sulla tua macchina

1npm install -g @openai/codex

Passo 2: Aggiungi il plugin all'interno di Claude Code

1/plugin marketplace add openai/codex-plugin-cc
2/plugin install codex@openai-codex
3/codex:setup

Passo 3: Crea due sotto-agenti in Claude Code

1/agents
2
3→ deep-reasoner
4  Modello: Opus 4.8
5  Istruzioni: "Usa per fasi che richiedono ragionamento, architettura,
6  debug di problemi complessi. Pensa a fondo, restituisci una conclusione
7  concisa su cui l'orchestratore possa agire."
8
9→ fast-worker
10  Modello: Sonnet 5
11  Istruzioni: "Usa per compiti meccanici, boilerplate, test,
12  formattazione, modifiche semplici. Esegui in modo efficiente."

Passo 4: Chiedi a Fable di scrivere un SKILL.md per Codex

1Scrivi un SKILL.md che insegni a Codex esattamente come:
2- Leggere ed eseguire piani di implementazione
3- Eseguire test e riportare i risultati a te
4- Gestire la struttura specifica dei file in questo progetto

Fai in modo che Codex non abbia bisogno di alcun supporto per il lavoro meccanico.

Fable scrive la skill una volta.

Codex la legge ad ogni esecuzione futura.

Il tuo output di Codex migliora immediatamente di 10 volte.

Il comando /loop (Il modo più potente per usare Fable in questo momento)

La maggior parte delle persone usa ancora il vecchio metodo del prompt.

Fai un prompt → Fable risponde → tu rivedi → fai un altro prompt → ripeti.

In quel modello, tu sei il loop.

Verifichi manualmente ogni passo, ogni correzione, ogni follow-up.

I loop ti rimuovono come collo di bottiglia.

Come funziona:

Dai a Fable un obiettivo in anticipo.

Lui avvia sotto-agenti per lavorare verso quell'obiettivo.

Gli agenti si danno prompt da soli e riferiscono quando hanno finito.

I due comandi:

1/goal — definisci il compito e lo stato finale
2
3Struttura:
4/goal [compito] fino a [stato finale misurabile] senza [vincoli]
5
6Esempio:
7/goal rifattorizzare il modulo auth fino a quando tutti i 47 test
8passano senza toccare il servizio di pagamento o lo schema del database

1/loop — esegui un prompt su una pianificazione automaticamente
2
3Struttura:
4/loop [il tuo prompt] --intervallo 30m --scadenza 8h
5
6Esempio:
7/loop esegui controllo di sicurezza su tutti gli endpoint API
8--intervallo 24h --scadenza 7g

La combinazione:

1/goal ricostruire il componente dashboard fino a quando il punteggio
2Lighthouse supera 90 su mobile senza rompere i test esistenti
3
4/loop esegui /goal sopra --intervallo 6h --scadenza 48h

Fable progetta il loop. I modelli più economici eseguono l'80% dell'esecuzione all'interno del loop. Fable rientra in gioco solo quando il loop si chiude o incontra un blocco.

Ti svegli con un compito finito.

[INSERT IMAGE 5 — PROMPT BELOW]

7 prompt da eseguire su Fable adesso

Queste sono le cose a più alta leva da fare con Fable prima di usarlo per qualsiasi altra cosa.

Non vibe coding.

Non rilasciare funzionalità.

Affilare ogni sistema che hai già.

1. Trova cosa vale davvero la pena eseguire su Fable

1Sei Fable 5, il modello più capace disponibile.
2
3Guarda i miei progetti, documenti e memoria.
4
5Elenca i 5 compiti principali che vale genuinamente la pena eseguire su di te.
6
7Classificali con una motivazione di una riga ciascuno.
8
9Non fare ancora il lavoro.

2. Riprogetta come costruisci prima di costruire qualsiasi cosa

1Voglio che tu controlli e riprogetti completamente il mio flusso di lavoro di codifica.
2
3Ecco come lavoro attualmente: [descrivi il tuo processo]
4
5Il mio obiettivo è: [cosa stai cercando di rilasciare]
6
7Rivedi, controlla, affila e migliora il mio sistema.
8
9Non scrivere codice. Riprogetta la fabbrica prima di metterla in funzione.

3. Pianifica il grande progetto — non costruirlo ancora

1Voglio pianificare: [descrivi il progetto]
2
3Non costruire ancora.
4
5Esponi il piano completo: fasi, decisioni chiave, rischi,
6e domande aperte.
7
8Segnala qualsiasi cosa potrebbe affondarlo.
9
10Rendi il piano abbastanza chiaro che Sonnet o Codex possano
11eseguirlo passo dopo passo senza farmi domande.

4. Trova tutto ciò che non va prima di rilasciare

1Sto per rilasciare questo progetto.
2
3Trova prima tutto ciò che non va.
4
5Leggi l'intero codebase.
6
7Cerca bug reali, casi limite rotti e qualsiasi cosa
8si romperà davanti a un utente.
9
10Elenca ogni problema con: come riprodurlo e la soluzione.
11
12Mantieni uno standard alto. Sii spietato.

5. Ricostruisci il tuo CLAUDE.md da zero

1Leggi il mio CLAUDE.md attuale.
2
3È stato scritto per modelli più vecchi ed è gonfio.
4
5Istruzioni più brevi e pulite funzionano meglio e costano meno
6su Fable.
7
8Riscrivilo:
9- Rimuovi le istruzioni di cui Fable non ha più bisogno
10- Stringi ogni flusso di lavoro
11- Aggiungi la tabella di routing dei modelli dalla nostra conversazione
12- Mantieni ogni sezione sotto le 5 righe dove possibile
13
14Fable capirà il resto da solo.

6. Ottieni consigli di business da tutto ciò che sa su di te

1Sei il mio consulente aziendale.
2
3Leggi il mio documento di piano, gli strumenti collegati e la memoria.
4
5Scrivi una valutazione di una pagina della mia attività e:
6- Le 3 cose principali su cui concentrarmi per i prossimi 3 mesi
7- Cosa abbandonare e perché
8- Una cosa a cui probabilmente sono cieco

7. Spazzata di sicurezza in automatico

1/loop esegui un controllo di sicurezza su tutti i miei endpoint API.
2
3Cerca: chiavi esposte, autenticazione mancante, lacune nei limiti di richiesta,
4vettori di injection e qualsiasi cosa un utente malintenzionato potrebbe sfruttare.
5
6Segnala solo problemi reali con valutazioni di gravità.
7
8--intervallo 24h --scadenza 7g

Livelli di sforzo — l'impostazione più fraintesa

La maggior parte delle persone usa max o xhigh come predefinito.

Questo è sbagliato.

Ecco cosa succede realmente a ogni livello:

→ Basso: Veloce, economico, sorprendentemente capace per compiti semplici. Molte persone riportano output fantastici qui.

→ Medio: Il punto di equilibrio. Fable su medio batte Opus su extra alto. Imposta questo come predefinito.

→ Alto: Usa per: debug difficile, refactoring multi-file, decisioni di architettura. Potere di ragionamento reale.

→ xhigh / max: Forno di token. Spesso produce output PEGGIORI di Alto. Riservalo ai problemi genuinamente più difficili che tu abbia mai affrontato.

La regola: inizia con Medio. Passa ad Alto solo se la qualità è effettivamente insufficiente. Non impostare mai max come predefinito.

Un'altra impostazione che uccide i budget:

Pensiero Esteso — lascialo spento per impostazione predefinita.

Attivalo solo per problemi che lo richiedono genuinamente. Lasciarlo acceso permanentemente è come tenere il motore acceso nel vialetto di casa.

Il trucco /handoff — risolvi il gonfiore della finestra di contesto

Le sessioni lunghe sono un killer silenzioso.

Ogni turno reinvia l'intera cronologia della conversazione.

Una sessione da 200k token diventa la cosa più costosa sulla tua fattura.

La soluzione: apri nuove chat frequentemente.

Ma non vuoi perdere il contesto quando lo fai.

Usa la skill /handoff:

1Dammi un prompt che posso usare per riavviare questa sessione in
2una nuova chat senza perdere nessuno del nostro contesto.
3
4Includi:
5- Cosa abbiamo deciso
6- Cosa abbiamo costruito
7- Quali sono i prossimi passi
8- Qualsiasi vincolo importante che devo ricordare
9
10Mantienilo sotto i 500 token in modo che la nuova sessione inizi snella.

Copia quell'output.

Apri una nuova chat.

Incollalo.

Continua esattamente da dove avevi lasciato a una frazione del costo del contesto.

Sessione fresca ogni 30–60 minuti = risparmio massiccio di token.

I 4 errori costosi da evitare

Errore 1: Fable è ora il predefinito.

Quando apri Claude Code, usa automaticamente Fable.

Controlla il selettore del modello prima di ogni sessione.

Questa singola abitudine mi ha beccato accidentalmente a eseguire Fable su chat normali più volte di quanto voglia ammettere.

Errore 2: Nessun limite di spesa.

Il 7 luglio, Fable esce dagli abbonamenti standard.

Aggiungi una carta di credito e imposta immediatamente un limite mensile rigido.

Impostazioni → Utilizzo → Regola Limite.

Fable brucia token velocemente in esecuzioni autonome e sessioni lunghe.

Senza un limite rigido, un'esecuzione notturna di un agente può accumulare una fattura prima che ti svegli.

Qualcuno è già stato fatturato $960 per un singolo prompt.

Imposta il limite stasera.

Errore 3: Chiedergli di spiegare il suo ragionamento.

Quella singola richiesta può far scattare i classificatori e il tuo lavoro viene silenziosamente gestito da un modello più debole mentre pensi di essere ancora su Fable.

Salta le richieste "perché". Giudica la qualità dell'output, non il processo.

Errore 4: Dargli piccoli prompt uno alla volta.

Fable tiene ore di contesto nella sua testa.

Dagli l'intera cosa disordinata in una volta sola.

Contesto completo. I vincoli. Di cosa hai effettivamente paura.

Ho dato a Fable un refactoring che rimandavo da settimane in un unico brief. È tornato fatto.

Dargli prompt uno alla volta spreca l'unica cosa in cui è più bravo.

Il confronto dei costi dei modelli — sapere cosa stai effettivamente pagando

Prima di instradare qualsiasi cosa, conosci il prezzo di ogni modello:

Modello Input ($/M) Output ($/M) Ideale per

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Fable 5 ~$15 ~$75 Pianificazione, revisione

Opus 4.8 ~$5 ~$25 Ragionamento profondo

Sonnet 5 ~$3 ~$15 Esecuzione standard

Kimi K2.7 ~$0,95 ~$4,00 Codifica in blocco, contesto lungo

GLM-5.2 ~$1,40 ~$4,40 Lavoro a livello di repository

DeepSeek v4 ~$0,28 ~$1,10 Lavoro pesante a costo irrisorio

Haiku 4.5 ~$1 ~$5 Pulizia, formattazione

Locale (Qwen/Llama) $0 $0 Completamento automatico, boilerplate

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Il divario tra Fable e DeepSeek: 53x in input. 68x in output.

Lo stesso agente di refactoring in 30 passi: → Tutto su Fable: ~$25 per esecuzione → Piano Fable + esecuzione Kimi: ~$1,40 per esecuzione → Stesso codice rilasciato. Stessi test superati.

Il routing non significa essere a buon mercato.

Significa essere precisi.

Il sistema completo — come appare in esecuzione

Prima di questo sistema:

→ Tutto viene instradato a Fable

→ La fattura aumenta ogni volta che rilasci

→ I limiti di utilizzo vengono raggiunti a metà sessione

→ Razioni i prompt come un viaggiatore con budget limitato

Dopo questo sistema:

→ Fable gestisce il 10% che ne ha effettivamente bisogno

→ I modelli economici gestiscono l'80% dell'esecuzione

→ /loop viene eseguito durante la notte senza toccare il tuo limite

→ Rilasci di più, spendi meno, non raggiungi mai un limite di velocità

Il riassunto in tre righe:

Fable pianifica. Altri eseguono. Fable rivede.

Questa singola regola riduce la tua fattura del 50%+ prima di cambiare qualsiasi altra cosa.

Il resto è ottimizzazione.

Esegui questo stasera

Incolla questo in Fable adesso:

Leggi il mio CLAUDE.md attuale e tutti i miei progetti attivi.

Il tuo compito: impostare il sistema di routing 10-80-10 per il mio flusso di lavoro.

Crea:

1. CLAUDE.md aggiornato con la tabella di routing completa dei modelli
2. Un elenco dei miei compiti attuali classificati in base a quale modello dovrebbe gestire ciascuno
3. Tre prompt /goal che posso eseguire stasera su modelli più economici in base a ciò che vedi nei miei progetti

Non eseguire nulla. Solo pianifica e instrada.

Fable fa la pianificazione.

Ti svegli con un sistema di routing completo.

E una fattura che non ti provoca un infarto.

Se questo ti ha fatto risparmiare denaro:

→ Ripubblica così altri sviluppatori smettono di bruciare i loro budget

→ Segui @sairahul1 per altri sistemi come questo

→ Aggiungi ai segnalibri — le configurazioni CLAUDE.md funzionano, incollale stasera

Iscriviti a theaibuilders.co per altri articoli interessanti come questo

Scrivo di AI, creazione di prodotti e sistemi che funzionano mentre dormi.

Risorse:

→ Instradatore di token Entelligence: entelligence.ai/blogs/entelligence-token-router

→ Flusso di lavoro a tre modelli che ha tagliato le fatture dell'80%: entelligence.ai/blogs/our-three-model-coding-workflow-that-cut-our-ai-bill-80

→ Claude Code: claude.ai/code

→ Codex CLI: npmjs.com/package/@openai/codex