Come costruire il tuo primo loop di IA nel 2026

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

Due degli ingegneri AI più esperti al mondo hanno detto la stessa cosa il mese scorso.

Peter Steinberger, creatore di OpenClaw, ora in OpenAI:

"Non dovresti più fare prompt per gli agenti di coding. Dovresti progettare loop che fanno prompt per i tuoi agenti."

Boris Cherny, responsabile di Claude Code in Anthropic:

"Non faccio più prompt a Claude. Ho dei loop in esecuzione che fanno prompt a Claude e decidono cosa fare. Il mio lavoro è scrivere loop."

La maggior parte delle persone ha letto queste frasi e ha pensato: cosa significa in pratica?

E, cosa più importante: come si costruisce uno di questi loop?

Questo articolo te lo spiega esattamente.

Niente teoria senza codice. Niente codice senza contesto. Passaggi reali. Comandi reali. Copia ed esegui.

Slate orchestra GPT-5.6, Claude e subagenti specializzati in un'attività di migrazione reale. Il modello è diventato più intelligente. Il cambiamento più grande è che strumenti come Slate possono finalmente tenere occupati quei modelli in modo continuo, invece di aspettare i prompt umani.

Il modo in cui la maggior parte delle persone usa l'AI è già superato

Scrivi un prompt. Aspetta. Leggi l'output. Correggi manualmente. Scrivi un altro prompt.

Tu sei il loop.

Ogni passaggio passa attraverso di te. L'AI aspetta. Tu decidi. L'AI aspetta di nuovo.

Nel momento in cui ti fermi, tutto si ferma.

I costruttori che si muovono più velocemente nel 2026 non stanno scrivendo prompt migliori.

Stanno costruendo sistemi che fanno i prompt al posto loro.

Il punto di leva si è spostato.

Dal digitare prompt → al progettare loop.

Cosa è cambiato con GPT-5.6?

GPT-5.6 non cambia la necessità dei loop.

Ne aumenta il valore.

Migliore è il modello, più costoso diventa lasciarlo inattivo tra un prompt e l'altro.

Nei flussi di lavoro da terminale, GPT-5.6 è notevolmente migliore in:

→ comprensione di codebase di grandi dimensioni

→ mantenimento della coerenza nell'implementazione

→ seguire piani multi-step

→ recupero da tentativi falliti

→ agire come un severo verificatore

Il risultato non è "prompt migliori".

Sono meno interventi umani per attività.

Cosa è realmente un loop

Definizione semplice:

Un prompt risponde una volta e si ferma.

Un loop continua a lavorare finché il lavoro non è effettivamente completato.

Non finché non genera una risposta.

Finché non raggiunge un risultato verificato.

Ogni agente AI serio esegue lo stesso ciclo sottostante:

→ Scopri — cosa deve essere fatto?

→ Esegui — fai il lavoro

→ Verifica — ha funzionato davvero?

→ Itera — non è finito? correggi e ripeti

→ Ferma — condizione soddisfatta, o limite massimo raggiunto

Claude Code. Cursor. Codex.

Sotto, eseguono tutti questo loop.

La differenza tra un prompt e un loop non è il modello.

È se qualcosa controlla il lavoro e continua finché non supera.

Il test delle 4 condizioni — esegui questo prima di costruire qualsiasi cosa

La maggior parte dei loop fallisce qui.

Un loop ripaga il suo costo di configurazione solo quando tutte e 4 le condizioni sono vere.

Se ne manca una, il loop costa più di quanto restituisce.

1. L'attività si ripete. Almeno settimanalmente. Un'attività una tantum è ancora meglio servita da un buon prompt.

2. La verifica è automatizzata. Qualcosa deve far fallire il lavoro senza di te nella stanza. Test. Linter. Build. Type check. Nessun gate = l'agente si sta auto-valutando.

3. Il tuo budget di token può assorbire lo spreco. I loop rileggono l'intero contesto ad ogni iterazione. Riprovano, esplorano, bruciano token indipendentemente dal fatto che l'esecuzione produca qualcosa. Questo è il costo che nessuno menziona.

4. "Fatto" è oggettivo. Un test che passa o fallisce. Una build che compila o no. Non "quando sembra a posto". Se "fatto" richiede un'opinione umana, mantienilo manuale.

Passa tutte e 4 → costruisci il loop.

Ne fallisci una qualsiasi → usa un prompt invece.

La versione onesta: la maggior parte degli sviluppatori non ha ancora bisogno di loop pesanti. Ciò che tutti possono usare è un loop semplice. Ne costruiremo uno a breve.

Installa Slate

Slate è un agente di coding AI costruito proprio per questo: eseguire attività lunghe, parallele e multi-step nel tuo terminale.

Costruito da RandomLabs. Il primo agente costruito specificamente per l'orchestrazione di sciami.

Cosa lo rende diverso da Claude Code o Cursor:

→ Seleziona automaticamente il modello giusto per ogni passaggio. Pianifica con Claude, cerca con un altro, esegui con Codex — Slate decide.

→ Esegue subagenti paralleli simultaneamente nella tua codebase

→ Gestisce il proprio contesto in sessioni lunghe multi-ora

→ Lavora insieme a te — non solo per te

Installalo con un comando:

1npm i -g @randomlabs/slate

Naviga nel tuo progetto e avvialo:

1cd /path/to/your/project
2slate

Questo apre la TUI di Slate — un'interfaccia terminale dove gli dai compiti e lo guardi lavorare.

Passo 1 — Configura il tuo spazio di lavoro

Prima che Slate possa eseguire loop sul tuo progetto, deve capire la tua codebase.

Crea un file AGENTS.md nella radice del tuo progetto. Questo è il contesto che Slate legge all'inizio di ogni sessione.

1# AGENTS.md
2
3## Cosa fa questa codebase
4[Descrizione del progetto in un paragrafo]
5
6## Architettura
7- src/api/ — Route API Express
8- src/services/ — Logica di business
9- src/db/ — Modelli di database (PostgreSQL via Prisma)
10- tests/ — Suite di test Jest
11
12## Comandi chiave
13- npm test — esegue l'intera suite di test
14- npm run build — compilazione TypeScript
15- npm run lint — controllo ESLint
16- npm run typecheck — tsc --noEmit
17
18## Regole
19- Non modificare mai src/billing/ o src/auth/ senza approvazione umana
20- Esegui sempre i test prima di segnare qualsiasi attività come completata
21- Usa il pattern di gestione degli errori esistente in src/utils/errors.ts
22
23## Ambiente
24- .env.slate contiene tutte le variabili d'ambiente necessarie a Slate

Slate legge questo file automaticamente all'avvio — non c'è bisogno di incollarlo ad ogni sessione.

Aggiungi le directory del tuo spazio di lavoro all'interno di Slate:

1/workspace add ./src
2/workspace add ./tests
3/workspace list

Oppure fai riferimento a file specifici inline usando le menzioni @:

1Per favore, rivedi @src/api/routes.ts e suggerisci miglioramenti

Passo 2 — Configura Slate

Crea slate.json nella radice del tuo progetto per controllare come si comporta Slate.

1{
2  "$schema": "https://randomlabs.ai/config.json",
3  "permission": {
4    "*": "allow",
5    "bash": "ask"
6  },
7  "models": {
8    "main": { "default": "anthropic/claude-opus-4.6" },
9    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
10    "search": { "default": "anthropic/claude-haiku-4.5" },
11    "reasoning": { "default": "openai/gpt-5.6" }
12  }
13}

Cosa fa:

→ "*": "allow" — Slate può leggere e scrivere file senza chiedere ogni volta

→ "bash": "ask" — Slate chiede prima di eseguire comandi shell (tienilo attivo finché non ti fidi)

→ Configurazione modelli — modello veloce ed economico per la ricerca, modello costoso per il ragionamento principale

Per esecuzioni CI o automatizzate dove non vuoi prompt:

1slate run "Esegui la suite di test e correggi eventuali errori" --dangerously-skip-permissions --output-format stream-json

Passo 3 — Il tuo primo compito (non ancora un loop)

Prima di costruire un loop, rendi affidabile una singola esecuzione manuale.

Questo è il passaggio più saltato. E il motivo per cui la maggior parte dei loop fallisce in produzione.

Dai a Slate un compito reale:

1Per favore, rivedi l'architettura dell'intera mia codebase.
2Crea un file ARCH.md con:
3- struttura attuale
4- dipendenze tra i moduli
5- 3 cose da migliorare
6Guarda prima @src/, poi @tests/

Guarda Slate lavorare. Farà:

1. Cercherà nei tuoi file
2. Costruirà la comprensione dell'architettura
3. Abbozzerà il file ARCH.md
4. Lo rivedrà rispetto alla tua richiesta prima di fermarsi

Questo è già un mini-loop — controlla il proprio output prima di finire.

Per un compito più lungo:

1Ehi Slate, analizza la mia codebase per il flusso di autenticazione,
2poi crea un piano per aggiungere il supporto OAuth2.
3Assicurati di guardare @src/auth/ e @src/api/routes.ts

Slate restituisce un piano. Tu iteri su di esso:

1No, non aggiungere una nuova classe provider di autenticazione.
2Fai in modo che segua lo stesso pattern di ApiKeyAuth esistente in src/auth/api-key.ts

Approva il piano. Slate esegue in modo autonomo.

Passo 4 — Crea una Skill (rendi il loop riutilizzabile)

Una Skill è il modo per smettere di rispiegare il tuo progetto ad ogni sessione.

Scrivila una volta. Slate la legge ad ogni esecuzione pertinente.

Crea la struttura di cartelle:

1mkdir -p .slate/skills/ci-triage
2touch .slate/skills/ci-triage/SKILL.md

Scrivi la skill:

1---
2name: "ci-triage"
3description: "Classifica i fallimenti CI per causa principale e abbozza correzioni per quelli facili."
4---
5
6# Skill di Triage CI
7
8## Cosa faccio
9Quando un'esecuzione CI fallisce, io:
101. Leggo l'output dei test
112. Classifico il fallimento: problema di ambiente / test instabile / vero bug / aggiornamento dipendenza / infrastruttura
123. Abbozzo correzioni per bug e problemi di dipendenza
134. Segnalo i problemi di ambiente e infrastruttura agli umani
14
15## Regole di classificazione
16- ambiente: secret mancante, variabile d'ambiente sbagliata → segnala a un umano
17- instabile: passa al nuovo tentativo senza modifiche al codice → riprova una volta, poi apri un ticket
18- bug: fallimento deterministico legato a un commit recente → abbozza correzione
19- dipendenza: fallimento legato a un aggiornamento di versione → abbozza PR di rollback
20- infrastruttura: timeout, OOM, problema runner → segnala immediatamente
21
22## Pattern di correzione
23- Fallimenti test di autenticazione → controlla prima src/auth/middleware.ts
24- Fallimenti test di database → verifica che la migrazione sia stata eseguita nell'ambiente CI
25- Fallimenti test E2E → controlla i selettori UI rispetto all'ultimo snapshot
26
27## Non fare mai
28- Disabilitare test falliti
29- Modificare la configurazione CI senza chiedere
30- Toccare src/billing/ o src/payments/
31
32## Stato
33Aggiorna STATE.md dopo ogni esecuzione:
34- File controllati
35- Classificazioni effettuate
36- PR aperti
37- Elementi segnalati

Elenca le skill disponibili all'interno di Slate:

1/skills

Attivane una manualmente:

1@ci-triage per favore, fai il triage dei test falliti di oggi

Oppure Slate attiva le skill automaticamente quando decide che sono pertinenti al compito corrente.

Passo 5 — Aggiungi lo stato (la memoria del loop)

L'agente dimentica.

Il file no.

Crea STATE.md nella radice del tuo progetto:

1# Stato del Loop — Triage CI
2
3## Ultima esecuzione
42026-06-28 03:30 UTC — 7 fallimenti classificati, 3 correzioni abbozzate, 4 segnalati
5
6## In corso
7- claude/fix-auth-token-refresh — test passano in locale, in attesa CI
8- claude/fix-flaky-payment-webhook — pattern di ripetizione applicato, monitoraggio
9
10## Completati
11- claude/bump-axios-1.7.4 → unito (CI verde)
12- claude/lint-fix-pass-june-28 → unito
13
14## Segnalati agli umani
15- src/billing/refund.ts — test falliscono in 3 modi, causa principale poco chiara
16- ci/staging-runner — timeout infrastruttura, non un problema di codice
17
18## Lezioni apprese
19- 2026-06-27: PowerShell ha un problema TLS 1.2 su questo runner Windows. Usa bash.
20- 2026-06-26: tests/e2e/checkout richiede il secret del webhook Stripe nell'ambiente. Salta se mancante.

Dì a Slate di usarlo all'inizio di ogni sessione aggiungendolo ad AGENTS.md:

1## Inizio sessione
2Leggi sempre STATE.md per primo. Riprendi da dove l'ultima esecuzione si è fermata.
3Aggiorna STATE.md alla fine di ogni esecuzione con cosa è stato fatto e cosa viene dopo.

Senza stato: ogni esecuzione parte da zero.

Con stato: ogni esecuzione riprende e si accumula sulla precedente.

Passo 6 — Costruisci il loop vero e proprio

Ora hai:

→ Spazio di lavoro configurato (AGENTS.md)

→ Configurazione impostata (slate.json)

→ Un'esecuzione manuale affidabile dimostrata

→ Una skill scritta (ci-triage)

→ File di stato creato (STATE.md)

È ora di racchiuderlo in un vero loop.

Opzione A: Loop con file di coda (il più semplice)

Crea loop.md:

1Leggi STATE.md per capire cosa è già stato tentato.
2
3Esegui la skill di triage CI su tutti i test falliti nell'ultima build.
4
5Per ogni fallimento:
6- Classificalo usando le regole della skill ci-triage
7- Abbozza una correzione per bug e problemi di dipendenza
8- Segnala i problemi di ambiente e infrastruttura
9
10Esegui le correzioni. Controlla se i test passano.
11Se i test passano → apri una PR.
12Se i test falliscono ancora → registra in STATE.md e fermati.
13
14Aggiorna STATE.md con tutto ciò che è stato fatto in questa esecuzione.
15
16Fermo massimo: 8 tentativi. Al limite, riporta lo stato corrente.

Eseguilo:

1slate --queue loop.md

Slate legge il file di coda ed esegue ogni blocco come un messaggio in coda.

Opzione B: Loop headless/CI (automatizzato)

Eseguilo in modo non interattivo in un'azione GitHub o in un cron job:

1slate run "$(cat loop.md)" --output-format stream-json --dangerously-skip-permissions

In un flusso di lavoro di GitHub Actions:

1name: Loop di Triage CI
2on:
3  workflow_run:
4    workflows: ["CI"]
5    types: [completed]
6
7jobs:
8  triage:
9    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13
14      - name: Installa Slate
15        run: npm i -g @randomlabs/slate
16
17      - name: Esegui loop di triage
18        env:
19          SLATE_API_KEY: ${{ secrets.SLATE_API_KEY }}
20        run: |
21          slate run "$(cat loop.md)" \
22            --output-format stream-json \
23            --dangerously-skip-permissions \
24            --workspace ./src \
25            --workspace ./tests

Ora ogni fallimento CI attiva automaticamente il loop di triage.

Nessun umano necessario fino alla segnalazione.

Passo 7 — Aggiungi sub-agenti (la separazione creatore-verificatore)

Il miglioramento strutturale più importante per qualsiasi loop.

Non lasciare mai che lo stesso agente valuti il proprio lavoro.

Il modello che ha scritto la correzione è un valutatore troppo generoso.

In Slate, puoi impostare modelli diversi per ruoli diversi:

1{
2  "models": {
3    "main": { "default": "anthropic/claude-opus-4.6" },
4    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
5    "search": { "default": "anthropic/claude-haiku-4.5" }
6  }
7}

Poi scrivi il tuo compito in modo che Slate usi questa separazione in modo naturale:

1Per favore, correggi i test di autenticazione falliti.
2
3Passo 1: Fai esplorare a un agente di ricerca src/auth/ per capire l'implementazione attuale.
4Passo 2: Fai implementare la correzione a un agente separato basandosi su ciò che è stato trovato.
5Passo 3: Fai verificare la correzione a un terzo agente rispetto ai requisiti originali del test —
6        questo agente NON dovrebbe aver visto l'implementazione.
7Passo 4: Apri la PR solo se il verificatore approva.

Slate orchestra i subagenti automaticamente.

L'agente di ricerca usa un modello veloce ed economico. L'agente di implementazione usa un modello più potente. Il verificatore usa un modello rigoroso senza accesso al ragionamento del creatore.

Questa separazione è il motivo per cui Slate può eseguire 5 subagenti paralleli su un singolo compito — ognuno specializzato, ognuno isolato.

Passo 8 — Il pattern del loop di stato (per compiti di lunga durata)

Per compiti che vengono eseguiti per ore o giorni, usa questo pattern nel prompt del tuo compito:

1Stai eseguendo un loop multi-sessione.
2
3OBIETTIVO: Migrare tutte le route Express al nuovo pattern ApiError.
4Tieni traccia dei progressi in STATE.md.
5
6INIZIO DI OGNI SESSIONE:
71. Leggi STATE.md
82. Trova il primo elemento incompleto in "Route rimanenti"
93. Esegui solo quell'elemento
10
11FINE DI OGNI SESSIONE:
121. Sposta gli elementi completati in "Route completate" in STATE.md
132. Registra eventuali blocchi in "Blocchi"
143. Aggiorna il timestamp "Ultima esecuzione"
154. Fermati in modo pulito
16
17Formato STATE.md:
18---
19## Route completate
20- [x] /api/users (2026-06-27)
21- [x] /api/auth/login (2026-06-28)
22
23## Route rimanenti
24- [ ] /api/payments/checkout
25- [ ] /api/payments/refund
26- [ ] /api/admin/users
27
28## Blocchi
29- /api/payments/refund — richiede revisione umana (tocca la logica di fatturazione)
30
31## Ultima esecuzione
322026-06-28 14:30 UTC
33---
34
35REGOLE FERREE:
36- Non toccare mai src/billing/ senza approvazione umana
37- Esegui sempre i test dopo ogni migrazione di route
38- Fermati dopo aver completato UNA route per sessione

Eseguilo ogni mattina:

1slate --continue "$(cat loop.md)"

--continue riprende la sessione più recente invece di ricominciare da capo.

Ogni giorno, una route in più. STATE.md tiene traccia di tutto.

Il loop riprende esattamente da dove si era fermato.

Passo 9 — Comandi personalizzati per i tuoi loop più usati

Aggiungi comandi slash personalizzati a slate.json in modo che i tuoi loop siano sempre a portata di tasto:

1{
2  "command": {
3    "triage": {
4      "description": "Esegui il loop di triage CI",
5      "template": "Leggi STATE.md. Esegui la skill ci-triage su tutti i test falliti. Aggiorna STATE.md al termine.",
6      "agent": "build"
7    },
8    "review": {
9      "description": "Rivedi un file per correttezza",
10      "template": "Rivedi @$ARGUMENTS per correttezza, casi limite e coerenza con il codice circostante."
11    },
12    "migrate": {
13      "description": "Migra una route al pattern ApiError",
14      "template": "Leggi STATE.md. Migra la prossima route incompleta al pattern ApiError. Esegui i test. Aggiorna STATE.md."
15    }
16  }
17}

Ora all'interno di Slate:

1/triage
2/review src/api/payments.ts
3/migrate

Ognuno esegue all'istante il prompt del tuo loop pre-scritto.

3 loop completi che puoi eseguire oggi

Loop 1: Triage dei fallimenti CI (quello che abbiamo costruito)

Quando: ogni fallimento CI Cosa: classifica → correggi i facili → segnala i difficili → apri PR Stato: STATE.md Gate: test passano Tempo di configurazione: 30 minuti

1# attivazione
2slate run "$(cat loop.md)" --dangerously-skip-permissions --output-format stream-json
3
4# o in GitHub Actions — vedi Passo 6 sopra

Loop 2: Brief mattutino

Quando: 7:00 ogni giorno feriale (cron job) Cosa: analizza le ultime 24 ore di commit, PR e issue aperti → scrivi un brief di 5 punti → pubblica su Slack

1# loop.md per il brief mattutino
2cat > morning-brief-loop.md << 'EOF'
3Leggi le ultime 24 ore di:
4- git log --since="24 hours ago" --oneline
5- PR aperte in bozza o in revisione
6- Issue GitHub aperte o aggiornate nelle ultime 24h
7
8Scrivi un brief mattutino:
9- 3 cose più importanti successe
10- 2 cose che necessitano attenzione oggi
11- 1 cosa a rischio di bloccare qualcuno
12
13Mantienilo sotto le 120 parole. Pubblicalo nel canale Slack #engineering.
14EOF
15
16# esegui su base programmata con cron
170 7 * * 1-5 slate run "$(cat morning-brief-loop.md)" --dangerously-skip-permissions

Loop 3: Loop di aggiornamento dipendenze

Quando: ogni lunedì Cosa: cerca pacchetti obsoleti → testa la compatibilità → apri PR per aggiornamenti sicuri

1cat > deps-loop.md << 'EOF'
2Leggi STATE.md.
3
4Esegui: npm outdated
5
6Per ogni pacchetto obsoleto:
71. Controlla se l'aggiornamento di versione è major (con modifiche sostanziali) o minor/patch (sicuro)
82. Per minor/patch: aggiorna il pacchetto, esegui npm test
93. Se i test passano: apri una PR
104. Se i test falliscono: registra in STATE.md come "necessita revisione umana"
115. Per aggiornamenti major: segnala sempre agli umani
12
13Regole ferree:
14- Non aggiornare mai più di 5 pacchetti in un singolo loop
15- Non aggiornare mai i pacchetti nella sezione "peer dependencies"
16- Esegui sempre l'intera suite di test dopo ogni aggiornamento, non solo i test correlati
17
18Aggiorna STATE.md con cosa è stato aggiornato e cosa è stato segnalato.
19EOF
20
21# esegui ogni lunedì
220 9 * * 1 slate run "$(cat deps-loop.md)" --dangerously-skip-permissions

Le modalità di fallimento che costano soldi

Conoscile prima di programmare qualsiasi cosa.

Il Loop di Ralph Wiggum

L'agente dichiara completato un lavoro a metà.

Esce presto. Il loop continua a spendere. In silenzio.

Correzione: condizione di arresto forzato controllata da un modello fresco.

1CONDIZIONE DI ARRESTO: Tutti i test in tests/auth/ passano E lint restituisce 0.
2Verifica usando un'esecuzione di controllo separata, non il giudizio dell'agente stesso.
3Limite massimo: 8 iterazioni. Al limite: riporta lo stato e fermati.

Deriva dell'obiettivo

Nelle sessioni lunghe, i vincoli iniziali scompaiono.

"Non toccare mai src/billing/" del messaggio 3 è sparito al messaggio 47.

Correzione: aggiungi un VISION.md che Slate rilegge all'inizio di ogni sessione.

1# VISION.md — Leggi all'inizio di ogni sessione
2
3## Obiettivo principale
4Migrare tutte le route Express al pattern ApiError.
5
6## Vincoli ferrei (non violare mai)
7- Non toccare mai src/billing/ senza approvazione umana
8- Non disabilitare mai test falliti
9- Esegui sempre l'intera suite di test prima di aprire qualsiasi PR
10
11## Priorità corrente
12Route in src/api/payments/ — gestisci con cura extra

Bias auto-referenziale

Il creatore valuta il proprio lavoro. Si dà sempre il via libera.

Correzione: subagente verificatore con accesso zero al ragionamento del creatore.

Dillo esplicitamente a Slate:

1L'agente verificatore NON dovrebbe vedere il lavoro dell'agente di implementazione.
2Dovrebbe vedere solo: i requisiti originali del test e l'output del test.
3Se i test passano → approva. Se i test falliscono → rifiuta. Nessuna opinione altrimenti.

Pigrizia agentica

Il loop considera un compito "abbastanza fatto" al completamento parziale.

Specialmente con criteri di successo vaghi.

Correzione: condizione di arresto oggettiva solo.

1FATTO QUANDO: npm test restituisce codice di uscita 0 E npm run lint restituisce codice di uscita 0.
2Non quando "i test sembrano a posto." Non quando "la maggior parte dei test passa."
3Codice di uscita 0 su entrambi i comandi. Questo è l'unico "fatto".

I trucchi specifici di Slate che contano

Alcune cose che rendono Slate diverso dagli altri agenti nella pratica.

Accodare messaggi mentre lavora

Slate sta eseguendo un compito lungo. Ti viene in mente qualcosa di importante.

Premi Tab per accodare il messaggio — viene eseguito dopo che il compito corrente è finito, senza interromperlo.

1[Slate sta lavorando al compito di migrazione...]
2
3Tu: In realtà, assicurati che il nuovo pattern gestisca anche il caso in cui userId è null
4[Tab — accodato]
5
6[Slate finisce il passaggio corrente, poi legge il tuo messaggio accodato]

Guidare durante l'esecuzione

Se Slate sta andando nella direzione sbagliata, non devi fermarlo:

1[Slate è a metà dell'implementazione della correzione...]
2
3Tu: Aspetta — non aggiungere una nuova classe per questo. Usa il BaseError esistente in src/utils/errors.ts
4[Invio — guida immediatamente]
5
6Slate: Capito, cambio approccio per usare BaseError...

Usa /enter-mode-next per passare da modalità guida / accoda / interrompi.Comandi shell direttamente

Esegui comandi all'interno della sessione di Slate senza passare a un altro terminale:

1!npm test          # esegue i test e invia l'output a Slate
2!git diff HEAD     # controlla cosa è cambiato
3!git status        # vede lo stato corrente

Slate legge l'output e lo usa nella sua azione successiva.

Modalità server per configurazioni di team

Esegui Slate come server e collegati da più terminali:

1# Terminale 1 — avvia il server
2slate serve --port 7777
3
4# Terminale 2 — collega la TUI
5slate attach http://localhost:7777 --dir /path/to/project

Utile per la programmazione in coppia con Slate o per eseguirlo su una macchina remota.

La lista di controllo completa per la configurazione

Prima di eseguire il tuo primo vero loop:

1□ npm i -g @randomlabs/slate installato
2□ AGENTS.md creato con panoramica del progetto, comandi, regole
3□ slate.json creato con permessi e configurazione modelli
4□ Un'esecuzione manuale completata e verificata affidabile
5□ SKILL.md scritta per il tuo primo compito ripetuto
6□ STATE.md creato e referenziato in AGENTS.md
7□ loop.md scritto con condizione di arresto esplicita
8□ Limite massimo di iterazioni (8 per iniziare)
9□ Il verificatore NON è lo stesso agente del creatore
10□ Gate di revisione umana su qualsiasi azione irreversibile (PR, deploy)

Spunta ogni casella prima di programmare qualsiasi cosa.

Saltane una e il loop fallirà in silenzio o ti farà pagare per niente.

Per altra ispirazione sui loop

Una volta compreso lo schema, il collo di bottiglia passa da "come costruisco un loop" a "quale loop dovrei costruire dopo".

La Forward Future Loop Library su signals.forwardfuture.com/loop-library è un ottimo posto per esplorare loop reali in esecuzione in diverse categorie: contenuti, ingegneria, operazioni, ricerca.

Quando vedi 20 loop funzionanti in un unico posto, smetti di pensare a prompt isolati.

La verità scomoda

Due costruttori possono eseguire lo stesso identico loop e ottenere risultati opposti.

Uno lo usa per muoversi più velocemente su un lavoro che già conosce a fondo.

L'altro lo usa per evitare del tutto di comprendere il lavoro.

Il loop non conosce la differenza.

La conosci tu.

Progettare un loop è più difficile che fare prompt engineering, non più facile.

Il punto non è che il lavoro sia diventato più facile.

Il punto di leva si è spostato.

Costruisci il loop.

Ma costruiscilo come qualcuno che intende rimanere l'ingegnere.

Non solo la persona che preme "avvia".

E il nuovo GPT-5.6 non sostituisce questo principio. Semmai, lo rafforza.

La frontiera non è più chi scrive il prompt più intelligente.

È chi progetta i migliori sistemi attorno a modelli sempre più capaci.

Il riepilogo in 60 secondi

Cos'è un loop:

→ Prompt = domanda. Loop = lavoro.

→ Scopri → Esegui → Verifica → Itera → Fermati

Il test delle 4 condizioni:

→ L'attività si ripete / La verifica è automatizzata / Il budget assorbe gli sprechi / "Fatto" è oggettivo

I 5 passaggi di configurazione:

→ AGENTS.md → slate.json → un'esecuzione manuale → SKILL.md → STATE.md

Poi impacchettalo:

→ file di coda loop.md O esecuzione headless di slate in CI

Le modalità di fallimento:

→ Ralph Wiggum (esce presto) / Deriva degli obiettivi (dimentica i vincoli) / Pregiudizio auto-referenziale (chi fa = chi controlla) / Pigrizia agentica (abbastanza fatto)

Il vantaggio di Slate:

→ Selezione automatica del modello per passaggio → Sottoagenti paralleli con isolamento → Gestione di sessioni lunghe → Il tuo loop, il tuo design

Se questo è stato utile:

→ Ripubblica per condividerlo con ogni costruttore che conosci

→ Segui @sairahul1 per altri sistemi come questo

→ Aggiungilo ai segnalibri: solo la checklist di configurazione vale la pena di essere salvata

Iscriviti a theaibuilders.co per altri articoli interessanti come questo

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

Strumenti menzionati:

→ Documentazione di Slate: docs.randomlabs.ai

→ Forward Future Loop Library: signals.forwardfuture.com/loop-library