Come costruire un sistema operativo agentico con Fable 5 (Guida per sviluppatori)

Ecco la traduzione in italiano del testo fornito, seguendo scrupolosamente tutte le linee guida specificate.

Questa è una guida A–Z completa su Claude Fable 5: cos'è e come usarlo come un ingegnere 100x

Questo cambierà tutto il tuo modo di lavorare con Claude

Segna questi 8 build prima di dimenticarli

Introduzione

Hai a disposizione il modello più potente mai reso disponibile al pubblico, e stai ancora scrivendo prompt uno alla volta. Questa guida risolve il problema.

Ecco la situazione a luglio 2026. Fable 5 può funzionare per ore senza supervisione, inviare i propri sub-agenti e completare una settimana di lavoro in una notte. È anche a consumo ($10/M in ingresso, $50/M in uscita tramite crediti d'uso), tende a strafare quando l'ambito non è delimitato, e difende i propri errori in modo più convincente di quanto la maggior parte delle persone difenda le proprie risposte corrette.

Usato in modo casuale, è un modo costoso per generare cose sbagliate impressionanti. Usato all'interno di un sistema, è la cosa più vicina a un impiegato che puoi noleggiare per tre dollari al giorno.

Questa guida costruisce quel sistema. Non una filosofia: i file veri e propri, in ordine, con un checkpoint dopo ognuno in modo da sapere che funziona prima di aggiungere il pezzo successivo.

Cosa avrai alla fine:

• Un CLAUDE.md con cui il modello non può negoziare (BUILD 1)
• Un ciclo giornaliero in cui Fable 5 prende ogni decisione ma scrive pochissimi token, i modelli economici fanno il lavoro, un verificatore indipendente lo valuta, e uno script bash ha il voto finale (BUILD 2-3)
• Un registro di fiducia che concede e revoca l'autonomia per competenza, automaticamente, in base ai tassi di superamento misurati (BUILD 4)
• Una directory degli obiettivi in cui tutto ciò che hai mai completato viene continuamente riverificato ogni giorno, per sempre, in modo che nulla marcisca in silenzio (BUILD 5)
• Un budget che si auto-applica invece di sorprenderti (BUILD 6)
• Quattro cicli opzionali (quorum, cricchetto, sparring, compost) ognuno con la condizione che ti dice quando installarlo (BUILD 7)
• Una pianificazione cron, un runbook per ogni allarme che il sistema può sollevare, e un programma di fiducia di 30 giorni che lo porta da supervisionato ad auto-estendente.

A chi è rivolto. A chiunque abbia un repository, un terminale e un abbonamento a Claude Code o una chiave API. Gli esempi sono orientati al codice perché i cicli sono nati intorno ai codebase, ma il sistema di obiettivi e metà dei cicli funzionano altrettanto bene su fatture, report e liste di lettura; i predicati sono solo comandi shell.

Come leggerlo. In ordine, eseguendo i controlli. BUILD 0 sono le impostazioni ufficiali di Anthropic e il linguaggio dei prompt; tutto il resto è il sistema costruito sopra. Ogni build richiede dai 10 ai 20 minuti. I 30 giorni alla fine non sono tempo di lettura; sono il programma di fiducia graduale durante il quale il sistema guadagna il diritto di funzionare senza di te. Tempo pratico totale: circa 2 ore.

I tre principi alla base di tutto, così puoi prevedere qualsiasi decisione di progettazione prima di leggerla:

1. Leggi, non consigli. Ogni regola ha un numero, un "mai" o un comando che la verifica. Qualunque cosa di più morbido viene ottimizzato per essere ignorato.
2. Niente valuta il proprio lavoro. Il pianificatore, l'esecutore, il verificatore e il gate sono quattro parti diverse, e l'ultima è deterministica.
3. Niente che è stato superato una volta viene lasciato incustodito. Il lavoro completato viene promosso a invariante riverificata. Un obiettivo che verifichi una sola volta è un'ipotesi con un timestamp.

Niente saggi da qui in poi. Otto build, ognuna con file, comandi e un checkpoint.

Prerequisiti

1CLI claude (Claude Code) con accesso a Fable 5     # crediti d'uso abilitati, limite /usage-credits impostato
2CLI llm + chiave OpenRouter                          # llm install llm-openrouter
3jq, gh, git, make, cron
4un repository con un comando di test

Cosa stai costruendo

1tuo-repo/
2  CLAUDE.md                    # BUILD 1: la costituzione
3  loop/
4    loop.sh                    # BUILD 3: il battito cardiaco
5    conductor.md               # BUILD 3: prompt di instradamento
6    triage.md                  # BUILD 3: prompt lettore economico
7    contract.md                # BUILD 2: le tre liste
8    workers/implement.md       # BUILD 3
9    workers/verify.md          # BUILD 3
10    guardrails/verify.sh       # BUILD 2: gate deterministico
11    scripts/trust-log.sh       # BUILD 4
12    scripts/log-cost.sh        # BUILD 6
13    scripts/cost-check.sh      # BUILD 6
14    quorum.sh                  # BUILD 7 (opzionale)
15    verify-goals.sh            # BUILD 5
16    goals/                     # BUILD 5: obiettivi permanenti
17    skills/                    # BUILD 4: un file per impiegato
18    memory/
19      STATE.md  trust.tsv  goal-ledger.tsv  dispatch.tsv  usage.log
20  Makefile                     # BUILD 8: tick / queue / trust / audit / dream

BUILD 0: Configura il Motore (dalla documentazione ufficiale di Fable 5)

Tutto in questo build proviene dalla documentazione ufficiale di Anthropic. Imposta queste cose prima di scrivere qualsiasi file tuo.

La scheda tecnica:

Impostazione

Valore

Fonte

Stringa modello

claude-fable-5

panoramica modelli

Contesto / output

1 milione di token / fino a 128k di output per richiesta

documenti introduttivi

Prezzo

$10/M in ingresso, $50/M in uscita

documenti introduttivi

Pensiero

adattivo, sempre attivo;

thinking: {type:"disabled"}

è RIFIUTATO; l'output del pensiero è solo riassunto

documenti introduttivi + sforzo

Sforzo

basso

medio

alto

molto alto

massimo

;

alto

= predefinito = omettere il parametro

documenti sforzo

Forma API

output_config: {"effort": "..."}

sull'API Messages

documenti sforzo

Cinque fatti ufficiali che cambiano il modo in cui costruisci:

1. max_tokens è un limite massimo per il pensiero PIÙ il testo della risposta. A sforzo alto e molto alto, impostalo grande (inizia con 64k) altrimenti Fable esaurisce lo spazio a metà del pensiero. Si applica a ogni chiamata claude -p in questa guida.
2. Molto alto è ufficialmente per "compiti agentici di lunga durata (oltre 30 minuti) con budget di token nell'ordine dei milioni." Questo è il posto del conduttore e nient'altro in questo sistema. I documenti dicono anche che uno sforzo inferiore su Fable 5 "spesso supera le prestazioni molto alte sui modelli precedenti", quindi resisti all'idea di aggiornare i lavoratori.
3. I rifiuti sono HTTP 200. Fable 5 esegue classificatori di sicurezza (cyber offensivo, biologia/scienze della vita, estrazione del ragionamento). Una richiesta rifiutata restituisce stop_reason: "refusal" come risposta di SUCCESSO. I tuoi script devono controllare il motivo di arresto, non il codice di uscita. Rimedio ufficiale: configura fallback lato server o middleware SDK per reindirizzare a Opus 4.8.
4. Non chiedere mai a Fable di ripetere il suo ragionamento. Prompt o competenze che dicono "mostra il tuo pensiero" o "spiega il tuo ragionamento nella risposta" attivano la categoria di rifiuto reasoning_extraction e attivano i fallback. Controlla ogni vecchia competenza per questo durante la migrazione. Leggi invece i blocchi di pensiero strutturati.
5. I turni sono lunghi per progettazione. I compiti difficili richiedono molti minuti per richiesta a sforzo più elevato; le esecuzioni autonome si estendono per ore. Regola i timeout del client e controlla le esecuzioni in modo asincrono (lavori pianificati, non attese bloccanti). Questo è il motivo per cui il battito cardiaco è cron, non un ciclo bloccante.

Il pacchetto di prompt ufficiale. Anthropic fornisce linguaggi di prompt testati per i comportamenti noti di Fable 5. Questi vanno nei tuoi prompt testualmente; non parafrasarli in modo più snello:

1. Anti-pianificazione eccessiva (per il conduttore e qualsiasi sessione interattiva):

1Quando hai informazioni sufficienti per agire, agisci. Non re-derivare fatti già
2stabiliti nella conversazione, non rimettere in discussione una decisione che l'utente ha già
3preso, o narrare opzioni che non perseguirai. Se stai valutando una scelta,
4fornisci una raccomandazione, non un'indagine esaustiva.

1. Anti-doratura (per ogni prompt del lavoratore; questa è la recinzione ufficiale contro lo strafare):

1Non aggiungere funzionalità, refactoring o introdurre astrazioni oltre quanto il compito
2richiede. Una correzione di bug non necessita di pulizie circostanti. Non progettare per
3requisiti futuri ipotetici: fai la cosa più semplice che funziona bene.
4Non aggiungere gestione degli errori o validazione per scenari che non possono verificarsi.
5Convalida solo ai confini del sistema.

1. Rivendicazioni di progresso fondate (per qualsiasi esecuzione lunga; nei test di Anthropic questo ha quasi eliminato i rapporti di stato inventati):

1Prima di riportare i progressi, verifica ogni affermazione rispetto a un risultato dello strumento di questa
2sessione. Riporta solo il lavoro per cui puoi indicare le prove; se qualcosa non è
3ancora verificato, dillo esplicitamente. Se i test falliscono, dillo con l'output; se un
4passaggio è stato saltato, dillo.

1. Promemoria per pipeline autonoma (per ogni prompt guidato da cron; elimina l'arresto anticipato del tipo "Ora eseguirò X"):

1Stai operando in modo autonomo. L'utente non sta guardando e non può rispondere a domande
2a metà compito. Per azioni reversibili che seguono dalla richiesta originale,
3procedi senza chiedere. Prima di terminare il tuo turno, controlla il tuo ultimo
4paragrafo: se è un piano, una domanda o una promessa su un lavoro che non hai
5fatto, esegui quel lavoro ora con chiamate agli strumenti. Termina solo quando il compito è completo
6o sei bloccato su input che solo l'utente può fornire.

1. Formato di memoria ufficiale (per il sognatore e memory/learnings/):

1Memorizza una lezione per file con un riepilogo di una riga all'inizio. Registra
2correzioni e approcci confermati allo stesso modo, incluso il motivo per cui erano importanti.
3Non salvare ciò che il repository già registra; aggiorna le note esistenti piuttosto che
4duplicare; elimina le note che si rivelano errate.

1. Istruzione ufficiale per il verificatore (i documenti lo affermano direttamente: "i sub-agenti verificatori separati con contesto fresco tendono a superare l'autocritica"):

1Stabilisci un metodo per controllare il tuo lavoro a un intervallo di [X] mentre
2costruisci. Esegui questo ogni [intervallo X], verificando il tuo lavoro con sub-agenti
3rispetto alle specifiche.

Due ordini di impalcatura dai documenti che vale la pena seguire: inizia dalla parte alta della tua gamma di difficoltà (testare Fable solo su carichi di lavoro semplici lo sottovaluta; dagli il problema irrisolto più difficile e lascia che lo definisca), e rifattorizza le vecchie competenze (le istruzioni scritte per i modelli precedenti sono spesso troppo prescrittive per Fable 5 e DEGRADANO l'output; se la performance predefinita è migliore senza un'istruzione, elimina l'istruzione).

CHECK 0: Ogni chiamata claude -p nei tuoi script ha un max_tokens esplicito e grande dove supportato; i tuoi script controllano stop_reason: "refusal"; nessun prompt o competenza in alcun luogo dice "mostra il tuo pensiero".

BUILD 1: La Costituzione (CLAUDE.md)

Perché, in una riga: Fable segue le leggi e ottimizza intorno ai consigli, quindi ogni riga ha bisogno di un numero, un "mai" o un comando che la verifichi.

Regole per il file: quattro blocchi, sotto le 150 righe, niente "pensa passo dopo passo" (il ragionamento è sempre attivo; quelli sono token pagati), niente personaggi agente predefiniti (Fable progetta team migliori di quanto tu possa predefinire), per lo più segnali di stop.

Crea CLAUDE.md:

1# CLAUDE.md
2
3## MAI (leggi; le eccezioni richiedono di chiedere prima)
4- Mai superare 200 righe modificate in un commit senza chiedere.
5- Mai toccare src/auth/, src/billing/, migrations/ o config di produzione senza supervisione.
6- Mai riportare il lavoro come completato in base alla propria valutazione. Fatto = il controllo è passato.
7- Mai inventare un segreto, un endpoint o una convenzione. Fermati e chiedi.
8- Mai aggiungere una dipendenza. Proponila in STATE.md e fermati.
9- Mai superare lo sforzo alto all'interno di qualsiasi ciclo. Molto alto è solo per revisioni singole.
10- Mai modificare o eliminare un test per farlo passare. Quello è un fallimento, sempre.
11- Mai ripetere, trascrivere o spiegare il tuo ragionamento interno nel testo della risposta.
12  (Ufficiale: attiva i rifiuti reasoning_extraction su Fable 5.)
13- Quando una condizione /goal viene soddisfatta, scrivi goals/<nome>.md con la condizione come
14  suo predicato prima di riportare il successo.
15
16## DISPACCIO (instrada ogni compito; la prima corrispondenza vince; registra in memory/dispatch.tsv)
17| modello          | marginale | appetito | intelligenza | gusto |
18|-----------------|-----------|----------|--------------|-------|
19| claude-fable-5  | 2 (crediti) | 3      | 10           | 10    |
20| claude-opus-4-8 | 7 (sub)   | 6        | 8            | 9     |
21| claude-sonnet-5 | 9 (sub)   | 8        | 7            | 7     |
22| codex (2° sub)  | 9         | 10       | 9            | 5     |
231. Decisione (pianificare/rivedere/instradare/stallo) -> fable-5, sforzo alto, sola lettura.
242. Letture >50k token (log/PDF/screenshot) -> codex. Mai fable.
253. Spedizioni agli utenti (UI/API/copia) -> gusto >= 8 ottiene il passaggio finale.
264. Specifica completa -> sonnet-5, sforzo medio.
275. Altrimenti sonnet-5; scala di un gradino in caso di errore senza chiedere.
28
29## PAROLE
30- "intelligenza" = problema più difficile gestito senza supervisione
31- "gusto" = UI/UX, qualità del codice, design API, copia
32- "fatto" = il predicato passa; nient'altro
33- "piccolo" = sotto 50 righe modificate; "veloce" = sotto 10 minuti del tuo tempo
34- "pulizia" = comportamento identico, verify.sh verde prima e dopo
35
36## FATTO
37- Ogni compito ha un done_when verificabile dalla macchina prima che il lavoro inizi.
38- Un agente con contesto fresco che non ha visto né il piano né la bozza verifica rispetto ad esso.
39- guardrails/verify.sh ha il voto finale.
40- Deviazioni: opzione conservativa, registra in IMPLEMENTATION.md, continua.
41- Creatore e verificatore discordano due volte -> fermati, metti in coda per un umano.

Modifica i numeri e i percorsi con i tuoi. Il materiale specifico del flusso di lavoro (procedura PR, checklist di rilascio) va in skills/, non qui.

CHECK 1: Per ogni riga chiediti: il modello potrebbe rispettare l'80% e dichiarare successo? Se sì, riscrivila con un numero o un "mai". wc -l CLAUDE.md sotto 150

BUILD 2: Muri e Cancello

Perché: il raggio di esplosione deve essere dichiarato prima del primo tick, e uno script bash deve avere il voto finale.

Crea loop/contract.md:

1## agisce da solo
2bozze PR su rami; correggi debito lint/test; aggiorna STATE.md; etichetta issue
3
4## mette in coda per me
5auth, pagamenti, migrazioni; qualsiasi competenza sotto il livello "auto"; qualsiasi diff > 400 righe
6
7## mi sveglia
8la verifica fallisce due volte sullo stesso elemento
9il router di salvaguardia ha scambiato i modelli a metà esecuzione
10il budget giornaliero è stato superato
11qualcosa richiede un segreto
12un obiettivo permanente è VIOLATO

Crea loop/guardrails/verify.sh (modifica per il tuo stack):

1#!/usr/bin/env bash
2set -e
3npm run typecheck --if-present
4npm test --if-present
5npm run lint --if-present

CHECK 2: ./loop/guardrails/verify.sh viene eseguito ed esce con 0 sul tuo repository corrente. Se fallisce ora, risolvi prima quello; l'intero sistema si basa su questo script.

BUILD 3: Il Battito Cardiaco

Perché, in tre righe: Fable come lavoratore è una fattura a quattro cifre (sessioni da 500k-1M token a $50/M in uscita); Fable come conduttore emette il 10-20% dei token mentre prende il 100% delle decisioni. Un modello da $0.01 legge i tick silenziosi. Gli agenti si passano il testimone attraverso uno schema JSON in modo che qualsiasi modello si adatti a qualsiasi posto.

Crea loop/triage.md:

1Ricevi commit recenti, issue aperte ed esecuzioni CI. Emetti SOLO risultati:
2- risultato: <una riga>
3  evidenza: <id commit/issue/esecuzione>
4  stato: actionable | informativo
5Nessuna correzione, nessuna opinione. Niente da segnalare = emetti esattamente "stato: quiet".
6Qualsiasi cosa tocchi auth, pagamenti, migrazioni, segreti = sempre actionable,
7annotato "contract-sensitive".

Crea loop/conductor.md:

1Sei il conduttore. Non scrivi codice. Non modifichi file.
21. Leggi STATE, REGISTRO FIDUCIA, CONTRATTO qui sotto. Non fidarti della memoria di essi.
32. Scegli l'UNICO elemento actionable di maggior valore.
4   contract-sensitive, ambiguo o probabile diff >400 righe -> azione: queue
5   niente che valga la pena fare -> azione: stop
63. Altrimenti azione: execute, con una specifica che un modello mediocre possa seguire.
7Emetti SOLO questo JSON:
8{ "action": "execute|queue|stop", "item": "...", "skill": "<kebab-case,
9stabile tra le esecuzioni>", "spec": "...", "done_when": ["<verificabile>", ...] }
10Sei costoso. Sii breve. Il tuo output è una decisione, non un saggio.

Crea loop/workers/implement.md:

1Ricevi un ordine di lavoro (JSON). Esegui la specifica esattamente.
2Fai il PROSSIMO passo verso done_when. I diff piccoli vincono.
3Credenziale mancante o decisione non documentata -> FERMATI, scrivi la domanda in
4IMPLEMENTATION.md. Non inventare mai segreti o convenzioni.
5Registra cosa hai fatto e perché in IMPLEMENTATION.md (massimo 3 righe).

Crea loop/workers/verify.md:

1Ricevi una SPECIFICA e un DIFF, nient'altro. Giudica solo ciò che hai di fronte.
21. Il diff soddisfa ogni done_when? Cita le righe.
32. Qualcosa al di fuori dell'ambito della specifica? Fallimento istantaneo. Test eliminati/saltati? Fallimento istantaneo.
4Emetti esattamente una riga: "PASS: <motivo>" o "FAIL: <motivo>".
5Il creatore era fiducioso. Quella non è una prova.

Crea loop/loop.sh:

1#!/usr/bin/env bash
2set -euo pipefail
3cd "$(dirname "$0")"
4MAX_ITERS="${MAX_ITERS:-10}"
5DAILY_BUDGET_USD="${DAILY_BUDGET_USD:-5}"
6CHEAP="${CHEAP:-openrouter/deepseek/deepseek-v4-flash}"
7WORKER="${WORKER:-openrouter/moonshotai/kimi-k2.6}"
8
9./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
10
11for ((i=1; i<=MAX_ITERS; i++)); do
12  # 1 TRIAGE: gate tick silenzioso, ~$0.01
13  { git log --oneline -20; gh issue list --limit 20 2>/dev/null || true; \
14    gh run list --limit 10 2>/dev/null || true; } \
15    | llm -m "$CHEAP" -s "$(cat triage.md)" >> memory/STATE.md
16  ./scripts/log-cost.sh triage 0.01
17  grep -q "stato: actionable" memory/STATE.md || { echo quiet; exit 0; }
18
19  # 2 CONDUTTORE: Fable, molto alto, contesto fresco, sola lettura, JSON in uscita
20  claude -p "$(cat conductor.md)
21STATE: $(cat memory/STATE.md)
22FIDUCIA: $(./scripts/trust-log.sh --render)
23CONTRATTO: $(cat contract.md)" \
24    --model claude-fable-5 --effort xhigh --allowedTools "Read" \
25    --output-format json > /tmp/c.json
26  ./scripts/log-cost.sh conductor 0.35
27
28  # 2a TOLLERANZA INSTARDAMENTO: non iterare mai su un modello che non hai scelto
29  SERVED=$(jq -r '.modelUsage | keys[0] // "claude-fable-5"' /tmp/c.json)
30  [[ "$SERVED" != *fable* ]] && { echo "reindirizzato" >> memory/STATE.md; exit 2; }
31
32  jq -r '.result' /tmp/c.json > work-order.json
33  SKILL=$(jq -r .skill work-order.json); ACTION=$(jq -r .action work-order.json)
34  [[ "$ACTION" == stop  ]] && exit 0
35  [[ "$ACTION" == queue ]] && { echo "in coda: $SKILL" >> memory/STATE.md; continue; }
36
37  # 3 ESEGUI: lavoratore economico, worktree isolato
38  WT="../wt-$i"; git worktree add "$WT" -b "loop/$SKILL-$i" >/dev/null
39  ( cd "$WT" && llm -m "$WORKER" -s "$(cat "$OLDPWD/workers/implement.md")" \
40      "$(cat "$OLDPWD/work-order.json")" > IMPLEMENTATION.md )
41  ./scripts/log-cost.sh worker 0.10
42
43  # 4 VERIFICA: Fable fresco, nessuno strumento, vede solo specifica + diff
44  V=$(claude -p "$(cat workers/verify.md)
45SPECIFICA: $(jq -r .spec work-order.json)
46DIFF: $(cd "$WT" && git diff)" \
47    --model claude-fable-5 --effort high --allowedTools "" \
48    --output-format json | jq -r .result)
49  ./scripts/log-cost.sh verifier 0.40
50
51  # 5 GATE: deterministico; poi registro; spedisci solo a livello auto
52  if [[ "$V" == PASS* ]] && ( cd "$WT" && "$OLDPWD/guardrails/verify.sh" ); then
53    ./scripts/trust-log.sh "$SKILL" pass
54    if [[ "$(./scripts/trust-log.sh --tier "$SKILL")" == auto ]]; then
55      ( cd "$WT" && git add -A && git commit -qm "loop: $SKILL" && gh pr create --fill || true )
56      echo "- spedito: $SKILL" >> memory/STATE.md
57    else
58      echo "- revisione: $SKILL in $WT" >> memory/STATE.md
59    fi
60  else
61    ./scripts/trust-log.sh "$SKILL" fail
62    echo "- FALLITO: $SKILL in $WT" >> memory/STATE.md
63  fi
64  ./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
65done
66exit 1   # limite di iterazione senza stop: controlla STATE.md

Mappa di uscita: 0 silenzioso/completato, 1 limite, 2 reindirizzamento, 3 budget. Tutti etichettati, di proposito.

CHECK 3: chmod +x loop.sh guardrails/verify.sh poi esegui ./loop.sh una volta manualmente. Conferma: un repository silenzioso esce con 0 per circa un centesimo; un repository con elementi actionable produce work-order.json con tutti e cinque i campi e una riga di verdetto in STATE.md.

BUILD 4: Il Registro di Fiducia

Perché: "aumenta l'autonomia man mano che la fiducia cresce" non è un meccanismo; un TSV con regole di livello lo è. L'autonomia è per competenza, non per ciclo.

Crea loop/scripts/trust-log.sh:

1#!/usr/bin/env bash
2# uso: trust-log.sh <competenza> <pass|fail> | --render | --tier <competenza>
3set -euo pipefail
4F="$(dirname "$0")/../memory/trust.tsv"; touch "$F"
5tier_of() { awk -v r="$1" -v p="$2" 'BEGIN{
6  rate=(r>0)?p/r:0
7  if (r>=20 && rate>=0.95) print "auto"
8  else if (r<10 || rate<0.90) print "watch"
9  else print "queue"}'; }
10case "${1:-}" in
11  --render)
12    printf "%-20s %5s %5s %6s %s\n" competenza esecuzioni superamenti tasso livello
13    while IFS=$'\t' read -r s r p; do [ -z "$s" ] && continue
14      printf "%-20s %5s %5s %5s%% %s\n" "$s" "$r" "$p" \
15        "$(awk -v r="$r" -v p="$p" 'BEGIN{printf "%.0f",(r>0)?p/r*100:0}')" \
16        "$(tier_of "$r" "$p")"; done < "$F";;
17  --tier)
18    line=$(grep -P "^${2}\t" "$F" || echo -e "${2}\t0\t0")
19    tier_of "$(cut -f2 <<<"$line")" "$(cut -f3 <<<"$line")";;
20  *)
21    awk -v s="$1" -v r="$2" -F'\t' 'BEGIN{OFS="\t"; f=0}
22      $1==s {f=1; print s,$2+1,$3+(r=="pass"); next} {print}
23      END{if(!f) print s,1,(r=="pass")?1:0}' "$F" > "$F.t" && mv "$F.t" "$F"
24    if [ "$2" = fail ]; then
25      esecuzioni=$(grep -P "^${1}\t" "$F" | cut -f2)
26      [ "$("$0" --tier "$1")" = watch ] && [ "$esecuzioni" -ge 10 ] \
27        && echo "ALLARME: $1 declassato a watch dopo $esecuzioni esecuzioni" >&2 || true
28    fi;;
29esac

• Regole di livello: auto = 20+ esecuzioni E 95%+ di superamento, spedisce senza supervisione. queue = bozze verificate aspettano te. watch = sotto 10 esecuzioni o sotto 90%, solo bozza. La retrocessione è automatica e stampa su stderr, che cron ti invia per email.
• Popola il roster: crea loop/skills/<nome>/SKILL.md per ogni attività ricorrente (fix-lint-debt, fix-flaky-test, bump-deps, triage-issues sono le quattro standard). Ogni file: frontespizio (nome, descrizione, quando), passaggi, un elenco "mai", un done-when verificabile. Ogni competenza inizia a watch.

CHECK 4: Esegui ./scripts/trust-log.sh demo pass 21 volte, poi --tier demo stampa auto. Registra un fallimento su una competenza con 10+ esecuzioni e vedi l'ALLARME su stderr. Resetta: > memory/trust.tsv.

BUILD 5: Obiettivi Permanenti + il Registro degli Obiettivi

Perché, in una riga: un obiettivo che verifichi una sola volta è un'ipotesi con un timestamp, quindi gli obiettivi completati vengono promossi a invarianti che vengono riverificate quotidianamente e registrate.

Crea un file per ogni cosa completata, goals/<nome>.md:

1predicato: cd $REPO && npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
2nato: 2026-07-06
3fonte: /goal sessione 2026-07-06 (fix auth flake)
4stato: soddisfatto
5ultimo-superamento: 2026-07-06
6su-violazione: svegliami. Non auto-correggere.
7ritira-quando: modulo auth eliminato. Il ritiro è una decisione umana, registrata.

Crea loop/verify-goals.sh:

1#!/usr/bin/env bash
2set -uo pipefail
3REGISTRO="memory/goal-ledger.tsv"; VIOLAZIONI=0
4for g in goals/*.md; do
5  [ -e "$g" ] || continue
6  grep -q '^stato: ritirato' "$g" && continue
7  pred=$(grep '^predicato:' "$g" | cut -d' ' -f2-); nome=$(basename "$g" .md)
8  inizio=$(date +%s%3N)
9  if timeout 60 bash -c "$pred" >/dev/null 2>&1; then r=pass
10    sed -i "s/^stato:.*/stato: soddisfatto/; s/^ultimo-superamento:.*/ultimo-superamento: $(date +%F)/" "$g"
11  else r=FALLITO; VIOLAZIONI=$((VIOLAZIONI+1)); sed -i "s/^stato:.*/stato: VIOLATO/" "$g"; fi
12  echo -e "$(date -Is)\t$nome\t$r\t$(( $(date +%s%3N) - inizio ))" >> "$REGISTRO"
13done
14[ "$VIOLAZIONI" -gt 0 ] && { grep -l '^stato: VIOLATO' goals/*.md; exit 1; }
15echo "tutti gli obiettivi permanenti sono validi"

Avvia la sentinella (solo rilevamento; le correzioni passano attraverso la pipeline normale):

1/loop 1d Esegui ./verify-goals.sh. Se non-zero: per ogni obiettivo violato, leggi la sua
2data ultimo-superamento e elenca cosa è stato unito da allora (git log --oneline --since=<data>).
3Segnala obiettivo, sospetti, politica su-violazione. Non correggere nulla.

La legge di promozione è già in CLAUDE.md (BUILD 1): ogni /goal superato scrive il proprio obiettivo permanente. Completare È l'iscrizione.

Query del registro che userai effettivamente:

1awk -F'\t' '$3=="FAIL"{n[$2]++} END{for(g in n) print n[g],g}' memory/goal-ledger.tsv | sort -rn | head -5   # più instabili
2grep <goal> memory/goal-ledger.tsv | awk -F'\t' '$3=="FAIL"' | head -1                                      # quando si è rotto

Predicato instabile: quarantena (stato: ritirato, nota "serve un predicato migliore"), mai eliminare.

CHECK 5: Aggiungi un goal con predicato: true e uno con predicato: false. ./verify-goals.sh esce con 1, trasforma il secondo in VIOLATED, ed entrambi appaiono nel ledger. Elimina i dummy.

BUILD 6: Il Budget

Perché: costo giornaliero = tick × triage + hit × (conductor + worker + verifier). A prezzi reali (triage $0,01, conductor $0,35, worker $0,10, verifier $0,40): un janitor giornaliero costa ~$2,56/giorno; un babysitter da 15 minuti con Fable in triage costa $34/giorno per lo stesso identico risultato. Il modello che legge i tick silenziosi decide il conto.

Crea loop/scripts/log-cost.sh:

1#!/usr/bin/env bash
2echo -e "$(date -Is)\t$1\t$2" >> "$(dirname "$0")/../memory/usage.log"

Crea loop/scripts/cost-check.sh:

1#!/usr/bin/env bash
2set -euo pipefail
3F="$(dirname "$0")/../memory/usage.log"; touch "$F"; TODAY=$(date +%F)
4case "${1:-}" in
5  --budget)
6    spent=$(awk -F'\t' -v d="$TODAY" '$1 ~ d {s+=$3} END{printf "%.2f",s}' "$F")
7    awk -v s="$spent" -v b="$2" 'BEGIN{exit (s>=b)?1:0}' \
8      || { echo "spesi \$$spent di \$$2" >&2; exit 1; };;
9  --report)
10    awk -F'\t' -v since="$(date -d '7 days ago' +%F)" \
11      '$1>=since{s[$2]+=$3;t+=$3} END{for(k in s) printf "  %-10s $%.2f\n",k,s[k]; printf "  TOTALE      $%.2f\n",t}' "$F";;
12esac

Regole che lo mantengono piatto: la cadenza è una decisione di costo (dimezzare l'intervallo raddoppia il minimo); il tick silenzioso deve costare centesimi; lo sforzo mai sopra high nei loop (xhigh è per revisioni singole; lo sforzo è per step, non per esecuzione).

CHECK 6: Dopo una settimana di tick, ./scripts/cost-check.sh --report corrisponde alla formula entro il rumore. Imposta DAILY_BUDGET_USD su un numero che non ti dispiacerebbe sprecare.

BUILD 7: I Loop Opzionali (installa quando si presenta la loro condizione)

• Quorum (installa quando il dispatch mostra risvegli di Fable che hanno prodotto azione: stop). Tre modelli economici votano; Fable si sveglia su 2 su 3. I votanti non vedono mai le risposte degli altri.

1V=0
2for m in deepseek/deepseek-v4-flash qwen/qwen-3.6 moonshotai/kimi-k2.6; do
3  llm -m "openrouter/$m" -s "$(cat triage.md)" < /tmp/signals.txt \
4    | grep -q "status: actionable" && V=$((V+1))
5done
6[ "$V" -ge 2 ] && exec ./conduct.sh || echo "quorum: silenzio ($V/3)"

• Ratchet (installa quando un singolo numero conta). Miglioramento monotono o auto-revert; la metrica non può essere aggirata; il minimo raggiunto diventa un goal permanente.

1/goal Ridurre `npm run lint 2>&1 | grep -c warning` a 0.
2Permessi: modificare src/; commit per ogni fix; rimisurare dopo ogni modifica.
3Muri: il numero NON sale mai; annulla qualsiasi modifica che lo aumenti o rompa
4un test; non modificare mai la configurazione di lint per abbassarlo.
5Timebox: fermarsi dopo 3 tentativi senza progressi; segnalare i sopravvissuti.

• Sparring (installa quando spedisci codice quotidianamente). Costruttore e distruttore, opposti; nessuno tocca l'output dell'altro; le dispute vanno a te.

1/loop 1d [distruttore] Leggi i diff uniti di ieri. Scrivi UN test fallito che
2esponga una debolezza reale. Committa sotto tests/sparring/ taggato @sparring.
3Non riparare nulla. Codice solido = dillo, non scrivere nulla.
4/loop 1d [costruttore] Se un test @sparring fallisce, ripara il CODICE finché non passa.
5Non modificare, indebolire o eliminare mai un test di sparring; le dispute si accumulano per me.

• Compost (installa sempre, settimanalmente). I fallimenti diventano leggi; massimo tre proposte; firma umana richiesta.

1/loop 7d Leggi gli scarti di questa settimana: FAILED in STATE.md, fallimenti in trust.tsv,
2FAIL in goal-ledger.tsv, PR chiusi non uniti. Estrai AL MASSIMO 3 proposte:
3una nuova legge CLAUDE.md (cita incidenti), una correzione di skill (stesso fallimento che si ripete),
4o un goal permanente che ci mancava. Solo proporre. Settimana pulita = dillo.

CHECK 7: Ogni loop opzionale ha la sua condizione di installazione scritta accanto nelle tue note. Installarli in modo speculativo è come i sistemi si gonfiano.

BUILD 8: Operazioni

Crea Makefile:

1tick:            ; ./loop/loop.sh
2queue:           ; @grep -E "review:|queued:|FAILED:|rerouted" loop/memory/STATE.md || echo vuoto
3trust:           ; @./loop/scripts/trust-log.sh --render
4audit:           ; @./loop/scripts/cost-check.sh --report
5goals:           ; @./loop/verify-goals.sh
6clean-worktrees: ; @git worktree list | awk '/wt-/{print $$1}' | xargs -rn1 git worktree remove --force

Cron, quando inizia la Settimana 2:

10 7 * * 1-5  cd /path/to/repo/loop && ./loop.sh >> memory/cron.log 2>&1
230 7 * * *   cd /path/to/repo/loop && ./verify-goals.sh >> memory/cron.log 2>&1

Il programma di fiducia di 30 giorni

Non saltare le graduatorie; ognuna sblocca la successiva.

Settimana

Livello

Cosa fai

Quando sei promosso

1

L1 report

Build 1-6;

make tick

a mano ogni giorno; leggi tutto

3 esecuzioni consecutive instradano esattamente come avresti fatto tu

2

L2 draft

cron attivo;

make queue

con il caffè; le revisioni alimentano il ledger

2 skill superano 20 esecuzioni registrate

3

L3 ship

make audit

vs la formula; la skill migliore va senza supervisione

1 settimana, zero interventi

4

L4 grow

compost approvazioni; approva 1 skill proposta; esegui il passaggio di eliminazione

hai rimosso qualcosa e nulla si è rotto

Il runbook. Cosa significa ogni allarme e cosa fare:

Segnale

Significato

Azione

exit 2 (reroute)

il router di salvaguardia ha scambiato modelli a metà esecuzione

leggi il checkpoint; riesegui l'elemento domani; non iterare mai sull'output scambiato

stop_reason: refusal

il classificatore di sicurezza ha rifiutato (HTTP 200, non un errore)

percorso ufficiale: fallback a Opus 4.8 tramite

fallbacks

o middleware; se si ripete su una skill, controlla quella skill per eco di ragionamento o frasi vicine a cyber/bio

exit 3 (budget)

la spesa giornaliera ha raggiunto il limite

make audit

; trova quale fase è cresciuta; correggi la mappa dello sforzo, non il budget

ALERT declassato

una skill consolidata è scesa sotto il 90%

leggi i suoi ultimi 3 fallimenti; di solito è lo schema della specifica, non il worker

goal VIOLATED

qualcosa di finito ha smesso di essere vero

la sentinella fornisce sospetti; la correzione passa attraverso il normale pipeline

stallo maker/checker x2

nessuno dei due è presunto corretto

decidi tu, o esegui lo stallo-breaker (terzo revisore fresco, giudica le prove, non può dividere la differenza)

verify-goals timeout

predicato troppo costoso

questa è una violazione; rendi il predicato più economico

Le Regole (stampa questo)

1. Leggi, non suggerimenti: un numero, un mai, o un comando che lo verifica.
2. Il conductor pianifica, i worker eseguono, nessuno verifica. --allowedTools lo impone.
3. Gli agenti parlano in ordini di lavoro. done_when = specifica + condizione di stop + invariante futura.
4. Spendi sforzo dove il loop si dirama. Mai sopra high in un loop.
5. Il tick silenzioso costa un centesimo o il loop costa mille.
6. Se uno script shell non potesse controllarlo, non scriverlo come goal.
7. I goal vengono promossi; non vengono chiusi. verify-goals.sh viene eseguito quotidianamente, per sempre.
8. Autonomia per skill: 20 esecuzioni, 95%, automatica. Declassamento automatico e rumoroso.
9. Due ledger: trust (worker) e goals (lavoro). Leggi entrambi con il caffè.
10. Calcola il metabolismo prima di impostare il cron.
11. Contratto nel repo: agisce-da-solo / accoda / mi-sveglia.
12. Non iterare mai sull'output di un modello che non hai scelto.
13. La sentinella rileva; il pipeline corregge.
14. Quorum prima di svegliare Fable. Ratchet poi salda. Sparring quotidiano. Compost settimanale.
15. Un criterio di promozione alla volta. Ogni mese, elimina qualcosa.
16. Dalla documentazione ufficiale: max_tokens limita pensiero più testo, i rifiuti sono HTTP 200, non chiedere mai ragionamento ripetuto, le skill vecchie degradano Fable, e i verificatori con contesto fresco battono l'autocritica. Anthropic lo dice; il sistema lo impone.

Conclusione

Tra trenta giorni, se hai fatto i check: un loop spedisce lavoro noioso senza supervisione, una directory goals riverifica tutto ciò che hai mai finito, due ledger ti dicono la verità sui tuoi worker e sul tuo lavoro, e un compost settimanale propone il prossimo miglioramento del sistema per la tua firma.

• Il modello non è mai stato la parte difficile. La parte difficile è stata costruire qualcosa intorno ad esso che rimanga onesto quando smetti di guardare. Questo è ciò che hai appena costruito.
• Inizia stasera con i venti minuti che lo dimostrano: BUILD 2's verify.sh, BUILD 3's primo tick a mano, e un goal permanente per l'ultima cosa che hai finito.
• La prima volta che verify-goals.sh cattura una regressione silenziosa su qualcosa che eri sicuro fosse finito, non avrai bisogno di convincerti del resto.

Disclaimer

Questo articolo è stato scritto utilizzando le note dell'utente e modificato da Claude Opus 4.8 max.