Home/ Corsi/ Gen AI per l'automazione dei processi

Gen AI per l'automazione dei processi

Sette lezioni per toglierti di dosso il lavoro ripetitivo: dividi il processo in parti e ognuna la dai a chi la fa meglio, fra te, una formula e l'AI. Si finisce con un'automazione che gira sul tuo lavoro, e per capirci si passa da un gioco che l'AI gioca al posto tuo.

7 lezioni Laboratori + mini-test In presenza e online
Corso di AI generativa per l'automazione dei processi
Le slide del corso sono in fondo alla pagina Vuoi la video lezione? Iscriviti gratis a HI
Indice del corso

Descrizione

Quasi tutti provano l'AI generativa nello stesso modo: aprono una chat, chiedono qualcosa, restano colpiti, e due settimane dopo lavorano come prima. Il salto arriva quando si smette di chiedere cose a una chat e si comincia a togliere pezzi di lavoro da un processo.

Il metodo di questo corso è divide et delega. I passi meccanici li fa una formula o del codice, quelli in cui bisogna capire qualcosa li fa un modello linguistico, quelli con una firma sopra restano a una persona. Il valore sta nel taglio, prima che nel prompt.

È pensato per chi ha un lavoro ripetitivo addosso e vuole riprendersi le ore: liberi professionisti, chi tiene l'amministrazione di una piccola azienda, chi risponde a richieste tutto il giorno. Per seguirlo non serve saper programmare.

Cosa imparerai

  • Scegliere il processo giusto con il conto del tempo, invece che a naso
  • Mappare un processo con passi, decisioni, dati e misure
  • Distinguere i passi meccanici, quelli di giudizio e quelli di responsabilità
  • Scrivere prompt con le quattro C e un formato d'uscita controllabile
  • Costruire un assistente stabile con istruzioni fisse e materiali allegati
  • Collaudare con una batteria di casi, compreso uno che deve fallire
  • Collegare i pezzi in una catena che parte da sola, con innesco e azioni
  • Far giocare a un classificatore un gioco a turni, e portare lo stesso giro sul lavoro
  • Mettere i controlli, tenere il visto umano dove serve e misurare il guadagno

Dettagli del corso

7 lezioni
Struttura
1 per lezione
Laboratori
Mini-test
Autoverifica
Presenza e online
Modalità

Strumenti e requisiti

Un assistente AI Un foglio di calcolo La tua casella di posta Uno strumento di automazione JSON

Va bene qualunque assistente AI a cui puoi dare istruzioni fisse e allegare dei file. Per la Lezione 5 serve uno strumento di automazione, e va bene anche quello della suite che usi già. Nelle Lezioni 5 e 6 c'è del codice commentato riga per riga: si legge anche senza scriverlo, e il laboratorio del gioco è l'unico che chiede di metterci le mani. Il classificatore della Lezione 3 è Bivio, che ho scritto per questo corso: si installa con un comando, gira in locale e non chiede nessuna chiave.

Lezione 1 di 7

Che cosa si automatizza, e che cosa no

Esci da questa lezione con il processo su cui lavorerai per tutto il corso e il conto che dice se automatizzarlo conviene.

Obiettivi della lezione

Chi arriva a un corso sull'automazione di solito ha già in testa lo strumento: ha visto un video su Make, ha sentito parlare di agenti, vuole provare. Il guaio è che lo strumento arriva dopo. Prima bisogna sapere che cosa si automatizza, perché metà del lavoro ripetitivo che ci portiamo dietro andrebbe tolto di mezzo invece che velocizzato.

Alla fine di questa lezione sarai in grado di:

  • Descrivere un processo con le sue quattro parti: innesco, ingressi, passi, esito;
  • Riconoscere quali attività ripetitive meritano di essere automatizzate e quali no;
  • Distinguere i lavori in cui l'AI generativa è brava da quelli in cui serve del software normale;
  • Fare il conto del tempo: quanto costa oggi quel lavoro e in quanto tempo rientri della fatica di automatizzarlo;
  • Scegliere il processo su cui lavorerai per tutto il corso.

Che cos'è un processo

Un processo è una sequenza di passi che parte da qualcosa che succede e finisce con qualcosa di consegnato. Le parti da avere sotto gli occhi ogni volta sono quattro.

  • L'innesco: il fatto che fa partire tutto. Arriva una mail, un cliente compila un modulo, è il primo del mese, qualcuno preme un pulsante.
  • Gli ingressi: il materiale su cui si lavora. Il testo della mail, un PDF, una riga di un foglio, tre informazioni che hai in testa.
  • I passi: quello che si fa, in ordine, comprese le decisioni (se il cliente è nuovo faccio questo, se è già nostro faccio quest'altro).
  • L'esito: la cosa che esce e che qualcuno riceve. Un preventivo mandato, una riga aggiunta a un registro, un post pubblicato.

Prendi il preventivo, che è l'esempio che uso sempre in aula perché ce l'hanno tutti. Innesco: arriva una richiesta per mail o su WhatsApp. Ingressi: quello che il cliente ha scritto, il listino, i lavori simili fatti in passato. Passi: capire che cosa chiede, controllare se siamo già in rapporto, stimare i tempi, scrivere il documento, mandarlo, segnarselo da qualche parte. Esito: un PDF nella casella del cliente e una riga nel foglio dei preventivi aperti.

Perché insisto su questa griglia

Quando un'automazione si rompe, nove volte su dieci si è rotta all'innesco o sugli ingressi: il modulo ha cambiato un campo, la mail arriva da un altro indirizzo, il PDF adesso è una scansione. Se hai scritto queste quattro parti, sai dove andare a guardare.

Quale lavoro merita di essere automatizzato

Non tutto il lavoro ripetitivo vale la fatica. Uso tre domande, in quest'ordine.

Prima domanda: quante volte succede? Una cosa che fai due volte l'anno la fai a mano e stai tranquillo. Sotto le quattro o cinque volte al mese, l'automazione di solito costa più di quello che rende.

Seconda domanda: quanto tempo prende, e quanto di quel tempo è meccanico? Un preventivo prende quaranta minuti, ma trenta sono la testa che decide il prezzo e dieci sono impaginare e copiare indirizzi. I dieci si delegano, i trenta restano tuoi.

Terza domanda: che succede se viene sbagliato? Una bozza di risposta sbagliata la correggi prima di mandarla. Una fattura sbagliata la scopre il commercialista a marzo. Più l'errore è costoso e tardivo da scoprire, più controlli servono, e i controlli sono tempo che si mangia il risparmio.

Ci sono anche due segnali che dicono di lasciar perdere. Il primo: il processo cambia ogni mese perché nessuno ha deciso come si fa. Automatizzare qualcosa di instabile vuol dire rifare l'automazione ogni mese. Il secondo: il processo esiste per abitudine e nessuno usa il risultato. Quel report settimanale che nessuno apre si cancella, invece di generarlo più in fretta.

La trappola del lavoro visibile

Tendiamo a voler automatizzare quello che si vede: la cosa noiosa che facciamo davanti agli altri. Spesso il tempo vero sta altrove, nei cinque minuti ripetuti quaranta volte al giorno che nessuno conta.

Dove l'AI generativa è brava

L'AI generativa lavora sul linguaggio: prende del testo e ne produce dell'altro.

LavoroEsempio concreto
TrasformareDa appunti sconclusionati a una mail ordinata; da verbale a elenco di decisioni
EstrarreDa una mail di richiesta: nome, azienda, che cosa vuole, entro quando
ClassificareSmistare le richieste in assistenza, commerciale, amministrazione
RiassumereTrenta recensioni in cinque punti ricorrenti
AbbozzareLa prima versione di una descrizione prodotto, che poi correggi
Tradurre e riscrivereLo stesso testo per il sito, per la newsletter e per il volantino

E dove sbaglia. Sui conti esatti: un modello linguistico mette in fila numeri plausibili, e un totale plausibile su una fattura è un totale sbagliato. Sui fatti che non gli hai dato: se chiedi il prezzo del tuo servizio senza allegare il listino, se lo inventa con la stessa faccia con cui direbbe la cosa giusta. Sulle cose che cambiano: disponibilità, scadenze, chi ha pagato. Su tutto questo il dato va preso dove sta e passato al modello già pronto.

I conti si fanno fuori

Se un passo del tuo processo contiene una moltiplicazione, falla fare al foglio di calcolo, al gestionale o a due righe di codice, e passa all'AI il risultato già calcolato.

Quando serve il software normale

Una parte di quello che oggi viene venduto come automazione con l'AI è automazione e basta, quella che esiste da trent'anni. Il criterio per scegliere sta in una domanda: la regola è scritta e vale sempre?

Se sì, si usa uno strumento che fa sempre la stessa cosa: una formula, un filtro, una regola della posta, un modello di documento, una riga di codice. Costa meno, va più veloce, e soprattutto sbaglia in modo prevedibile.

Se la regola invece dipende da come è scritto il testo, dal tono, dal contesto, allora serve un modello linguistico. «Sposta in una cartella le mail che contengono la parola fattura» è una regola. «Sposta in una cartella le mail in cui il cliente si sta lamentando» ha bisogno di qualcuno che capisca la frase.

Quasi tutti i processi veri sono misti: pezzi meccanici con dentro due o tre punti in cui bisogna capire qualcosa. Il lavoro della Lezione 3 è proprio tagliare il processo lungo quelle giunture.

Il conto del tempo

Prima di toccare qualunque strumento, si fa un conto su tre righe. È grezzo e basta per decidere.

  1. Costo attuale: minuti a volta × volte al mese. Un preventivo da 40 minuti fatto 12 volte al mese costa 480 minuti, cioè 8 ore.
  2. Costo dopo: quanto durerebbe la parte che resta a te, più il tempo di controllare quello che ha fatto l'AI. Nel preventivo: 30 minuti di testa più 3 di controllo, 12 volte, cioè 396 minuti.
  3. Costo di costruzione: le ore che spendi a mappare, scrivere i prompt, collegare i pezzi e collaudare. Per un processo piccolo sono fra le 4 e le 10 ore la prima volta.

Il punto di pareggio è il rapporto fra la terza riga e il risparmio mensile. Nell'esempio risparmi 84 minuti al mese, cioè un'ora e mezza: se la costruzione ti costa 6 ore, rientri in quattro mesi. Va bene se quel processo lo farai ancora fra quattro mesi.

La voce che tutti dimenticano

La manutenzione. Un'automazione collegata a servizi esterni va toccata due o tre volte l'anno, perché qualcosa a monte cambia. Mettici un'ora ogni quattro mesi nel conto e avrai una stima onesta.

Laboratorio: l'inventario di una settimana

Obiettivo: arrivare alla fine della lezione con un processo scelto, scritto su una riga, e il suo conto del tempo.

Passo 1, l'elenco

Apri un foglio e scrivi tutte le attività ripetitive dell'ultima settimana di lavoro. Vai a memoria e aiutati con la posta inviata e il calendario, che sono i due posti dove il lavoro ripetitivo lascia le impronte. Punta a quindici righe: le prime cinque vengono da sole, le altre dieci sono quelle interessanti.

Passo 2, le colonne

Per ogni riga compila queste colonne:

AttivitàVolte al meseMinuti a voltaQuanto è meccanico (1-5)Che succede se sbaglio (1-5)
Rispondere alle richieste di preventivo124024
Copiare i dati degli ordini nel foglio60453
Scrivere il post settimanale45021
Smistare la posta del mattino201542

Passo 3, il calcolo

Aggiungi una colonna Minuti al mese con volte × minuti, e ordina il foglio dal valore più alto. Nell'esempio qui sopra in testa resta il preventivo con 480 minuti, poi vengono lo smistamento con 300 e i dati degli ordini con 240: guarda che la riga da 4 minuti ripetuta 60 volte pesa più del post da 50 minuti.

Passo 4, la scelta

Scegli una riga che stia in alto per minuti al mese, abbia un punteggio di meccanicità di 3 o più, e un rischio di 3 o meno. È il tuo processo per tutto il corso. Scrivilo in una frase sola con questa forma: «Quando succede X, io faccio Y, e ne esce Z».

Risultato atteso

Un foglio con almeno dodici righe compilate, ordinato per minuti al mese, e una frase scritta che descrive il processo scelto. Tienilo aperto: nella Lezione 2 lo trasformiamo in una mappa.

Mini-test di autoverifica

Vuoi testare le tue competenze?

Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.

Entra su HI

Riassunto della lezione

Cosa hai imparato

  • Un processo ha quattro parti: innesco, ingressi, passi, esito. Scriverle serve poi a capire dove si rompe.
  • Tre domande per scegliere: quante volte succede, quanto tempo prende e quanto di quel tempo è meccanico, quanto costa l'errore.
  • L'AI generativa lavora sul linguaggio: trasforma, estrae, classifica, riassume, abbozza. I conti e i dati che cambiano si prendono altrove.
  • Se la regola è scritta e vale sempre, usa il software normale: costa meno e sbaglia in modo prevedibile.
  • Il conto del tempo si fa prima, su tre righe, e comprende la manutenzione.

Prossimi passi

Nella Lezione 2, Mappare il processo prima di toccarlo prendiamo il processo che hai scelto nel laboratorio e lo scriviamo passo per passo, con i tempi, le decisioni e le eccezioni.

Lezione 2 di 7

Mappare il processo prima di toccarlo

Alla fine hai il tuo processo su una pagina: i passi con i minuti, le decisioni con i loro criteri, le eccezioni messe a parte.

Obiettivi della lezione

In aula la frase ricorrente è «il mio processo lo so a memoria, saltiamo questa parte». Poi chiedo di scriverlo passo per passo su un foglio e succedono due cose: saltano fuori tre varianti che nessuno aveva mai nominato, e due persone della stessa azienda scoprono di farlo in modo diverso. Mezz'ora di scrittura risparmia giornate di automazione buttata.

Quando hai finito, sai fare queste cose:

  • Scrivere un processo come elenco di passi con un verbo all'inizio di ogni riga;
  • Segnare le decisioni, i dati che servono e chi fa che cosa;
  • Misurare ogni passo: tempo, frequenza, dove sta l'informazione;
  • Separare il caso normale dalle eccezioni e decidere quali eccezioni restano a mano;
  • Riconoscere i tre errori tipici di chi mappa per la prima volta.

Perché si mappa prima

Una mappa serve a tre cose, in ordine di importanza.

Rende visibile quello che fai in automatico. Gran parte di un lavoro esperto sta nei micro controlli che nessuno racconta: guardi il nome e ti ricordi che quel cliente paga tardi, apri il gestionale per controllare una cosa e nel frattempo ne vedi un'altra. Se quei passi non sono scritti, l'automazione li salta e tu non capisci perché il risultato «non è la stessa cosa».

Ti dice dove sta il tempo. Una volta scritti i passi con i minuti accanto, la metà delle volte scopri che il collo di bottiglia sta in un punto che non avresti toccato: l'attesa di una risposta, la ricerca di un file, il passaggio di consegne fra due persone.

Ti dà il confine di quello che stai automatizzando. Senza confine, un'automazione cresce finché non diventa ingestibile. Con la mappa decidi: da qui a qui, il resto per ora resta com'è.

Mappa quello che fai, non quello che dovresti fare

La tentazione è scrivere la versione bella del processo, quella da manuale della qualità. Serve invece la versione vera, comprese le scorciatoie e i fogli di appoggio. Poi si migliora: prima si guarda.

Che cosa contiene una mappa

Una mappa utile sta su una pagina e contiene sei cose.

  • L'innesco, scritto come un fatto datato: «arriva una mail all'indirizzo info», «è lunedì mattina».
  • I passi, numerati, uno per riga, ognuno che comincia con un verbo: leggere, controllare, scrivere, inviare, registrare.
  • Le decisioni, scritte come domande a risposta chiusa: «il cliente è già nostro?», con i due rami indicati.
  • I dati, per ogni passo: quale informazione serve e in quale posto sta (una casella di posta, un foglio, il gestionale, la testa di un collega).
  • Chi, perché un processo che passa da tre persone ha due attese dentro, e le attese pesano più del lavoro.
  • L'esito, con il posto dove finisce: chi lo riceve e dove resta traccia.

La forma scritta

Va benissimo un elenco numerato. Un esempio, sul processo del preventivo:

N.PassoChiDati e dove stannoMinuti
1Leggere la richiesta e capire che cosa chiedeiotesto della mail5
2Controllare se il cliente è già nostroiogestionale, scheda cliente3
3Decidere: cliente nuovo o già nostro?ioesito del passo 21
4Stimare le ore di lavoroiolavori simili passati, listino20
5Scrivere il documento sul modelloiomodello Word, dati dei passi 1 e 48
6Inviare per mailioindirizzo del cliente2
7Registrare nel foglio dei preventivi apertiiofoglio Preventivi2

Se preferisci il disegno, fai delle scatole in fila con le frecce, e un rombo dove c'è una decisione. La forma conta poco: conta che ogni riga abbia un verbo e che le decisioni siano separate dai passi.

Misurare i passi

Accanto a ogni passo servono tre numeri e una parola.

  • Minuti: quanto dura davvero quel passo. Misurali una volta con il cronometro invece di stimarli: la differenza fra stima e misura arriva spesso al doppio.
  • Attesa: quanto tempo passa prima che il passo successivo cominci. Un passo da 2 minuti con 2 giorni di attesa dopo è il vero problema di quel processo.
  • Quante volte: alcuni passi si fanno sempre, altri solo in certi casi. Segna la percentuale: «passo 4, nel 30% dei casi».
  • Tipo: una parola fra meccanico, giudizio, responsabilità. È la colonna che useremo nella Lezione 3 per decidere che cosa delegare.

Le attese non si automatizzano con l'AI

Se la mappa mostra che il grosso del tempo è attesa (il collega che risponde, il cliente che manda il documento), il guadagno sta in un promemoria automatico o in una regola concordata, non in un prompt. Il conto del tempo della Lezione 1 va rifatto su quello che l'AI può davvero toccare.

Il caso normale e le eccezioni

Ogni processo ha una strada maestra e qualche sentiero laterale. La strada maestra copre il 70 o l'80 per cento dei casi; i sentieri sono il cliente estero, l'ordine urgente, il documento che arriva come foto storta.

La regola è questa: si automatizza la strada maestra, e si scrive che cosa succede quando il caso non ci rientra. Un'automazione che gestisce tutti i casi previsti e imprevisti costa cinque volte tanto e si rompe lo stesso.

Pratica: fai un elenco a parte delle eccezioni e per ognuna decidi una delle tre cose.

  1. Resta a mano: il caso è raro, lo tratti tu come adesso. L'automazione deve accorgersene e fermarsi.
  2. Entra nella mappa: il caso capita spesso, quindi è un secondo ramo del processo e va scritto insieme agli altri passi.
  3. Si elimina a monte: il caso nasce da un modulo fatto male o da un'informazione che non chiediamo. Si corregge la causa.

La terza opzione è quella che rende di più, e di solito nessuno la considera. Metà delle eccezioni di un processo nasce dal fatto che chiediamo i dati in modo vago.

Tre errori di chi mappa per la prima volta

Passi troppo grossi. «Preparare il preventivo» è un titolo, non un passo. Se una riga dura più di dieci minuti, dentro ci sono almeno tre passi nascosti. Spezzala finché ogni riga ha un verbo e un risultato visibile.

Decisioni travestite da passi. «Valutare la richiesta» nasconde una scelta con dei criteri. Tira fuori la domanda e i criteri: sono esattamente la parte che poi dovrai spiegare all'AI, e se non riesci a scriverli non riuscirai a delegarli.

La mappa senza dati. Un elenco di passi senza la colonna «dove sta l'informazione» sembra completo e serve a poco: quando arrivi a costruire l'automazione scopri che il dato del passo 4 vive solo dentro un PDF, e devi rifare tutto.

Per approfondire

Ho scritto un pezzo più lungo sulla mappatura, con la notazione e gli esempi di reparto: Mappare i processi prima di automatizzarli. Leggilo dopo il laboratorio, così confronti la tua mappa con quelle.

Laboratorio: la mappa del tuo processo

Obiettivo: una pagina che descrive il processo scelto nella Lezione 1, con i passi misurati e le eccezioni elencate.

Consegna

  1. Scrivi l'innesco in una riga, come un fatto: che cosa succede, dove, in che forma arriva.
  2. Elenca i passi numerati, ognuno con un verbo all'inizio. Fermati quando nessuna riga dura più di dieci minuti.
  3. Segna le decisioni come domande, con i rami. Per ogni decisione scrivi il criterio con cui scegli.
  4. Aggiungi le colonne chi, dati e dove stanno, minuti, attesa, tipo (meccanico, giudizio, responsabilità).
  5. Elenca le eccezioni in una tabella a parte e assegna a ognuna una delle tre sorti: resta a mano, entra nella mappa, si elimina a monte.
  6. Fai la somma dei minuti per tipo. Quanti minuti al mese stanno nei passi meccanici? Quello è il tetto massimo di quello che puoi guadagnare.

Controllo di qualità della mappa

Passa la tua mappa a una persona che fa lo stesso lavoro, o rileggila dopo un giorno, con queste tre domande: una persona nuova riuscirebbe a eseguire il processo leggendo solo questo? Ogni decisione ha un criterio scritto? Per ogni dato so in che posto andarlo a prendere?

Risultato atteso

Una tabella con da 6 a 15 passi, ogni riga con il suo tipo e i suoi minuti, una lista di eccezioni con la loro sorte, e un numero solo in fondo: i minuti al mese che stanno nei passi meccanici. Quel numero è il bersaglio del resto del corso.

Mini-test di autoverifica

Vuoi testare le tue competenze?

Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.

Entra su HI

Riassunto della lezione

Cosa hai imparato

  • Si mappa il processo vero, con le scorciatoie dentro, invece della versione da manuale.
  • Sei elementi: innesco, passi con un verbo, decisioni con i criteri, dati e dove stanno, chi, esito.
  • Ogni passo si misura: minuti, attesa, quante volte capita, e il tipo fra meccanico, giudizio e responsabilità.
  • La strada maestra si automatizza, le eccezioni restano a mano, entrano nella mappa o si eliminano a monte.
  • I tre errori tipici: passi troppo grossi, decisioni travestite da passi, mappa senza la colonna dei dati.

Prossimi passi

Nella Lezione 3, Spezzare il processo e delegare i pezzi prendiamo la tua mappa e tagliamo: quali passi vanno all'AI, con quale prompt, e in che formato devono uscire i risultati perché il passo dopo possa usarli.

Lezione 3 di 7

Spezzare il processo e delegare i pezzi

Il tuo processo diventa una catena, e i passi che dai all'AI hanno il loro prompt, già provato su tre casi veri.

Obiettivi della lezione

Questa è la lezione centrale del corso, e il metodo è quello che chiamo divide et delega: si prende un problema grosso, lo si spezza in pezzi piccoli, e a ogni pezzo si dà un esecutore. Alcuni pezzi restano tuoi, altri li fa una formula, altri li fa un modello linguistico. Il valore sta nel taglio, prima che nel prompt.

Alla fine della lezione riesci a:

  • Classificare ogni passo della tua mappa come meccanico, di giudizio o di responsabilità;
  • Scrivere un prompt come specifica di lavoro, con le sue quattro C;
  • Imporre un formato d'uscita, che è la condizione perché due passi si possano collegare;
  • Usare gli esempi per fissare uno stile invece di descriverlo a parole;
  • Costruire una catena di prompt e capire che cosa si guadagna rispetto a un prompt unico;
  • Riconoscere quando un passo di giudizio vuole un modello che classifica invece di uno che scrive.

Tre tipi di passo

Riprendi la tua mappa e guarda la colonna «tipo». Ogni passo sta in una di queste tre categorie.

  • Meccanico: la regola è scritta e vale sempre. Copiare un dato, applicare uno sconto, mandare la mail all'indirizzo giusto, aggiungere una riga a un foglio. Questi passi li fa il software normale, con una formula o due righe di codice.
  • Di giudizio: serve capire qualcosa di scritto o di implicito. Riconoscere che cosa chiede una mail, decidere se il tono è una lamentela, riassumere, scegliere il modello di documento adatto. Qui entra l'AI generativa.
  • Di responsabilità: qualcuno ci mette la firma. Il prezzo finale, la promessa di una data, l'invio al cliente. Questi restano a una persona, anche quando l'AI ha preparato tutto.

Un processo tipico da dieci passi si divide grosso modo così: sei meccanici, tre di giudizio, uno di responsabilità. Il guadagno più grande arriva dai sei meccanici, che di solito nessuno guarda perché sembrano troppo banali per meritare attenzione.

Il passo che sembra di giudizio e non lo è

«Capire se la richiesta è urgente» sembra giudizio. Spesso, scrivendo il criterio, si scopre che l'urgenza dipende da una data scritta nel testo: allora è estrazione di un dato più un confronto fra due date, cioè un pezzo di AI e un pezzo di formula. Distinguere i due conviene, perché il confronto fra date fatto da una formula è sempre giusto.

I modelli che classificano e basta

Un passo di giudizio ha due esecutori possibili. Il primo è il modello che conosci, quello che scrive: gli chiedi se il tono di una mail è una lamentela e ti risponde con una frase, che poi devi rileggere per tirarne fuori un sì o un no. Il secondo è una famiglia di modelli che non scrivono niente: gli dai lo stato della pratica e una domanda, e ti torna indietro una risposta di tipo fisso con accanto la probabilità.

Arriva questo messaggio all'assistenza: «Il pacco è arrivato rotto, vorrei fare un reso». Per smistarlo servono tre decisioni, e sono tutte chiuse: che tono ha (negativo), in che lingua è (italiano), cosa vuole chi scrive (un reso). Con quelle tre il ticket va al gruppo dei resi da solo. Se la probabilità su una delle tre è bassa, finisce nella fila che guarda una persona.

Quelle tre domande però tornano identiche su diecimila messaggi, e lì quanto costa e quanto dura una singola decisione decide se l'automazione si può fare o resta un'idea. Un modello che scrive la risposta te la costruisce un token alla volta; uno che decide valuta le domande insieme e torna il risultato già strutturato.

Da settembre 2026 quello di cui si parla di più è Jev, di TypeSafe AI, che l'azienda chiama System One model. Accetta tre forme di domanda: choice per scegliere fra opzioni date, score per dare un voto su una scala ordinata, noul per il sì o no. Le prime due restituiscono anche la distribuzione delle probabilità e un valore di confidenza, la terza un numero fra 0 e 1.

{
  "model": "jev-latest",
  "state": "Provo da tre giorni a collegare il conto Stripe e continua a
            fallire. Sto perdendo vendite, aiutatemi subito.",
  "questions": {
    "urgente": {
      "type": "noul",
      "instructions": "Il messaggio esprime urgenza o una scadenza"
    }
  }
}
{
  "model": "jev-1.13.0",
  "answers": {
    "urgente": { "type": "noul", "noul": 0.999 }
  },
  "usage": { "input_tokens": 296, "output_tokens": 20 }
}

Si chiama POST https://api.typesafe.ai/v1/systemone, con la chiave nell'intestazione. Quello 0,999 dice che il messaggio è urgente, e il tuo codice lo usa per mettere la pratica in cima alla fila. Due cose lo rendono comodo dentro una catena. Le domande di una stessa richiesta vengono valutate in parallelo e ognuna per conto suo sullo stesso stato, quindi aggiungerne una quasi non allunga l'attesa. E la risposta arriva già come dato, senza il giro di chiedere un JSON a un modello che scrive e poi sperare che l'abbia scritto bene, che è il punto in cui le catene si rompono (lo vediamo nella Lezione 5).

Tre cose da sapere prima di andarlo a provare

Jev resta un servizio chiuso: gira sui server di TypeSafe, il modello non te lo danno, e per l'API dell'azienda c'è una lista d'attesa. Dal 18 settembre 2026 però sta anche su OpenRouter, quindi provarlo si può senza aspettare il proprio turno.

Lì c'è anche l'unico prezzo che si controlla da fuori: Jev 1.13 costa 0,042 dollari per milione di token in ingresso e zero in uscita, con 32.000 token di contesto. Zero in uscita perché di token in uscita non ce ne sono.

I numeri di velocità e risparmio invece li mette l'azienda che vende il modello: sul suo sito TypeSafe dichiara da 40 a 200 volte più veloce e 444 volte meno caro di un modello che scrive, e nella stessa pagina scrive che quei guadagni stanno sul lato alto di quelli veri. Quello che regge da sé è la struttura: un modello che non genera testo non ha token in uscita da pagare.

Dati verificati il 23 settembre 2026 su OpenRouter e sul sito di TypeSafe. Prezzi e disponibilità cambiano: prima di farci un preventivo, ricontrolla.

Lo stesso, sul tuo computer: Bivio

L'idea di Jev si può rifare con un modello aperto, e l'ho fatto: si chiama Bivio, sta su github.com/TheRealF/bivio, ed è quello che useremo nel laboratorio della Lezione 6. Gira sul tuo computer, non chiede nessuna chiave, non manda niente in rete, e parla la stessa API: un programma scritto per Jev punta su Bivio cambiando l'indirizzo di base.

pip install git+https://github.com/TheRealF/bivio
bivio scarica     # il modello, 2,5 GB
bivio serve       # http://127.0.0.1:8017/campo

Da Python la stessa domanda di prima si scrive così, e la risposta ha già il tipo giusto senza passare da nessun JSON da rileggere:

from bivio import Bivio

b = Bivio()
r = b.decidi(
    "Provo da tre giorni a collegare il conto Stripe e continua a fallire. "
    "Sto perdendo vendite, aiutatemi subito.",
    {
        "urgente": {"tipo": "si_no",
                    "istruzioni": "Il messaggio esprime urgenza o una scadenza"},
        "reparto": {"tipo": "scelta",
                    "istruzioni": "Chi deve prendere in carico la richiesta",
                    "opzioni": {"pagamenti": "Incassi, fatture, rimborsi",
                                "tecnico": "Errori e malfunzionamenti",
                                "commerciale": "Preventivi e nuovi contratti"}},
    },
)

r["urgente"].valore        # True
r["reparto"].valore        # 'tecnico'
r["reparto"].probabilita   # 0.9999

Le domande sono quattro tipi invece di tre: c'è anche numero, che torna una stima su una scala di ancore che dichiari tu («quante ore serviranno?»). E c'è l'astensione, un'opzione in più che il modello può scegliere quando lo stato non basta per rispondere: utile il giorno che vuoi un ramo «questa la guarda una persona».

Che cosa cambia davvero fra i due

Bivio è un modello aperto da quattro miliardi di parametri, quindi dichiara di essere bravo quanto Jev tanto quanto io dichiaro di correre come un centometrista. Sui trentuno casi di prova del progetto ne prende trenta, con circa 190 millisecondi a decisione su un portatile. Il vantaggio è un altro, e per imparare conta di più: ce l'hai adesso, gira senza rete, e puoi guardarci dentro.

Il prompt è una specifica di lavoro

Un prompt scritto bene somiglia alle istruzioni che daresti a una persona al primo giorno: che ruolo ha, su che materiale lavora, che cosa deve fare, in che forma deve consegnare. Quattro parti, sempre nello stesso ordine.

  1. Contesto e ruolo: chi sei tu, che azienda è, chi leggerà il risultato. Due o tre righe bastano, e servono a scegliere il registro e le parole del mestiere.
  2. Materiale in ingresso: il testo su cui lavorare, marcato in modo che si capisca dove comincia e dove finisce.
  3. Istruzione: che cosa fare, un'azione sola, scritta all'imperativo.
  4. Formato d'uscita: come deve essere fatta la risposta, campo per campo, e che cosa fare quando un'informazione manca.

Un esempio completo sul passo «estrai i dati dalla richiesta»:

Sei l'assistente di uno studio di consulenza informatica di Livorno.
Ricevi le richieste che arrivano dal modulo del sito e le prepari per
il preventivo.

Richiesta del cliente, fra i marcatori:
<<<
{testo della richiesta}
>>>

Estrai le informazioni richieste. Usa solo quello che c'e' scritto
nella richiesta: dove un dato manca scrivi "non indicato".

Rispondi solo con questa tabella, senza frasi prima o dopo:

Nome: 
Azienda: 
Contatto (mail o telefono): 
Che cosa chiede (una frase): 
Scadenza indicata: 
Budget indicato: 
Tono (neutro / urgente / scontento):

Nel prompt qui sopra ci sono tre scelte che non sono di stile. Il materiale sta fra marcatori, e questo evita che una frase del cliente venga letta come un ordine. C'è scritto che cosa fare quando un dato manca, altrimenti il modello lo inventa per riempire il buco. E l'uscita è una lista di campi fissi, sempre gli stessi.

Il formato d'uscita tiene insieme la catena

Finché lavori in chat, la forma della risposta è un gusto. Dentro un processo diventa la cosa più importante di tutto il prompt, perché l'uscita di un passo è l'ingresso del passo dopo: se cambia forma, il passo dopo si rompe.

Tre formati, in ordine di rigidità.

  • Campi con etichetta, come nell'esempio sopra. Si legge a occhio, va bene quando il risultato lo usa una persona.
  • Tabella, con le colonne dichiarate. Va bene quando il risultato finisce in un foglio.
  • JSON, quando il risultato lo legge un programma. È il formato che useremo nella Lezione 5.
Rispondi solo con un oggetto JSON valido, senza testo attorno e senza
blocco di codice, con esattamente queste chiavi:

{
  "nome": "",
  "azienda": "",
  "contatto": "",
  "richiesta": "",
  "scadenza": "",
  "budget": "",
  "tono": ""
}

Regole: tutti i valori sono stringhe; dove un dato manca il valore e'
la stringa vuota; "tono" vale solo "neutro", "urgente" o "scontento".

Guarda l'ultima riga: un campo con tre valori possibili dichiarati si può controllare con un confronto, e il passo successivo sa che cosa aspettarsi. Un campo libero dove il modello scrive «abbastanza urgente» costringe a interpretare di nuovo.

La prova del nove

Un formato d'uscita è buono se riesci a scrivere, in una frase, il controllo che dice se la risposta è valida: «deve essere un JSON con sette chiavi e il campo tono deve valere una di queste tre parole». Se non riesci a scrivere il controllo, il formato è ancora troppo vago.

Due esempi valgono dieci righe di spiegazione

Quando il risultato deve avere uno stile (il tuo modo di scrivere le mail, la lunghezza delle descrizioni prodotto, il livello di dettaglio di un riassunto), descriverlo a parole funziona male. Mostrarlo funziona bene.

Si allegano al prompt due o tre coppie ingresso e uscita, prese dal lavoro vero e corrette a mano finché sono come le vuoi.

Esempi di come scrivo io queste risposte.

Esempio 1
Richiesta: "Salve, avrei bisogno di sistemare il sito, si vede male
dal telefono. Quanto costa?"
Risposta: "Buongiorno, grazie del messaggio. Per capire che cosa
serve mi basta l'indirizzo del sito: gli do un'occhiata e le scrivo
entro domani con una stima. Se preferisce sentirci a voce, mi dica
quando la trovo."

Esempio 2
Richiesta: "Mi serve un preventivo per un gestionale entro venerdi',
budget massimo 5000 euro."
Risposta: "Buongiorno, grazie. Venerdi' e' fattibile. Per fare una
stima seria mi servono tre informazioni: quante persone lo useranno,
quali dati deve gestire e se deve parlare con programmi che avete
gia'. Con quelle le mando il preventivo entro giovedi' sera."

Adesso scrivi la risposta a questa richiesta, con lo stesso tono e
la stessa lunghezza.

Gli esempi insegnano anche quello che non dici: che saluti così, che chiedi sempre le informazioni mancanti invece di sparare un prezzo, che chiudi con un impegno datato. Tre righe di istruzioni non ci arrivano.

Catena di prompt contro prompt unico

La tentazione è scrivere un prompt lungo che fa tutto: leggi la mail, capisci che cosa vuole, controlla il listino, scrivi il preventivo, preparalo per l'invio. Funziona per una dimostrazione e si sgretola nell'uso.

Quello che si guadagna:

  • Vedi dove sbaglia. Con quattro passi separati, quando il risultato è storto sai quale passo ha fallito e correggi quello. Con un prompt unico hai una cosa sola che «ogni tanto sbaglia».
  • Controlli in mezzo. Fra un passo e l'altro puoi mettere una verifica automatica, o un visto umano, o un dato preso dal gestionale.
  • Riusi i pezzi. Il passo che estrae i dati da una mail serve anche negli altri due processi che hai in elenco.

La catena del preventivo, tagliata:

PassoChi lo faEntraEsce
1. Estrarre i dati della richiestaAItesto della mailJSON con sette campi
2. Cercare il cliente in anagraficaformula o codicecampo aziendacodice cliente oppure vuoto
3. Classificare il tipo di lavoroAIcampo richiestauna voce del listino
4. Calcolare la stimafoglio di calcolovoce di listino, oreimporto
5. Scrivere il testo di accompagnamentoAIJSON, importo, esempi di stilebozza della mail
6. Controllare e inviarepersonabozza, importomail inviata

Quando in aula arriviamo a questa tabella, la domanda che mi fanno sempre è perché il passo 4 non lo faccia l'AI insieme al resto. La risposta è che un importo si calcola: al modello lo passo già fatto, così nel testo finisce la cifra giusta. E il passo 6 resta a una persona perché lì c'è una firma.

Laboratorio: taglia e scrivi i prompt

Obiettivo: la catena del tuo processo, con i prompt dei passi delegati scritti e provati su tre casi veri.

Consegna

  1. Classifica ogni passo della mappa della Lezione 2 come meccanico, giudizio o responsabilità. Se un passo è misto, spezzalo in due.
  2. Disegna la catena in una tabella con quattro colonne: passo, chi lo fa, che cosa entra, che cosa esce. Ogni «esce» deve coincidere con l'«entra» del passo successivo.
  3. Scrivi i prompt dei passi affidati all'AI, con le quattro C: chi (ruolo), cosa fare (l'istruzione, sul materiale che metti fra marcatori), cosa non fare (fra cui la regola per i dati mancanti) e come farlo (il formato d'uscita).
  4. Prova su tre casi veri presi dal tuo archivio: uno facile, uno con un'informazione mancante, uno scritto male.
  5. Correggi il prompt dove il risultato è storto. Cambia una cosa alla volta e riprova sugli stessi tre casi, così sai se il cambiamento ha migliorato o peggiorato.
  6. Allega gli esempi ai passi in cui conta lo stile: prendi due risposte vere che hai scritto tu. Le prime quattro C si scrivono, gli esempi si allegano.

Risultato atteso

Una tabella con la catena completa, da due a quattro prompt scritti in un file di testo (con la data in cima), e per ognuno la prova sui tre casi con annotato che cosa hai corretto. Il caso scritto male è quello che insegna di più: guarda se il modello ha inventato i dati mancanti o ha scritto «non indicato» come gli avevi chiesto.

Mini-test di autoverifica

Vuoi testare le tue competenze?

Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.

Entra su HI

Riassunto della lezione

Cosa hai imparato

  • Tre tipi di passo: meccanico al software, di giudizio all'AI, di responsabilità alla persona.
  • Il prompt è una specifica: contesto e ruolo, materiale fra marcatori, istruzione, formato d'uscita.
  • Il formato d'uscita tiene insieme la catena, e si riconosce buono quando riesci a scrivere in una frase il controllo che lo valida.
  • Gli esempi insegnano lo stile meglio di qualunque descrizione, compreso quello che non hai detto.
  • Spezzare rende: vedi dove sbaglia, metti controlli in mezzo, riusi i pezzi altrove.

Prossimi passi

Nella Lezione 4, Dalla chat all'assistente prendiamo i prompt che hai scritto e li rendiamo stabili: istruzioni fisse, materiali di riferimento allegati, modelli con i buchi da riempire, e una batteria di casi con cui collaudarli.

Lezione 4 di 7

Dalla chat all'assistente che risponde sempre uguale

Ti porti a casa un assistente dedicato al tuo processo, collaudato su sei casi, che puoi usare senza correggerne il tono ogni volta.

Obiettivi della lezione

Un prompt provato tre volte in chat funziona. Lo stesso prompt usato quaranta volte al mese da due persone diverse comincia a dare risultati che ballano, perché ognuno lo incolla con qualche parola cambiata e ogni volta la conversazione porta dietro roba della volta prima.

Quando arrivi in fondo hai imparato a:

  • Separare le istruzioni fisse dal materiale che cambia a ogni giro;
  • Costruire un assistente dedicato con i suoi materiali di riferimento allegati;
  • Scrivere un modello di prompt con i buchi da riempire;
  • Collaudarlo con una batteria di casi, compreso un caso che deve fallire;
  • Tenere le versioni dei prompt in modo da poter tornare indietro.

La chat è una conversazione, il processo vuole ripetibilità

In chat le cose vanno bene per un motivo che passa inosservato: quando la risposta non ti convince, tu correggi al volo. «Più corto», «togli quella frase», «in italiano». Quel lavoro di aggiustamento è tuo, dura trenta secondi, e non è scritto da nessuna parte.

Dentro un processo quel lavoro va tolto di mezzo, per due ragioni. La prima è che se il risultato deve passare al passo successivo senza che tu lo guardi, deve essere già giusto. La seconda è che se il processo lo fa anche un collega, deve venirgli uguale.

La mossa è sempre la stessa: tutto quello che oggi correggi a voce diventa una riga scritta nelle istruzioni fisse. Per due settimane, ogni volta che correggi, segnati la correzione. Io con le mie mail ci ho messo quel tempo e sono venute fuori nove righe: quelle nove righe sono le istruzioni, il resto era contorno.

La conversazione che si porta dietro le cose

Se usi la stessa chat per venti pratiche di fila, il modello ha davanti anche le diciannove precedenti e comincia a mescolarle: nomi che tornano dove non c'entrano, un tono preso dalla pratica di prima. Per il lavoro ripetitivo si apre una conversazione nuova a ogni pratica, sempre.

Le istruzioni fisse

Le istruzioni fisse sono la parte del prompt che vale per tutte le pratiche: chi sei, come si scrive in questa azienda, che cosa non si fa mai, come deve essere fatta l'uscita. Negli strumenti di oggi hanno nomi diversi (istruzioni del progetto, istruzioni personalizzate, istruzioni di sistema) e la sostanza è identica: un testo che sta sopra a ogni conversazione senza che tu lo riscriva.

Che cosa ci va dentro:

  • Ruolo e destinatario: per chi lavori e chi leggerà.
  • Le regole di stile che oggi correggi a mano: la lunghezza, il «lei» o il «tu», le parole che non usate, la firma.
  • I limiti: che cosa fare quando manca un'informazione, quando fermarsi e chiedere, che cosa non promettere mai (sconti, date, disponibilità).
  • Il formato d'uscita di quel tipo di lavoro.

Che cosa resta fuori: il materiale della singola pratica, che cambia ogni volta e viaggia nel messaggio.

RUOLO
Assisti uno studio di consulenza informatica di Livorno, tre persone.
Prepari le bozze di risposta alle richieste che arrivano dal sito.
Le legge il titolare prima di inviarle.

STILE
Dai del lei. Frasi corte. Da 60 a 120 parole. Nessun elenco puntato
nelle mail. Chiudi sempre con un impegno che ha una data.
Non usare: soluzione su misura, innovativo, all'avanguardia.

LIMITI
Non indicare mai prezzi, date di consegna o disponibilita': quelli li
aggiunge il titolare. Se nella richiesta mancano informazioni per
capire che lavoro e', chiedile con al massimo tre domande.

USCITA
Solo il testo della mail, senza oggetto e senza firma.

La sezione LIMITI è quella che tiene in piedi il resto. Un assistente che promette una data che nessuno ha verificato fa un danno che poi paghi tu.

Un contenitore per ogni processo

Gli assistenti si tengono separati: uno per processo, con le sue istruzioni e i suoi materiali. Tutti i principali strumenti di AI generativa hanno questa cosa, sotto nomi diversi: i Progetti, gli assistenti personalizzati, gli spazi di lavoro.

Che cosa allegare

  • Il listino o il catalogo, nella versione aggiornata, con la data nel nome del file.
  • Da cinque a dieci esempi di lavoro fatto bene, scelti da te.
  • Le risposte alle domande ricorrenti, quelle che scrivi sempre uguali.
  • Il glossario dei termini vostri, se il mestiere ne ha.

Che cosa lasciare fuori

I dati personali dei clienti, i documenti coperti da riservatezza, le password. Su questo torniamo nella Lezione 7, e la regola breve è: prima di allegare un documento, chiediti se ti darebbe fastidio vederlo in mano a un fornitore esterno.

I materiali invecchiano

Un listino allegato sei mesi fa continua a essere usato con la faccia dell'informazione aggiornata. Metti la data nel nome del file e segnati sul calendario un controllo ogni tre mesi: è la manutenzione di cui parlavamo nella Lezione 1.

Il modello con i buchi da riempire

Sotto le istruzioni fisse, ogni pratica ha un messaggio che cambia. Anche quello va fissato, altrimenti ognuno lo scrive a modo suo. Si prepara un modello con i buchi segnati fra parentesi graffe, e si tiene in un file di testo, in una nota o in un'espansione di tastiera.

Richiesta arrivata il {data}, canale {modulo del sito / mail / telefono}.

Testo del cliente:
<<<
{testo}
>>>

Cliente gia' nostro: {si' / no}
Tipo di lavoro (dal listino): {voce}
Note interne: {due righe, oppure "nessuna"}

Scrivi la bozza di risposta.

Un modello fatto così fa due cose: obbliga chi lo usa a raccogliere tutte le informazioni prima di partire, e rende le pratiche confrontabili quando qualcosa va storto e devi capire perché.

Collaudare sul serio

Provare due volte e dire «funziona» è il modo più comune di mettere in strada un'automazione che poi delude. Serve una batteria di casi, scritta una volta e riusata a ogni modifica.

Sei casi bastano per cominciare:

  1. Tre casi normali, presi dall'archivio, di quelli che capitano tutte le settimane.
  2. Un caso con un'informazione mancante: deve chiedere invece di inventare.
  3. Un caso scritto male, confuso, con errori di battitura: deve capirlo lo stesso o fermarsi in modo pulito.
  4. Un caso che deve fallire: una richiesta fuori perimetro, per esempio qualcuno che chiede un lavoro che non fate. Deve dirlo, invece di inventarsi una risposta.

Per ogni caso scrivi in una riga che cosa consideri una risposta accettabile. Poi, a ogni modifica delle istruzioni, ripassi i sei casi. Ci vogliono dieci minuti e ti dice se il cambiamento ha migliorato o ha rotto qualcosa.

Una cosa alla volta

Quando cambi le istruzioni, cambia una regola sola e ripassa la batteria. Se ne cambi tre insieme e il risultato peggiora, non sai quale delle tre è stata. È lento per i primi due giri e poi diventa la cosa che ti fa risparmiare il pomeriggio.

Tenere le versioni

Le istruzioni fisse sono il pezzo che ti è costato più tempo, e stanno dentro l'interfaccia di un servizio che un giorno potresti cambiare. Tienine una copia in un file di testo, con la data in cima e due righe che dicono che cosa è cambiato rispetto alla versione prima.

2026-09-21 v3
Aggiunta la riga sui prezzi nei LIMITI, dopo la bozza che prometteva
uno sconto del 10% che nessuno aveva autorizzato.

2026-09-14 v2
Portata la lunghezza da 150 a 120 parole. Tolte le parole vietate.

2026-09-08 v1
Prima versione.

Serve a tre cose: tornare indietro quando una modifica peggiora il risultato, capire dopo tre mesi perché c'è quella regola strana, e portarsi il lavoro su un altro strumento senza ricominciare.

Laboratorio: costruisci il tuo assistente

Obiettivo: un assistente dedicato al tuo processo, con istruzioni fisse, materiali allegati, un modello di messaggio e una batteria di sei casi superata.

Consegna

  1. Crea il contenitore nello strumento che usi e chiamalo con il nome del processo.
  2. Scrivi le istruzioni fisse con le quattro sezioni: ruolo, stile, limiti, uscita. Parti dai prompt della Lezione 3 e sposta lì dentro tutto quello che vale sempre.
  3. Allega i materiali: listino con la data nel nome, da cinque a dieci esempi di lavoro fatto bene, le risposte ricorrenti.
  4. Prepara il modello di messaggio con i buchi fra parentesi graffe e salvalo dove lo ritrovi in due secondi.
  5. Scrivi la batteria: sei casi presi dall'archivio, ognuno con una riga che dice che cosa è accettabile.
  6. Passa la batteria. Dove fallisce, aggiungi una riga alle istruzioni, cambiando una cosa sola, e ripassa tutti e sei.
  7. Salva la versione in un file di testo con la data.

Risultato atteso

Un assistente che, dati gli stessi sei casi in giorni diversi, produce risultati che puoi usare senza correggere il tono e senza togliere frasi. Il caso fuori perimetro deve dire che è fuori perimetro: se inventa una risposta, alle istruzioni manca ancora una riga.

Mini-test di autoverifica

Vuoi testare le tue competenze?

Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.

Entra su HI

Riassunto della lezione

Cosa hai imparato

  • Quello che correggi a voce diventa una riga scritta nelle istruzioni fisse.
  • Un contenitore per processo, con istruzioni e materiali di riferimento allegati e datati.
  • Quattro sezioni: ruolo, stile, limiti, uscita. La sezione limiti è quella che evita i danni.
  • Il modello con i buchi obbliga a raccogliere le informazioni prima di partire.
  • Sei casi di collaudo, compreso uno che deve fallire, ripassati a ogni modifica, una modifica alla volta.

Prossimi passi

Nella Lezione 5, Collegare i pezzi facciamo partire la catena da sola: inneschi, azioni, gli strumenti che collegano i servizi fra loro, e dove entra l'AI dentro una catena che gira senza di te.

Lezione 5 di 7

Collegare i pezzi: l'automazione che parte da sola

Una parte del tuo processo comincia a girare senza di te, con un controllo che ferma la pratica quando qualcosa non torna.

Obiettivi della lezione

Fino a qui la catena la fai partire tu: apri l'assistente, incolli, copi il risultato, lo porti dove serve. Funziona, e vale già una parte del risparmio. Adesso togliamo anche quel copia e incolla, che nei processi frequenti è la metà del tempo rimasto.

Alla fine sei capace di:

  • Descrivere qualunque automazione nella forma innesco e azioni;
  • Scegliere lo strumento adatto fra quelli visuali, i fogli e il codice;
  • Capire che cosa sono API e webhook, quanto basta per leggerne la documentazione;
  • Inserire un passo di AI dentro una catena automatica e maneggiarne l'uscita;
  • Riconoscere quando serve un agente e perché un agente vuole un cancello umano.

Innesco e azioni, sempre la stessa forma

Qualunque automazione, con qualunque strumento, ha questa forma: quando succede una cosa, fai queste altre cose in fila. Cambia il vestito, la sostanza no.

Gli inneschi si contano sulle dita:

  • Arriva qualcosa: una mail, un messaggio, un file in una cartella, una risposta a un modulo.
  • Cambia qualcosa: una riga nuova in un foglio, uno stato che passa da aperto a chiuso.
  • È ora: ogni lunedì alle otto, ogni primo del mese.
  • Qualcuno preme: un pulsante, un comando, una chiamata da un altro programma.

Le azioni sono altrettanto poche: leggere un dato, trasformarlo, scriverlo da qualche parte, mandare un messaggio, decidere fra due strade. Un passo di AI è un'azione di trasformazione come le altre: entra testo, esce testo.

Scrivi la frase prima di aprire lo strumento

«Quando arriva una mail all'indirizzo info, estrai i sette campi, aggiungi una riga al foglio Richieste e mandami un avviso se il tono è scontento». Se riesci a scrivere questa frase, il resto è montaggio. Se non ci riesci, torna alla mappa della Lezione 2.

Con che cosa si collega

Tre famiglie, e si sceglie in base a dove stanno già i tuoi dati.

FamigliaEsempiQuando conviene
Strumenti visualiZapier, Make, n8n, Power AutomateDevi collegare servizi diversi fra loro e non vuoi scrivere codice
Dentro la suiteGoogle Apps Script, le macro di OfficeI dati stanno già nei fogli e nella posta della stessa suite
CodicePython, un piccolo servizio tuoServe una logica che gli strumenti visuali rendono contorta, o i volumi sono alti

Due avvertenze pratiche. La prima: gli strumenti visuali si pagano a operazione, quindi un processo che gira mille volte al mese cambia di prezzo rispetto a uno che gira cinquanta volte. La seconda: n8n si può installare su un proprio server, che è la strada di chi ha dati che preferisce tenere in casa.

E una terza strada, che in aula stupisce sempre: a volte basta una cartella condivisa con dentro un modello e una convenzione sui nomi dei file. Mi è capitato di arrivare con l'idea di collegare tre servizi e di uscire con una cartella e due regole scritte, che dopo un anno funzionavano ancora. Prima di montare cinque servizi, guarda se il problema si scioglie così.

API e webhook, spiegati corti

Un'API è la porta di servizio di un programma: un indirizzo a cui mandi una richiesta scritta in un formato prestabilito e che ti risponde con dei dati, di solito in JSON. Quando in uno strumento visuale scegli l'azione «aggiungi riga al foglio», dietro c'è una chiamata a un'API, con la differenza che l'hanno già scritta per te.

Un webhook è la stessa cosa al contrario: dai a un servizio un tuo indirizzo, e lui ti chiama quando succede qualcosa. Il modulo del sito che avvisa la tua automazione appena qualcuno lo compila funziona così. Il vantaggio è che nessuno deve stare a controllare ogni cinque minuti se è arrivato qualcosa.

Tre parole che ti servono leggendo qualunque documentazione:

  • Chiave (o token): la password del programma che chiama. Si tiene fuori dai file che condividi, nelle impostazioni del servizio.
  • Endpoint: l'indirizzo preciso della funzione che vuoi usare.
  • Limite di chiamate: quante richieste al minuto ti concedono. Superarlo fa fallire i passi, in silenzio.

Il passo di AI dentro la catena

Dentro un'automazione, rispetto alla chat, cambiano tre cose, e sono le tre che fanno fallire i primi tentativi.

Nessuno guarda la risposta. Quindi il formato d'uscita della Lezione 3 diventa obbligatorio, e in JSON: il nodo dopo deve poter prendere il campo che gli serve.

Il modello ogni tanto aggiunge frasi di cortesia. «Ecco il JSON richiesto:» davanti all'oggetto manda in errore la lettura. Si previene con l'istruzione esplicita («rispondi solo con l'oggetto JSON, senza testo attorno e senza blocco di codice») e si sopravvive con un controllo che, se la lettura fallisce, ferma la pratica e avvisa.

Ogni chiamata parte da zero. Il contesto che in chat era nella conversazione qui va messo nel messaggio: le istruzioni fisse della Lezione 4 vanno incollate nel nodo.

function elaboraRichieste() {
  const etichetta = GmailApp.getUserLabelByName('da-elaborare');
  const foglio = SpreadsheetApp.getActive().getSheetByName('Richieste');

  etichetta.getThreads(0, 10).forEach(function (thread) {
    const messaggio = thread.getMessages()[0];
    const dati = estraiConAI(messaggio.getPlainBody());
    if (!dati) return;                       // lettura fallita: si lascia li'
    foglio.appendRow([
      new Date(), dati.nome, dati.azienda, dati.contatto,
      dati.richiesta, dati.scadenza, dati.tono
    ]);
    thread.removeLabel(etichetta);
  });
}

Quindici righe, e fanno il grosso del lavoro di copia e incolla di un mese. La funzione estraiConAI è la chiamata al modello con il prompt della Lezione 3: prende il testo, restituisce un oggetto con i campi, oppure niente quando la risposta non si riesce a leggere.

Guarda l'ultima riga del ciclo: l'etichetta si toglie dopo che la riga è stata scritta. Se qualcosa fallisce prima, la mail resta etichettata e al giro successivo ci riprova. È il modo più economico di non perdere pratiche per strada.

La chiave non si scrive nel codice

Una chiave API scritta dentro un file che poi finisce condiviso è una chiave pubblicata, e chi la trova la usa a spese tue. Si tiene nelle proprietà dello script o nelle variabili d'ambiente, e si revoca quando non serve più.

Quando si parla di agenti

In una catena come quella qui sopra, il modello risponde e basta: il giro delle azioni l'hai deciso tu, passo per passo. Si parla di agente quando al modello dai degli strumenti (leggere una casella, scrivere in un foglio, cercare sul web) e lasci che sia lui a decidere quale usare e in che ordine, finché l'obiettivo è raggiunto.

Il modo standard di dare strumenti a un assistente si chiama MCP, ed è il protocollo con cui un'applicazione espone le proprie funzioni a un modello. In pratica: colleghi il tuo gestionale e poi puoi chiedere a parole di fare le cose che il gestionale sa fare.

La differenza pratica fra catena e agente si vede in due situazioni.

  • Il processo è sempre uguale: conviene la catena. È prevedibile, si collauda, costa poco.
  • Il percorso cambia ogni volta a seconda di quello che si trova: qui l'agente ha senso, perché scrivere tutti i rami sarebbe infinito.

Con gli strumenti in mano, però, un errore smette di essere una frase sbagliata e diventa un'azione sbagliata: una mail partita, una riga cancellata. Per questo un agente che può scrivere fuori vuole un cancello: le azioni che modificano qualcosa passano da un visto, almeno finché non hai qualche settimana di storico che ti dice che si comporta bene.

Il cancello, fatto fare a un classificatore

Il visto su ogni azione regge finché le azioni sono dieci al giorno. Gli strumenti di programmazione con l'AI hanno preso un'altra strada: prima che una chiamata parta, un secondo modello guarda che cosa sta per fare e la ferma se tocca qualcosa di serio. Passa il comando che legge un file, si ferma quello che cancella, manda o paga.

Con un classificatore come Jev, quello della Lezione 3, il cancello si monta anche fuori da quegli strumenti. In LangChain è un pezzo di mezzo da aggiungere all'agente, e sono tre righe:

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import AutoModeMiddleware

guardrail = AutoModeMiddleware(tools=["bash"])
agent = create_agent("anthropic:claude-opus-5", middleware=[guardrail])

Lo stesso pezzo sa anche scegliere il modello: una domanda sul primo messaggio («è una ricerca semplice o un lavoro di architettura?») manda la richiesta al modello economico oppure a quello capace, e la probabilità con la sua confidenza restano leggibili nello stato dell'agente. Il pacchetto si chiama langchain-typesafe e vuole la sua chiave in TYPESAFE_API_KEY, fuori dal codice come tutte le altre.

Jev però è un servizio chiuso in lista d'attesa, quindi lo stesso cancello lo faccio girare con Bivio, la versione locale che trovi nella Lezione 3. Cambia che il modello sta sul tuo computer, quindi il comando che sta per partire non esce di casa:

from bivio import Bivio

guardia = Bivio()

def si_puo_fare(azione):
    r = guardia.decidi(azione, {
        "scrive": {"tipo": "si_no",
                   "istruzioni": "L'operazione modifica o cancella dati gia' esistenti"},
        "esce_dati": {"tipo": "si_no",
                      "istruzioni": "L'operazione manda dati fuori dall'organizzazione"},
    })
    return not (r["scrive"].valore or r["esce_dati"].valore)

si_puo_fare("SELECT nome FROM clienti WHERE citta = 'Livorno'")   # True
si_puo_fare("DELETE FROM ordini WHERE anno < 2024")               # False

La domanda costa un decimo di secondo e non si paga a token, quindi un cancello così si può mettere davanti a ogni chiamata invece che davanti a quelle che ti ricordi. L'esempio completo, con sei comandi da provare, sta in esempi/cancello_agente.py dentro al progetto.

Se non programmi, tieni l'idea e chiedila a chi vi costruisce le automazioni: un cancello automatico davanti alle azioni costa poco e vale molto il giorno che un agente decide di cancellare la cartella sbagliata.

Laboratorio: la tua prima catena che parte da sola

Obiettivo: un'automazione che gira senza di te su un pezzo del tuo processo, con un punto di controllo.

Consegna

  1. Scrivi la frase innesco e azioni del pezzo che vuoi automatizzare. Un pezzo solo: il più meccanico della catena della Lezione 3.
  2. Scegli lo strumento guardando dove stanno i dati: dentro la suite che usi già, oppure uno strumento visuale se i servizi sono di fornitori diversi.
  3. Monta l'innesco e verificalo da solo: quando arriva la cosa, la catena deve partire. Provalo prima di aggiungere il resto.
  4. Aggiungi il nodo di AI con il prompt della Lezione 3, uscita in JSON, istruzione esplicita di rispondere senza testo attorno.
  5. Aggiungi il controllo: se la lettura del JSON fallisce o un campo obbligatorio è vuoto, la pratica si ferma e ti arriva un avviso.
  6. Aggiungi l'azione finale: la riga nel foglio, il file nella cartella, la bozza salvata.
  7. Provala su dieci casi veri e tieni il conto: quanti sono passati puliti, quanti si sono fermati, quanti sono passati con un errore che non ha fermato niente. L'ultima colonna è quella che conta.

Risultato atteso

Una catena che gira da sola su dieci casi, con almeno un caso che si è fermato in modo pulito avvisandoti. Se su dieci casi non si è fermata mai, provane uno rotto apposta (una mail vuota, un allegato al posto del testo): un'automazione che non sa fermarsi è una che un giorno scrive dati sbagliati senza dirlo.

Mini-test di autoverifica

Vuoi testare le tue competenze?

Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.

Entra su HI

Riassunto della lezione

Cosa hai imparato

  • Innesco e azioni: la forma di ogni automazione, da scrivere in una frase prima di aprire qualunque strumento.
  • Tre famiglie di strumenti: visuali, dentro la suite, codice. Si sceglie in base a dove stanno i dati.
  • API e webhook: la porta di servizio di un programma e la chiamata che arriva da sola quando succede qualcosa.
  • Il nodo di AI in catena vuole uscita in JSON, istruzione di rispondere senza testo attorno, e un controllo che fermi la pratica quando la lettura fallisce.
  • L'agente sceglie da sé quali strumenti usare, quindi le azioni che modificano qualcosa passano da un visto.

Prossimi passi

Nella Lezione 6, Esempio pratico: far giocare l'AI al posto tuo mettiamo in fila tutto quello che hai imparato su una cosa piccola e senza conseguenze: un gioco a turni, giocato da un classificatore. È il giro degli agenti visto per intero in una schermata.

Lezione 6 di 7

Esempio pratico: far giocare l'AI al posto tuo

Un videogioco a turni giocato dall'AI al posto tuo: si fotografa lo stato, si fanno tre domande, si esegue la mossa, si ricomincia. Poi lo stesso giro lo porti sul lavoro.

Obiettivi della lezione

Questa lezione è una parentesi, e conviene saperlo prima di cominciare: il tuo processo resta dov'è, lo riprendiamo nella Lezione 7. Qui il metodo delle cinque lezioni di prima lo guardi girare per intero su un gioco, dove a ogni turno vedi subito se la decisione era buona.

Alla fine di questa lezione sai:

  • Fotografare uno stato e passarlo a un modello che decide;
  • Scrivere le tre forme di domanda di un classificatore con i loro criteri;
  • Costruire il giro: leggi lo stato, chiedi, esegui, ricomincia (il gioco te lo do scritto);
  • Tenere i conti dentro al gioco e lasciare al modello la sola scelta;
  • Mettere il cancello sulla confidenza, e portare tutto questo sul tuo lavoro.

Perché si comincia da un gioco

Un gioco a turni ha le tre cose che un processo di lavoro fatica a darti tutte insieme. Le regole sono scritte, quindi sai sempre quali mosse esistono. Lo stato sta in una riga, perché la partita è fatta di pochi numeri. E soprattutto una mossa sbagliata non fa danni: il caso peggiore è che perdi la partita e ne cominci un'altra.

Al lavoro nessuna delle tre è vera all'inizio: le regole stanno nella testa delle persone (Lezione 2), lo stato è sparso fra una casella di posta e tre fogli, e una mossa sbagliata arriva a un cliente.

C'è anche una ragione tecnica. Una partita a turni fa una domanda al modello ogni turno, e una partita ne dura trenta. Con un modello che scrive staresti a guardare una rotellina e pagheresti trenta risposte lunghe per ottenere trenta parole. Con un classificatore la domanda è una sola chiamata che torna un'etichetta, quindi questo laboratorio si può fare stasera.

Il gioco: la grotta

Serve un gioco abbastanza semplice da tenerlo in una schermata e abbastanza cattivo da rendere la scelta interessante.

  • Hai 100 di vita, due pozioni da 30 e un colpo forte che dopo l'uso si ricarica in due turni.
  • Il mostro ha 120 di vita e a ogni turno ti toglie da 8 a 20, tirato a caso.
  • Ogni turno scegli una fra quattro mosse: attacca, colpo forte, pozione, fuggi.
  • Scappando tieni le monete raccolte. Morendo le perdi tutte.

La scelta è interessante perché nessuna mossa è sempre giusta. Il colpo forte rende molto e ti lascia scoperto due turni. La pozione ti salva e regala un turno al mostro. Fuggire è la mossa che nessuno ricorda di avere, e spesso è quella che porta a casa la serata.

Il gioco te lo do già scritto: sono cinquanta righe di Python senza niente da installare, le copi in un file e girano.

Il codice della grotta, da copiare in grotta.py
import random

MOSSE = ["attacca", "colpo_forte", "pozione", "fuggi"]

class Eroe:
    def __init__(self):
        self.vita, self.pozioni, self.ricarica = 100, 2, 0
        self.monete, self.turno, self.fuggito = 0, 1, False

class Mostro:
    def __init__(self):
        self.nome, self.vita = "Ombra della grotta", 120
    def colpisci(self, eroe):
        eroe.vita -= random.randint(8, 20)

def fotografia(eroe, mostro):
    forte = "pronto" if eroe.ricarica == 0 else "fra %d turni" % eroe.ricarica
    return ("Turno %d. "
            "Eroe: vita %d su 100, pozioni %d (curano 30). "
            "Colpo forte: %s. "
            "Mostro: %s, vita %d su 120, toglie da 8 a 20 a turno. "
            "Monete raccolte: %d, si perdono morendo."
            % (eroe.turno, eroe.vita, eroe.pozioni, forte,
               mostro.nome, mostro.vita, eroe.monete))

def esegui(mossa, eroe, mostro):
    # ⚠️ Una mossa impossibile (colpo forte in ricarica, pozione finita)
    #    brucia il turno. È una conseguenza vera: chi decide deve leggere lo stato.
    if mossa == "attacca":
        mostro.vita -= random.randint(6, 10); eroe.monete += 5
    elif mossa == "colpo_forte" and eroe.ricarica == 0:
        mostro.vita -= random.randint(18, 24); eroe.ricarica = 3; eroe.monete += 5
    elif mossa == "pozione" and eroe.pozioni > 0:
        eroe.pozioni -= 1; eroe.vita = min(100, eroe.vita + 30)
    elif mossa == "fuggi":
        eroe.fuggito = True

def esito(eroe, mostro):
    if eroe.vita <= 0:  return ("morto", 0)
    if eroe.fuggito:    return ("fuggito", eroe.monete)
    return ("vinto", eroe.monete + 50)

def gioca(scegli):
    """`scegli(stato, eroe, mostro)` restituisce una delle MOSSE."""
    eroe, mostro = Eroe(), Mostro()
    while eroe.vita > 0 and mostro.vita > 0 and not eroe.fuggito:
        esegui(scegli(fotografia(eroe, mostro), eroe, mostro), eroe, mostro)
        if mostro.vita > 0 and not eroe.fuggito:
            mostro.colpisci(eroe)
        if eroe.ricarica: eroe.ricarica -= 1
        eroe.turno += 1
        if eroe.turno > 60: break          # salvagente contro le partite infinite
    return esito(eroe, mostro)

Tutto quello che cambia da un giocatore all'altro sta in una funzione sola, scegli, che riceve la fotografia e restituisce una parola. I due metri di paragone sono tre righe:

a_caso = lambda stato, eroe, mostro: random.choice(MOSSE)

def tre_if(stato, eroe, mostro):
    # la strategia che scriveresti tu in due minuti
    if eroe.vita <= 30 and eroe.pozioni: return "pozione"
    if eroe.vita <= 15:                  return "fuggi"
    if eroe.ricarica == 0:               return "colpo_forte"
    return "attacca"

Questi due leggono i numeri dagli oggetti e la fotografia la ignorano: il testo serve a chi decide leggendo. Scrivi tre_if come ti pare, l'importante è che sia la tua strategia. È il giocatore da battere, e non è un fantoccio: con queste quattro righe la grotta si vince spesso.

Fotografare lo stato

Un classificatore guarda uno stato e risponde a delle domande su quello stato. Il primo pezzo è quindi la funzione che fotografa la partita e la mette in una riga leggibile, e nel file della grotta c'è già.

def fotografia(eroe, mostro):
    forte = "pronto" if eroe.ricarica == 0 else "fra %d turni" % eroe.ricarica
    return (
        "Turno %d. "
        "Eroe: vita %d su 100, pozioni %d (curano 30). "
        "Colpo forte: %s. "
        "Mostro: %s, vita %d su 120, toglie da 8 a 20 a turno. "
        "Monete raccolte: %d, si perdono morendo."
        % (eroe.turno, eroe.vita, eroe.pozioni, forte,
           mostro.nome, mostro.vita, eroe.monete)
    )

Due scelte dentro a queste poche righe, e sono le stesse che farai sul lavoro.

Si manda lo stato di adesso, non la storia della partita. La tentazione è allegare tutti i turni precedenti. In un gioco a turni il presente contiene già tutto quello che conta, e la cronologia allunga la richiesta senza aggiungere niente. È la stessa ragione per cui nella Lezione 4 si apre una conversazione nuova a ogni pratica.

Nello stato ci vanno anche le regole che servono a scegliere: che le pozioni curano 30, che il mostro toglie da 8 a 20, che le monete si perdono morendo. Senza questi numeri la domanda «conviene bere?» non ha una risposta, e il modello indovina.

Le tre domande, in una chiamata sola

Adesso la parte che decide. Sullo stesso stato faccio tre domande di tipo diverso: quale mossa (scelta), quanto sono in pericolo (si_no), quanto è dura questa partita (voto). Lo stato viene letto una volta sola e le tre domande si appoggiano a quella lettura, quindi aspettare le tre insieme è quasi come aspettarne una.

Il classificatore è Bivio, quello della Lezione 3. Se non l'hai ancora installato sono due comandi.

pip install git+https://github.com/TheRealF/bivio
bivio scarica     # il modello, 2,5 GB
from bivio import Bivio

cervello = Bivio()          # il modello si carica una volta, poi resta in memoria

DOMANDE = {
    "mossa": {
        "tipo": "scelta",
        "istruzioni": "Quale mossa conviene giocare in questo turno",
        "opzioni": {
            "attacca": "Colpo normale, toglie da 6 a 10, sempre disponibile",
            "colpo_forte": "Toglie da 18 a 24, poi tre turni di ricarica",
            "pozione": "Recupera 30 di vita e regala un turno al mostro",
            "fuggi": "Esci vivo dalla grotta e tieni le monete gia' raccolte",
        },
    },
    "pericolo": {
        "tipo": "si_no",
        "istruzioni": "Il mostro puo' uccidermi entro i prossimi due turni",
    },
    "durezza": {
        "tipo": "voto",
        "istruzioni": "Quanto e' messa male questa partita",
        "livelli": ["Sotto controllo", "In bilico", "Persa"],
    },
}

def decidi(stato):
    return cervello.decidi(stato, DOMANDE)

Il campo che fa il lavoro vero è opzioni (in Jev si chiama criteria, ed è la stessa cosa). Quelle descrizioni sono il regolamento che il modello legge: se scrivi «pozione: cura» e basta, la berrà anche a vita piena. Per il voto è l'elenco ordinato dei livelli, dal più basso al più alto. Le opzioni arrivano a 26, che per un gioco a turni sono molte più del necessario.

r = decidi(stato)

r["mossa"].valore           # 'pozione'
r["mossa"].probabilita      # 0.86
r["mossa"].distribuzione    # {'attacca': 0.07, 'colpo_forte': 0.02,
                            #  'pozione': 0.86, 'fuggi': 0.05}
r["mossa"].confidenza       # 0.79

r["pericolo"].valore        # True
r["pericolo"].probabilita   # 0.91

r["durezza"].valore         # 1.4   il voto come media pesata sui tre livelli
r["durezza"].dispersione    # 0.57  quanto il modello era combattuto

Guarda che cosa ti torna oltre alla mossa. La distribuzione dice quanto la scelta era combattuta: 0,86 contro 0,07 è una decisione netta, 0,44 contro 0,41 è una moneta lanciata. La confidenza è il numero su cui monteremo il cancello. E durezza a 1,4 su una scala di tre livelli è l'informazione che in una chat avresti dovuto leggere in un paragrafo.

La stessa cosa contro Jev

Bivio risponde anche sulla porta di Jev: POST /v1/systemone, con noul, choice e score e gli stessi nomi di campo della Lezione 3. Quindi il codice che scrivi qui, il giorno che ti arriva l'accesso a Jev, cambia l'indirizzo di base e basta. Vale anche al contrario: una cosa scritta per Jev la provi in locale senza pagare niente.

Il giro

Il giro ce l'hai già: è la funzione gioca del gioco. Quello che manca è il terzo giocatore, e sono otto righe.

def con_bivio(stato, eroe, mostro):
    r = decidi(stato)
    mossa = r["mossa"].valore

    # il cancello: se la scelta e' combattuta si gioca quella che non fa danni
    if r["mossa"].confidenza < 0.6:
        mossa = "attacca"

    return mossa

print(gioca(a_caso), gioca(tre_if), gioca(con_bivio))

È il giro degli agenti della Lezione 5, scritto per esteso: leggi lo stato, chiedi una decisione, esegui, ricomincia finché il compito non è finito. Cambia che qui lo vedi tutto in una schermata, e che i tre giocatori si scambiano cambiando una parola.

Se non vuoi installare niente

Bivio si scarica 2,5 GB di modello, e su una connessione lenta o su un computer prestato non è sempre la strada. In quel caso il laboratorio si fa lo stesso con l'assistente che usi tutti i giorni. La funzione da scrivere è la stessa, con dentro un'altra cosa:

import json

def con_assistente(stato, eroe, mostro):
    risposta = chiedi_al_modello(               # la tua chiamata, quella che hai gia'
        "Scegli una mossa fra: attacca, colpo_forte, pozione, fuggi.\n"
        "Rispondi solo con {\"mossa\": \"...\"}, senza testo attorno.\n\n" + stato)
    try:
        return json.loads(risposta)["mossa"]
    except (ValueError, KeyError):
        return "attacca"        # la lettura e' fallita: mossa che non fa danni

Cambiano tre cose, e sono le tre della Lezione 5. Va più piano, perché una risposta scritta si aspetta. Costa di più, perché paghi dei token per ottenere una parola. E soprattutto non hai la confidenza, quindi il cancello non lo puoi mettere sulla certezza della scelta: ti resta il try, che è un cancello sulla forma della risposta invece che sul merito.

Quello che il modello non tocca

La riga con il commento è la più importante del file. esegui() fa i conti: sottrae la vita, tira i danni, scala le pozioni, gestisce la ricarica. Al modello resta la sola scelta fra quattro parole.

È la regola della Lezione 1 vista in azione. Se lasciassi calcolare i danni al modello, ogni tanto il mostro perderebbe 14 di vita invece di 9 e nessuno se ne accorgerebbe, perché 14 è un numero plausibile.

Lo stesso vale per le regole già scritte. «Se la vita è sotto 15 e ho una pozione, bevo» è una regola: si scrive con un if, costa zero e non sbaglia mai. Il modello si guadagna il posto dove la scelta dipende da cinque cose insieme, che è il caso di tutti gli altri turni.

Le mosse impossibili non gliele offriamo

Questa l'ho imparata facendo girare il laboratorio.

La prima versione offriva al modello tutte e quattro le mosse a ogni turno. Sceglieva il colpo forte anche mentre era in ricarica, cioè bruciava il turno senza fare danni, e moriva in tutte le partite. Leggeva nello stato che il colpo forte era «fra 2 turni» e lo sceglieva lo stesso, perché nella descrizione c'era scritto che toglie da 18 a 24 ed è il numero più grande della lista.

La correzione è una funzione di sei righe che costruisce l'elenco delle opzioni guardando lo stato:

def legali(eroe):
    mosse = ["attacca"]
    if eroe.ricarica == 0:  mosse.append("colpo_forte")
    if eroe.pozioni > 0:    mosse.append("pozione")
    mosse.append("fuggi")
    return {m: DESCRIZIONI[m] for m in mosse}

# e nella domanda, al posto dell'elenco fisso:
"opzioni": legali(eroe)

Con questa riga sola il giocatore passa da morire in ogni partita a vincerne tre su quattro. Quale mossa sia possibile è un passo meccanico: la regola è scritta e vale sempre, quindi lo fa il codice. Quale mossa sia conveniente è un passo di giudizio, e resta al modello. È la tabella della Lezione 3 applicata a una riga di codice.

Dove ti ricapita, sul lavoro

Ogni volta che dai a un modello un elenco di scelte, guarda se in quel momento sono tutte davvero possibili. Il reparto che è in ferie, il modello di documento che per quel cliente non si usa, lo sconto che sopra i mille euro non si applica: se glieli offri lui ogni tanto li prende, e tu hai speso una decisione per farti dare una risposta che il tuo gestionale sapeva già che era sbagliata.

La prova che conviene fare

Prima di chiamare il modello, gioca cento partite con a_caso e cento con tre_if. Non costano niente e girano in un secondo: sono i due metri di paragone. Se il classificatore non batte i tre if, il problema sta nelle descrizioni dentro a opzioni, e si lavora lì.

Il cancello, anche in un gioco

La riga confidence < 0.6 è il cancello della Lezione 5, in miniatura. Quando la scelta è combattuta, il programma gioca la mossa che non può far male invece di fidarsi.

Nel gioco puoi spingerla oltre, e ti consiglio di provarci: la mossa che spende una risorsa che non torna (l'ultima pozione, il colpo forte) la fai passare solo sopra una confidenza alta. Vedrai le partite cambiare forma. La soglia è il tuo unico bottone: alzandola il programma gioca prudente e vince meno, abbassandola diventa spavaldo e muore.

Quel bottone al lavoro si chiama in un altro modo, e lo vediamo nella Lezione 7: sotto soglia la pratica si ferma e chiama una persona.

Misurare, che qui è gratis

Il bello di un gioco è che il punteggio esiste già. I due giocatori che non chiamano nessuno fanno cento partite, quelli che chiamano un modello ne fanno venti: bastano a vedere la differenza e non ti fanno passare la serata ad aspettare. Riempi questa tabella.

GiocatorePartite vinteMonete medieTurni mediChiamate per partita
A caso0
Tre if scritti da te0
Classificatoreuno per turno
Classificatore con il cancellouno per turno

I numeri non te li scrivo io: dipendono dalle descrizioni che metti in opzioni, che sono la tua parte del lavoro. Quello che ti interessa guardare è la colonna delle monete medie insieme a quella delle vittorie, perché un giocatore che scappa sempre vince poco e porta a casa parecchio, ed è una strategia.

Quello che è venuto a me

Questi sono i miei numeri, con Bivio su un portatile, seme fisso, quaranta partite per riga. Servono per darti un ordine di grandezza e per farti vedere due cose che non ti aspetti.

GiocatorePartiteVinteFuggiteMorteMonete medie
A caso1000%94%6%6,2
Quattro righe di if10063%35%2%74,3
Bivio, tutte le mosse sempre offerte400%0%100%0,0
Bivio, solo le mosse legali4075%2%22%72,6
Bivio legali, più una regola sul «pericolo»400%75%25%21,1

La prima sorpresa è la terza riga contro la quarta, ed è quella del paragrafo sulle mosse legali. La seconda è l'ultima riga: ci avevo messo sopra una regola scritta a mano («se il modello dice che sono in pericolo, bevo o scappo») e ha peggiorato tutto, perché quel sì/no dice sì quasi sempre. Una risposta non tarata, usata come se fosse tarata, fa più danni che non usarla.

E il confronto con le quattro righe di if finisce in pareggio: il classificatore vince più partite e porta a casa qualche moneta in meno. Il gioco serve a farti vedere come si delega una decisione senza rompere niente.

Conta anche le chiamate

L'ultima colonna è quella che si dimentica. Una partita da trenta turni fa trenta chiamate, quindi venti partite ne fanno seicento: su un classificatore è un esperimento da fare a cuor leggero, con un modello che scrive è una sera e un conto da guardare. Se stai usando l'assistente del piano B, bastano cinque partite. Con Bivio le chiamate non si pagano e restano sul tuo computer, quindi il limite è solo il tempo: una partita sono circa sei secondi su un portatile recente. Le misure di velocità e costo di TypeSafe stanno nella Lezione 3, con il loro cartellino di chi le dichiara.

Lo stesso giro, al posto tuo, sul lavoro

Se l'AI sa giocare al posto tuo, sa anche lavorare al posto tuo: è lo stesso identico giro con altri nomi.

Nella grottaNel tuo lavoro
Il turno che cominciaLa richiesta che arriva (l'innesco della Lezione 2)
La fotografia della partitaLo stato della pratica: chi scrive, che cosa chiede, che cosa sappiamo già
Le quattro mosseI passi che hai in mappa: rispondere, smistare, chiedere un dato, passare a una persona
Le descrizioni in opzioniI criteri delle decisioni, quelli che nella Lezione 2 hai dovuto scrivere
I conti dentro esegui()Gli importi, le date, le scadenze: al foglio e al gestionale
La soglia di confidenzaIl punto in cui la pratica si ferma e chiama te
Monete e partite vinteMinuti risparmiati e pratiche passate pulite (Lezione 7)

Una differenza c'è, ed è tutta la Lezione 7. Nella grotta la mossa sbagliata ti fa perdere delle monete finte. Sul lavoro parte una mail a un cliente vero, e da quel momento il cancello smette di essere un'idea carina e diventa la ragione per cui puoi lasciare che il giro vada da solo.

Laboratorio: fai giocare l'AI

Obiettivo: una partita giocata da un classificatore, con il cancello acceso e la tabella delle misure riempita.

Consegna

  1. Copia la grotta in grotta.py dal blocco qui sopra. Non c'è niente da installare. Se preferisci partire da qualcosa che già gira, il file finito con tutti i giocatori sta in esempi/grotta.py.
  2. Fai giocare a_caso per cento partite e segna la riga della tabella. È il tuo pavimento.
  3. Riscrivi tre_if con la tua strategia (per esempio: bevi sotto 30, colpo forte appena pronto, scappa sotto 15 senza pozioni) e fai altre cento partite. È il tuo metro vero.
  4. Attacca il classificatore con le tre domande (o l'assistente del piano B) e fai venti partite senza cancello.
  5. Accendi il cancello a 0,6 e rifai venti partite. Se vuoi vedere il bottone in azione, dieci a 0,4 e dieci a 0,8.
  6. Togli dalle opzioni le mosse impossibili con la funzione legali(), e rifai venti partite. Questa è la riga della tabella che ti sorprenderà di più.
  7. Lavora sulle descrizioni: prendi il turno in cui la scelta ti sembra più sbagliata, guarda le probabilità, e riscrivi la descrizione dell'opzione che ha vinto a torto. Una modifica alla volta, come nella Lezione 4.
  8. Compila la tabella del trasferimento con il tuo processo nella colonna di destra.

Risultato atteso

Quattro righe di misure e una frase scritta su quale giocatore terresti. È legittimo che vincano i tre if: la grotta è un gioco semplice e le regole scritte su un gioco semplice sono difficili da battere. Quella frase, con dentro il perché, vale più di una vittoria del classificatore, ed è esattamente il giudizio che ti serve quando deciderai sul tuo processo.

Mini-test di autoverifica

Vuoi testare le tue competenze?

Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.

Entra su HI

Riassunto della lezione

Cosa hai imparato

  • Un gioco è il banco di prova più economico: regole scritte, stato in una riga, nessun danno.
  • La fotografia dello stato contiene la situazione di adesso e i numeri che servono a scegliere.
  • Le descrizioni in opzioni sono il regolamento che il modello legge, e sono la parte su cui si lavora.
  • I conti restano nel gioco, al modello resta la scelta fra parole.
  • La soglia di confidenza è l'unico bottone: alta gioca prudente, bassa muore.
  • Il giro è lo stesso del lavoro, con una differenza sola: lì le mosse hanno conseguenze.

Prossimi passi

Nella Lezione 7, Controllo, errori e messa in strada prendiamo quella differenza di petto: come sbaglia un modello quando le mosse contano, quali controlli mettere, dove tenere il visto umano e come si misura il tempo guadagnato davvero.

Lezione 7 di 7

Controllo, errori e messa in strada

La tua automazione passa all'uso vero, con i controlli attivi e il conto dei minuti che ti restituisce davvero.

Obiettivi della lezione

Le automazioni non muoiono il giorno che le accendi. Muoiono tre mesi dopo, quando qualcuno cambia un campo di un modulo e per due settimane il foglio si riempie di righe storte che nessuno guarda.

Finita questa lezione, e con lei il corso, sai:

  • Riconoscere i tre modi in cui un modello sbaglia dentro un processo;
  • Mettere controlli automatici sui campi, sui formati e sui valori plausibili;
  • Decidere dove tenere il visto umano e quando toglierlo;
  • Sapere che cosa non mandare a un servizio esterno e come regolarti con i dati dei clienti;
  • Misurare il tempo risparmiato davvero, e decidere se tenere, correggere o smontare.

Come sbaglia un modello dentro un processo

In chat gli errori si vedono, perché li leggi. In un'automazione passano, e si accumulano. Tre forme, in ordine di frequenza.

Riempie i buchi. Un campo che manca nella richiesta viene compilato con un valore plausibile: un cognome verosimile, una data che sta bene lì. È l'errore più insidioso perché il risultato sembra perfetto. Si previene con l'istruzione esplicita sui dati mancanti e si prende con un controllo che confronti i campi estratti con il testo di partenza.

Cambia formato. Per novantasette pratiche risponde con le sette chiavi, alla novantottesima aggiunge un commento o mette una data scritta a parole. Non c'è prompt che lo escluda al cento per cento: si mette il controllo e si decide che cosa fare quando fallisce.

Sbanda sui casi lunghi. Con un testo molto lungo la qualità cala nella parte centrale, e con un elenco di trenta voci ne salta due. Si previene spezzando: dieci voci per volta, poi si uniscono i risultati.

L'errore silenzioso è peggio del blocco

Un'automazione che si ferma ti fa perdere mezz'ora. Un'automazione che va avanti scrivendo dati sbagliati te ne fa perdere due giorni, tre mesi dopo, quando qualcuno se ne accorge e bisogna capire da quando. Nel dubbio, conviene che si fermi.

I controlli automatici

Un controllo è una domanda a risposta secca che un programma sa fare da solo. Quattro tipi coprono quasi tutto.

  • Struttura: la risposta si legge come JSON e ha esattamente le chiavi previste.
  • Obbligatori: i campi senza i quali la pratica non può andare avanti sono pieni. Nome e contatto sì, budget no.
  • Dominio: i campi con valori ammessi contengono uno di quelli. Il tono vale neutro, urgente o scontento; la data si legge come data.
  • Plausibilità: i numeri stanno dentro un intervallo sensato. Un importo sopra i 50.000 euro o una scadenza fra tre anni fermano la pratica anche se sono scritti bene.

C'è poi un controllo che vale da solo più degli altri quattro, ed è il riscontro sul testo di partenza: per i campi copiati (nome, azienda, contatto, date) si verifica che quella stringa compaia davvero nel testo originale. Costa tre righe di codice e prende quasi tutti i casi di dato inventato.

Che cosa succede quando un controllo fallisce

  1. La pratica si ferma dove sta, senza scrivere niente a valle.
  2. Resta segnata come da lavorare, così non si perde.
  3. Arriva un avviso a una persona, con il materiale di partenza allegato.
  4. Il fallimento finisce nel registro, con la data e il motivo.

Dove tenere il visto umano

Il visto umano si mette nei punti dove un errore esce di casa: prima di mandare qualcosa a un cliente, prima di scrivere in un sistema che fa fede, prima di un pagamento. Dentro il processo, invece, i passaggi intermedi possono correre da soli.

Il visto ha un costo, e va speso bene. Tre regole che uso.

  • Un visto solo per pratica, nel punto giusto. Tre visti in fila diventano tre clic automatici, e un clic automatico vale zero.
  • Il visto deve essere informato: chi firma deve vedere accanto il materiale di partenza. Approvare una bozza senza avere sotto gli occhi la richiesta del cliente è un timbro.
  • Il visto si toglie con i numeri. Dopo qualche settimana guardi quante volte hai corretto qualcosa prima di approvare: se la percentuale è bassa e gli errori rimasti costano poco, il visto può diventare un controllo a campione.

Fra il visto su tutto e il campione c'è una terza strada, quella del classificatore della Lezione 3: guarda ogni pratica e chiama te solo quando la sua risposta è incerta. La soglia la scegli tu, per esempio ogni confidenza sotto 0,9 passa a una persona. Così il tuo tempo va sui casi dubbi invece che sui primi dieci della giornata, ed è la stessa idea del cancello davanti agli strumenti di un agente.

Il controllo a campione

Una via di mezzo che funziona: la pratica passa da sola e una su dieci finisce in una cartella che rivedi il venerdì. Tieni il polso della qualità senza spendere un visto per ogni pratica.

I dati che escono di casa

Quando mandi un testo a un servizio di AI, quel testo esce dalla tua azienda e arriva ai server di qualcun altro. Se dentro ci sono dati di persone, stai facendo un trattamento di dati personali, e valgono le regole di sempre.

Quattro cose pratiche.

  • Guarda dove finiscono i dati e se vengono usati per addestrare. I piani a pagamento per le aziende di solito lo escludono e lo mettono per iscritto; i piani gratuiti spesso no. Sta scritto nelle condizioni, e va letto una volta.
  • Firma il contratto giusto. Se il fornitore tratta dati personali per conto tuo serve un accordo (il responsabile del trattamento), e i fornitori seri ce l'hanno pronto da firmare.
  • Manda il meno possibile. Per estrarre il tipo di richiesta non serve il codice fiscale. Togliere i dati identificativi prima di inviare costa poco e risolve gran parte del problema.
  • Aggiorna il registro e l'informativa. Se hai un registro dei trattamenti, quel passaggio va scritto lì; se sul sito c'è un'informativa, deve nominare il fornitore.

Due cose che non si fanno mai: incollare in una chat documenti coperti da segreto professionale o sanitario senza aver verificato il contratto, e caricare elenchi di clienti interi «per fare una prova». La prova si fa su tre righe inventate.

Misurare quello che hai guadagnato

Nella Lezione 1 hai fatto una stima. Adesso si misura, perché le stime sull'automazione sono ottimiste per costruzione.

Quattro numeri, presi per un mese:

NumeroCome si prende
Pratiche passate da soleIl conteggio del registro
Pratiche fermate da un controlloIl conteggio degli avvisi
Pratiche passate con un erroreIl controllo a campione, moltiplicato
Minuti spesi da teIl tempo dei visti più quello delle pratiche fermate

Il guadagno vero è il costo attuale della Lezione 1 meno i minuti spesi adesso, meno il tempo di manutenzione. Se il numero è piccolo, il processo era sbagliato o l'automazione è troppo delicata: in tutti e due i casi meglio saperlo a un mese invece che a un anno.

La terza riga della tabella è quella che va guardata per prima. Le pratiche passate con un errore che nessuno ha fermato sono il debito che l'automazione sta accumulando, e se cresce si torna al visto.

Tenere in vita quello che gira

Le automazioni si rompono per cause che stanno fuori da loro. Le quattro più comuni: un servizio cambia la sua API, qualcuno aggiunge un campo al modulo, una chiave scade, il fornitore cambia il modello sotto al cofano e le risposte escono un po' diverse.

Da preparare prima che succeda:

  • Un registro di ogni esecuzione con data, esito, motivo del fallimento. Senza, non saprai mai da quando le cose andavano male.
  • Un avviso quando fallisce più del solito: se in un giorno si ferma cinque volte invece di una, qualcosa è cambiato a monte.
  • La batteria di casi della Lezione 4, ripassata ogni tre mesi e dopo ogni cambio di modello o di strumento.
  • Una pagina di istruzioni che dica come si spegne e come si fa a mano. Il giorno che si rompe, di solito, tu sei in ferie.

Saper smontare

Un'automazione che ti costa più manutenzione di quanto rende va spenta, e va bene così: hai imparato dove sta il tempo e hai la mappa. Tenere in piedi una cosa che non rende per non ammettere di averla costruita è il modo più caro di automatizzare.

Laboratorio: collaudo e messa in strada

Obiettivo: la tua automazione pronta per essere usata davvero, con i controlli attivi e il conto del guadagno.

Consegna

  1. Scrivi i controlli della tua catena: struttura, obbligatori, dominio, plausibilità, riscontro sul testo di partenza. Una riga per controllo, con scritto che cosa succede quando fallisce.
  2. Prova con venti casi veri presi dall'archivio degli ultimi mesi. Segna per ognuno: passato pulito, fermato, passato con errore.
  3. Rompi la catena apposta tre volte: un testo vuoto, un campo con un valore assurdo, una risposta del modello con del testo davanti al JSON. Verifica che si fermi in tutti e tre i casi.
  4. Decidi dove sta il visto e scrivi che cosa deve avere davanti chi firma.
  5. Compila la scheda dei dati: che cosa esce dall'azienda, verso quale fornitore, con quale contratto, e che cosa hai tolto prima di mandarlo.
  6. Scrivi la pagina di istruzioni: come si spegne, come si fa a mano, chi si avvisa.
  7. Fai il conto del guadagno mensile e confrontalo con la stima della Lezione 1.

Risultato atteso

Venti casi provati con i tre esiti contati, tre rotture provocate che si sono fermate come dovevano, una scheda dei dati compilata e un numero: i minuti al mese che hai guadagnato. Se quel numero è più basso della stima, guarda la riga delle pratiche fermate: di solito il tempo se ne va lì, e si recupera correggendo un controllo troppo severo o un prompt troppo vago.

Mini-test finale

Vuoi testare le tue competenze?

Il test di questa lezione, col punteggio e i progressi, sta su HI · Human Intelligence. Ti iscrivi gratis.

Entra su HI

Riassunto del corso

Il metodo, in sei mosse

  • Scegli il processo con il conto del tempo, invece che a naso.
  • Mappa quello che fai davvero, con i minuti e le decisioni scritte.
  • Spezza in passi meccanici, di giudizio e di responsabilità, e delega ognuno a chi lo fa meglio.
  • Fissa i prompt in un assistente con istruzioni, materiali e una batteria di casi.
  • Collega i pezzi con innesco e azioni, con l'uscita in un formato prevedibile.
  • Controlla e misura, tieni il visto dove un errore esce di casa, e spegni quello che non rende.

Dove continuare

Se vuoi il metodo intero, il corso Divide et Delega lo applica a un processo per volta, e alla fine hai realizzato con me un progetto tuo. Se invece vuoi andare a fondo sugli strumenti, il corso Claude in pratica entra nei connettori, nell'MCP e nell'automazione con Claude Code.

Vuoi questo corso per te o per il tuo team?

Porto l'automazione dei processi con l'AI dentro le aziende, in presenza a Livorno e in Toscana o online in tutta Italia, partendo dai vostri processi veri.

Parliamone
Torna ai corsi

Le slide del corso

Tutto il corso in 49 slide: si sfogliano qui, anche con le frecce della tastiera.

Slide 1: Gen AI per l'automazione dei processi. Sette lezioni per toglierti di dosso il lavoro ripetitivo, fino a un'automazione che gira sul tuo processo.
Slide 2: Apri una chat, resti colpito. Due settimane dopo, come prima.. Il salto arriva quando togli pezzi di lavoro da un processo. Il metodo è Divide et Delega: spezzi il processo e ogni parte la dai a chi la fa meglio.
Slide 3: Scegliere il processo. Le quattro parti, tre domande, il conto del tempo. La mappa passo per passo sta nel minicorso Mappare e automatizzare i processi.
Slide 4: Un processo ha quattro parti
Slide 5: Tre domande, in quest'ordine
Slide 6: Dove l'AI generativa è brava
Slide 7: Un totale plausibile su una fattura è un totale sbagliato.. Il modello sbaglia sui conti esatti, sui fatti che non gli hai dato e sui dati che cambiano. Il conto lo fa il foglio, e al modello passi il risultato.
Slide 8: La regola è scritta e vale sempre?
Slide 9: . Un preventivo da 40 minuti, 12 volte al mese. Risparmi 84 minuti: se costruire ti costa 6 ore, rientri in quattro mesi. Più un'ora di manutenzione ogni quattro mesi.
Slide 10: Accanto a ogni passo, tre numeri e una parola
Slide 11: Le eccezioni: tre sorti
Slide 12: Spezzare e delegare. La lezione centrale: chi fa ogni passo, il prompt come specifica, la catena e i modelli che classificano.
Slide 13: Tre tipi di passo
Slide 14: «È urgente?» spesso è una data e un confronto fra due date.. La data la estrae l'AI. Il confronto lo fa una formula, ed è sempre giusto.
Slide 15: Il prompt ha quattro C
Slide 16: Il formato tiene insieme la catena
Slide 17: Due esempi valgono dieci righe di spiegazione.. Allega due o tre coppie di richiesta e risposta vere, corrette a mano. Insegnano anche quello che non dici: il saluto, le domande, l'impegno datato.
Slide 18: La catena del preventivo
Slide 19: Uno stato e una domanda: torna un'etichetta.. Con accanto la probabilità. «Il pacco è arrivato rotto, vorrei fare un reso»: tono negativo, italiano, vuole un reso. Con tre risposte chiuse il ticket va ai resi da solo.
Slide 20: Jev e Bivio
Slide 21: Dal prompt alla catena. Un assistente che risponde sempre uguale, e i pezzi collegati in un'automazione che parte da sola.
Slide 22: Quello che oggi correggi a voce diventa una riga scritta.. Per due settimane segnati ogni correzione. Con le mie mail ne sono venute fuori nove righe: quelle sono le istruzioni fisse.
Slide 23: Le istruzioni fisse, in quattro sezioni
Slide 24: La batteria: sei casi
Slide 25: Quando succede una cosa, fai queste altre cose in fila.. «Quando arriva una mail all'indirizzo info, estrai i sette campi, aggiungi una riga al foglio Richieste e mandami un avviso se il tono è scontento.»
Slide 26: Con che cosa si collega
Slide 27: Dentro la catena nessuno guarda la risposta.. Quindi uscita in JSON, un controllo che ferma la pratica se la lettura fallisce, e le istruzioni fisse dentro al nodo: ogni chiamata parte da zero.
Slide 28: Catena o agente?
Slide 29: Il cancello, fatto da un classificatore
Slide 30: L'AI gioca al posto tuo. Una parentesi: il metodo intero girato su un gioco a turni, dove vedi subito se la decisione era buona.
Slide 31: Perché un gioco
Slide 32: Il gioco: la grotta
Slide 33: Lo stato di adesso, con le regole per scegliere.. Le pozioni curano 30, il mostro toglie da 8 a 20, le monete si perdono morendo. Senza quei numeri il modello indovina.
Slide 34: Le opzioni sono il regolamento
Slide 35: Il giro, con il cancello a 0,6
Slide 36: I conti li fa esegui(). Al modello resta la scelta.. Una fra quattro parole. Se calcolasse lui i danni, ogni tanto il mostro perderebbe 14 di vita invece di 9, e nessuno se ne accorgerebbe: 14 è un numero plausibile.
Slide 37: Le mosse impossibili non gliele offriamo
Slide 38: . Sei righe di Python. Prima moriva nel 100% delle partite, dopo ne vince tre su quattro.
Slide 39: Quello che è venuto a me
Slide 40: Lo stesso giro, sul lavoro
Slide 41: Controllo e messa in strada. Come sbaglia un modello, i controlli automatici, il visto umano, i dati che escono di casa, la misura.
Slide 42: Come sbaglia un modello in produzione
Slide 43: L'errore silenzioso è peggio del blocco.. Un'automazione che si ferma ti costa mezz'ora. Una che scrive dati sbagliati, due giorni, tre mesi dopo, quando bisogna capire da quando. Nel dubbio, conviene che si fermi.
Slide 44: I controlli automatici
Slide 45: Tre visti in fila diventano tre clic automatici.. Un visto solo, dove l'errore esce di casa, con la richiesta del cliente sotto gli occhi. Dopo qualche settimana di numeri puliti diventa un controllo a campione.
Slide 46: I dati che escono di casa
Slide 47: Un mese dopo, quattro numeri
Slide 48: Il metodo in sei mosse
Slide 49: Le macchine calcolano, noi comprendiamo.. Il corso Divide et Delega applica il metodo a un processo per volta, e alla fine hai realizzato con me un progetto tuo.

Vuoi la video lezione?

Su HI · Human Intelligence queste slide diventano una video lezione con la mia voce, e ci sono i test del corso. L'iscrizione è gratuita.

Iscriviti gratis a HI
Federico BoggiaRispondo io, in giornata

Ciao! Dimmi che ti serve: un corso online, HI · Human Intelligence o la formazione per la tua azienda.

Scrivimi su WhatsApp