Come padroneggiare l'IA in 30 giorni: la roadmap definitiva

La maggior parte delle persone usa l'IA da due anni e ancora scrive nel riquadro come se stesse cercando su Google. Una vaga riga, una scrollata di spalle alla risposta, chiusura della scheda. "Usano" l'IA come "usi" un tapis roulant su cui appendi le camicie.

La parte scomoda: il divario tra chi ottiene 10x da questi modelli e chi non ottiene nulla non è talento, e non è un modello segreto. È un sistema. Il gruppo del 10x riutilizza le stesse poche mosse — ogni prompt, ogni giorno — finché non diventano memoria muscolare.

La maestria non è conoscere più prompt. È possedere un sistema ripetibile che esegui senza pensare.

Questo è quel sistema, compresso in 30 giorni. Quattro settimane, dodici play numerati, ognuno dei quali termina in una cosa che fai oggi. Prompt copiabili. Python vero e funzionante (verificato con l'SDK Anthropic, v0.109.1). Nessuna teoria su cui non puoi agire entro stasera.

Il colpo di pistola culturale è stata la famosa frase di Andrej Karpathy sul "vibe coding" — "ti abbandoni completamente alle vibes... e dimentichi persino che il codice esista." Questa è la vibrazione. Questa è la disciplina sottostante che fa sì che la vibrazione porti davvero a qualcosa.

Parte 1 · Settimana 1 — Il Modello Mentale e le Prime Vittorie (Giorni 1–7)

L'obiettivo di questa settimana non è la conoscenza. È una vittoria. Entro il Giorno 7, dovresti aver delegato almeno un compito reale a un modello e aver sentito il tempo restituirti. Tutto il resto si basa su quella sensazione.

01. Realizza un compito reale con l'IA — oggi.

Non iniziare con un corso. Inizia con un compito che devi già a qualcuno: un'email che rimandi, appunti da sistemare, una funzione da abbozzare. Il modo più veloce per "capire" l'IA è affidarle qualcosa con poste in gioco reali e giudicare il risultato rispetto a quello che avresti scritto tu.

L'errore che fanno i principianti è scrivere un argomento ("scrivi sull'onboarding") invece di un brief. Tratta il modello come un nuovo assunto competente al primo giorno: ha le competenze ma nessuno dei tuoi contesto. Dai un ruolo, il compito, il contesto e l'output esatto che desideri.

Usalo quando: hai un compito che normalmente faresti da solo in meno di un'ora — scrivere, riassumere, riformattare, fare brainstorming, pianificare.

1Sei il mio <ruolo, es. "caporedattore diretto">.
2Compito: <un compito concreto in una frase>.
3Contesto: <2–3 righe che il modello non può sapere — pubblico, obiettivo, vincoli>.
4Output: <formato esatto — lunghezza, struttura, tono>.
5Se qualcosa è ambiguo, chiedimi prima invece di indovinare.

Quell'ultima riga è il trucco. Trasforma un tentativo singolo in una breve conversazione, e le conversazioni battono i monologhi quasi sempre.

Fallo ora: scegli un compito dalla tua lista, riempi i quattro slot, eseguilo. Tieni il prompt — riutilizzerai la struttura per tutto il mese.

02. Impara l'anatomia di un prompt che funziona.

Ogni prompt affidabile ha tre parti, e i principianti ne saltano due. Chiarezza (dì esattamente cosa vuoi), contesto (dì perché e per chi), e formato (dì come deve essere l'output). La stessa guida di Anthropic chiama questa la regola del "dipendente brillante ma nuovo": più spieghi precisamente, migliore è il risultato — e la loro regola d'oro letterale è "mostra il tuo prompt a un collega con un contesto minimo; se fosse confuso, lo sarà anche il modello."

L'upgrade singolo più efficace è aggiungere la motivazione. Non dire solo "non usare mai i puntini di sospensione." Dì "questo verrà letto ad alta voce da un motore text-to-speech, quindi non usare mai i puntini di sospensione — non può pronunciarli." Il modello generalizza dalla ragione. È la differenza tra un ordine e una spiegazione.

Usalo quando: una risposta arriva generica, fuori tono, o tecnicamente corretta ma inutile. Nove volte su dieci, mancava una delle tre parti.

1# Debole (argomento, non un brief)
2Scrivi sulla nostra nuova funzionalità.
3
4# Forte (chiarezza + contesto + formato)
5Scrivi un annuncio di prodotto di 120 parole per la nostra nuova "Modalità Focus."
6Pubblico: utenti esistenti che trovano l'app rumorosa.
7Obiettivo: convincerli a provarla almeno una volta questa settimana.
8Tono: calmo, sicuro, zero hype.
9Formato: 1 paragrafo breve + un CTA di una riga.

Fallo ora: prendi il prompt debole di ieri e riscrivilo con tutte e tre le parti etichettate. Eseguili entrambi. Osserva il divario.

03. Ruba le 6 tecniche fondamentali — e una riga di codice.

Queste sei appaiono in ogni guida seria di prompt engineering perché funzionano sempre: (1) sii chiaro e diretto, (2) aggiungi contesto/motivazione, (3) fornisci esempi, (4) struttura con tag in stile XML, (5) assegna un ruolo, (6) dì di pensare prima di rispondere. Passerai la Settimana 2 ad allenare ciascuna — questa è la mappa.

Due meritano di essere messe in pratica immediatamente: ruoli e tag. Un ruolo nell'istruzione di sistema guida il tono e il giudizio per l'intera conversazione; anche una sola frase fa la differenza. Tag come <contesto> e <esempi> impediscono al modello di confondere le tue istruzioni con i tuoi dati. Ecco la tecnica del ruolo come codice vero e funzionante — il primo assaggio dell'API in cui vivrai entro la Settimana 3.

Usalo quando: vuoi un comportamento coerente tra molte chiamate (il ruolo) o stai mescolando istruzioni con input disordinati (i tag).

1import anthropic
2
3client = anthropic.Anthropic()  # legge ANTHROPIC_API_KEY dal tuo ambiente
4
5msg = client.messages.create(
6    model="claude-opus-4-8",
7    max_tokens=1024,
8    system="Sei un redattore senior. Tagli il superfluo e mantieni la voce dell'autore.",  # il ruolo
9    messages=[
10        {"role": "user", "content": "Modifica questo paragrafo, poi elenca cosa hai cambiato:\n\n<bozza>...</bozza>"}
11    ],
12)
13print(msg.content[0].text)

Fallo ora: riscrivi un prompt con un ruolo esplicito e tag < > intorno all'input. Hai appena usato 2 delle 6 — la Settimana 2 completa il set.

Parte 2 · Settimana 2 — Prompt Engineering per Output Reali (Giorni 8–14)

Questa settimana trasformi "funziona più o meno" in "funziona sempre." Stesso compito, stessa forma, stessa qualità — su richiesta. Quell'affidabilità è ciò che ti permette di automatizzare nella Settimana 3.

04. Blocca tono e formato con esempi multishot.

Dire al modello cosa vuoi è buono. Mostrarglielo è meglio. Alcuni esempi ben scelti (la tecnica si chiama few-shot o multishot prompting) fissano formato, tono e casi limite in modo più affidabile di qualsiasi aggettivo. La guida è coerente in tutto il settore: includi 3–5 esempi, rendili diversificati in modo che il modello non si aggrappi a uno schema accidentale, e avvolgi ciascuno in tag in modo che sia chiaramente un esempio e non un'istruzione.

Questo è il singolo salto di qualità più grande per il lavoro ripetitivo — classificazione, estrazione, formattazione, riscrittura. Se fai lo stesso tipo di compito più di due volte a settimana, merita degli esempi.

Usalo quando: il formato dell'output varia tra le esecuzioni, o hai bisogno che il modello corrisponda a uno stile specifico.

1Classifica ogni ticket di supporto come esattamente uno tra: bug | fatturazione | funzionalità.
2
3<esempi>
4<esempio>
5Ticket: "Mi è stato addebitato due volte questo mese."
6Categoria: fatturazione
7</esempio>
8<esempio>
9Ticket: "Il pulsante Esporta non fa nulla su Safari."
10Categoria: bug
11</esempio>
12<esempio>
13Ticket: "Per favore, aggiungi una modalità scura."
14Categoria: funzionalità
15</esempio>
16</esempi>
17
18Ticket: "L'app si blocca quando carico un PDF."
19Categoria:

Fallo ora: prendi un compito ricorrente, scrivi 3 esempi diversificati nei tag <esempio>, e guarda l'output prendere forma.

05. Fai pensare il modello prima di rispondere.

Per qualsiasi cosa che richieda ragionamento — analisi, matematica, pianificazione, giudizio complesso — la cosa peggiore che puoi fare è pretendere la risposta immediatamente. Dagli spazio per ragionare prima. Puoi lasciare che i modelli più recenti pensino in modo adattivo, o, in una chat normale, forzarlo: chiedi un ragionamento passo-passo in un blocco <pensiero>, poi una risposta finale concisa in un blocco <risposta>. Separare i due significa ottenere il beneficio del ragionamento senza il muro di testo.

Una mossa bonus dalla guida di Anthropic: chiedigli di autoverificarsi prima di finire — "verifica la tua risposta rispetto ai vincoli sopra." Sorprendentemente spesso coglie i propri errori, specialmente su matematica e logica.

Usalo quando: il compito ha più di un passaggio, una risposta giusta su cui puoi sbagliare, o compromessi da valutare.

1Domanda: <una domanda con un vero compromesso>
2
3Prima, ragiona all'interno dei tag <pensiero>: elenca cosa sai, cosa manca,
4e due risposte candidate con i loro compromessi.
5Poi dai la tua decisione all'interno dei tag <risposta> — massimo 3 frasi.
6Prima di finire, verifica che la tua risposta non contraddica nulla di quanto sopra.

Fallo ora: prendi una decisione che stai rimuginando, falla passare attraverso la divisione pensiero/risposta, e leggi il <pensiero> — è lì che si nasconde il valore.

06. Costruisci una libreria di prompt riutilizzabile.

A questo punto hai scritto una dozzina di buoni prompt e ne hai persi metà nella cronologia delle chat. Fermati. I professionisti non riscrivono i prompt — riempiono template. Estrai i tuoi migliori prompt in un unico file con {variabili} per le parti che cambiano, e avrai trasformato l'ingegnosità una tantum in infrastruttura.

Questa è la cerniera dell'intero programma di 30 giorni: è il momento in cui i tuoi prompt smettono di essere usa e getta e iniziano a comporsi. Un semplice dict Python e str.format è tutto ciò di cui hai bisogno per iniziare — nessun framework, nessuna dipendenza.

Usalo quando: hai eseguito un prompt simile tre volte. Alla terza volta, trasformalo in template.

1# libreria_prompt.py — i tuoi prompt come infrastruttura riutilizzabile
2TEMPLATES = {
3    "riassumi": (
4        "Sei un {ruolo}.\n"
5        "Riassumi il testo seguente per {pubblico}.\n"
6        "Formato: {formato}.\n\n"
7        "<testo>\n{testo}\n</testo>"
8    ),
9}
10
11def costruisci(nome: str, **kwargs) -> str:
12    return TEMPLATES[nome].format(**kwargs)
13
14prompt = costruisci(
15    "riassumi",
16    ruolo="scrittore tecnico",
17    pubblico="utenti non tecnici",
18    formato="3 punti elenco, massimo 15 parole ciascuno",
19    testo="...incolla qui le note di rilascio...",
20)
21print(prompt)  # inserisci direttamente in client.messages.create(...)

Fallo ora: crea libreria_prompt.py, sposta i tuoi 3 migliori prompt come template con variabili. Questo file cresce per tutto il mese.

Parte 3 · Settimana 3 — Automatizza con l'API (Giorni 15–21)

La chat è dove impari. L'API è dove scalare. Questa settimana passi dall'eseguire compiti uno alla volta a eseguirli a centinaia, su un programma, mentre dormi.

07. Passa dalla chat all'API.

L'API non è altro che i tuoi prompt di chat in una funzione che puoi chiamare. Se sai scrivere un prompt, sai scrivere questo — sono dieci righe. Imposta la tua chiave come variabile d'ambiente (non incollarla mai nel codice), avvolgi la chiamata in una funzione, e hai un comando AI riutilizzabile che puoi inserire in qualsiasi script.

Simon Willison, che ha documentato l'uso pratico dei LLM meglio di quasi chiunque altro, sottolinea che la leva non sta nelle configurazioni esotiche — sta nel collegare i modelli ai piccoli strumenti che già usi. Questa funzione è quel cavo.

Usalo quando: vuoi che lo stesso prompt sia disponibile ovunque — in script, cron job, altri programmi — non solo in una scheda del browser.

1import os
2import anthropic
3
4client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
5
6def chiedi(prompt: str) -> str:
7    msg = client.messages.create(
8        model="claude-opus-4-8",
9        max_tokens=1024,
10        messages=[{"role": "user", "content": prompt}],
11    )
12    return msg.content[0].text
13
14if __name__ == "__main__":
15    print(chiedi("Dammi 5 oggetti accattivanti per un'email di lancio prodotto."))

Fallo ora: installa l'SDK (pip install anthropic), imposta ANTHROPIC_API_KEY, ed esegui questo file. Prima chiamata API riuscita = Settimana 3 sbloccata.

08. Trasforma un compito quotidiano in uno script.

È qui che il tempo torna effettivamente indietro. Qualsiasi compito che fai su una cartella di elementi — riassumi questi 50 trascritti, tagga questi 200 ticket, riscrivi queste 30 descrizioni di prodotto — è un ciclo. Scrivi la versione per un singolo elemento una volta, puntala a una cartella, e vai via. Usa un modello più economico e veloce per il lavoro in blocco; non hai bisogno del tuo modello più potente per riassumere un memo.

Usalo quando: ti sorprendi a fare lo stesso compito AI ripetutamente a mano. Quella ripetizione è uno script che non hai ancora scritto.

1import pathlib
2import anthropic
3
4client = anthropic.Anthropic()
5INBOX = pathlib.Path("./inbox")        # inserisci qui i file .txt
6OUT = pathlib.Path("./riassunti")
7OUT.mkdir(exist_ok=True)
8
9def riassumi(testo: str) -> str:
10    msg = client.messages.create(
11        model="claude-haiku-4-5",      # economico + veloce: lo strumento giusto per il lavoro in blocco
12        max_tokens=300,
13        system="Riassumi in 3 punti elenco concreti. Niente fronzoli.",
14        messages=[{"role": "user", "content": testo}],
15    )
16    return msg.content[0].text
17
18for f in INBOX.glob("*.txt"):
19    (OUT / f"{f.stem}.md").write_text(riassumi(f.read_text(encoding="utf-8")), encoding="utf-8")
20    print("riassunto:", f.name)

Fallo ora: trova un compito in blocco, inserisci i file in ./inbox, esegui il ciclo. Hai appena fatto un'ora di lavoro in un minuto.

09. Riduci costi e latenza con la cache.

Una volta che gestisci volumi reali, due cose iniziano a contare: velocità e il conto. La leva più grande è il prompt caching. Se ogni chiamata condivide un prefisso lungo e invariato — una guida di stile, una knowledge base, una grande istruzione di sistema — stai pagando per rileggerlo ogni singola volta. Marchialo con cache_control e il modello riutilizza la versione in cache: una lettura dalla cache costa circa il 10% del prezzo di input normale, contro una scrittura una tantum con un sovrapprezzo del +25%. Per i lavori in batch che condividono un prefisso, l'API Batch aggiunge un ulteriore sconto di circa il 50%.

Usalo quando: molte chiamate condividono un grande blocco statico di contesto (il caso classico: un lungo prompt di sistema riutilizzato per un intero lavoro).

1import anthropic
2
3client = anthropic.Anthropic()
4GUIDA_STILE = open("guida_stile.md").read()   # lungo, identico in ogni chiamata
5
6msg = client.messages.create(
7    model="claude-opus-4-8",
8    max_tokens=1024,
9    system=[
10        {
11            "type": "text",
12            "text": GUIDA_STILE,
13            "cache_control": {"type": "ephemeral"},  # memorizza nella cache questo grande prefisso
14        }
15    ],
16    messages=[{"role": "user", "content": "Riscrivi questa email per corrispondere alla guida:\n\n..."}],
17)
18print(msg.usage)  # osserva cache_read_input_tokens salire dopo la prima chiamata

Fallo ora: trova un prompt con un grande prefisso ripetuto, avvolgilo in un blocco cache_control, ed eseguilo due volte. Stampa msg.usage e osserva la lettura dalla cache attivarsi.

Parte 4 · Settimana 4 — Strumenti, Dati e Rilascio (Giorni 22–30)

L'ultima settimana è il salto da "IA che parla" a "IA che fa." Dai al modello degli strumenti, lo colleghi ai tuoi dati reali e impacchetti il tutto in un flusso di lavoro che userai per anni.

10. Dai al modello degli strumenti (function calling).

Un modello da solo può solo produrre testo. Dagli strumenti e può compiere azioni — controllare il tuo calendario, chiamare un'API, eseguire un calcolo. Descrivi ogni strumento con un nome, una descrizione e uno schema JSON dei suoi input; il modello decide quando chiamarlo e ti passa argomenti strutturati da eseguire. Questa è la base di ogni "agente AI" di cui hai sentito parlare.

Usalo quando: il compito necessita di dati in tempo reale o un'azione che il modello non può eseguire solo con il testo (qualsiasi cosa con "cerca," "recupera," "calcola" o "invia").

1import anthropic
2
3client = anthropic.Anthropic()
4
5strumenti = [
6    {
7        "name": "ottieni_eventi_calendario",
8        "description": "Restituisce gli eventi dell'utente per una data specifica.",
9        "input_schema": {
10            "type": "object",
11            "properties": {
12                "data": {"type": "string", "description": "Data come AAAA-MM-GG"}
13            },
14            "required": ["data"],
15        },
16    }
17]
18
19msg = client.messages.create(
20    model="claude-opus-4-8",
21    max_tokens=1024,
22    tools=strumenti,
23    messages=[{"role": "user", "content": "Cosa ho in calendario il prossimo lunedì?"}],
24)
25
26for block in msg.content:
27    if block.type == "tool_use":
28        print("Il modello vuole chiamare:", block.name, "con", block.input)
29        # ora TU esegui ottieni_eventi_calendario(**block.input) e rimandi indietro il risultato

Fallo ora: definisci uno strumento per qualcosa che usi effettivamente (calendario, meteo, una ricerca), e osserva il modello produrre una chiamata tool_use pulita. Non devi nemmeno eseguirla ancora — basta vederlo decidere.

11. Collega l'IA ai tuoi dati con MCP.

Incollare il contesto a mano non scala. Il Model Context Protocol (MCP), introdotto da Anthropic nel novembre 2024, è la soluzione standard — pensalo come una porta USB-C per l'IA: uno standard di connessione, e qualsiasi client conforme può accedere ai tuoi file, database e strumenti. In pochi mesi è passato da idea interna a standard del settore, con migliaia di server pronti all'uso che puoi inserire tramite configurazione.

Non devi scrivere codice per usare la maggior parte dei server — aggiungi una voce a un file di configurazione. Ecco un server filesystem che dà a un modello accesso in lettura a una cartella di appunti:

Usalo quando: continui a fornire al modello la stessa fonte di verità a mano — i tuoi documenti, un repository, un database, una knowledge base.

1{
2  "mcpServers": {
3    "filesystem": {
4      "command": "npx",
5      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Utenti/tuo/nome/appunti"]
6    }
7  }
8}

Fallo ora: sfoglia i server MCP disponibili, scegline uno che punti a dati che usi settimanalmente, e aggiungilo alla configurazione del tuo client. Fai una domanda a cui solo i tuoi dati possono rispondere.

12. Confeziona un flusso di lavoro che riutilizzerai per sempre.

Giorno 30. Hai prompt, script e strumenti — ora trasformali in una cosa che evochi per nome. Le Agent Skills di Anthropic (diventate uno standard aperto nel dicembre 2025) sono il formato pulito per questo: una cartella con un SKILL.md che contiene un nome, una descrizione di quando usarlo e i passaggi. Il modello lo carica solo quando pertinente (un principio di design chiamato divulgazione progressiva), così puoi accumularne decine senza appesantire il contesto. Anche se non toccassi mai più l'API, scrivere i tuoi compiti ripetibili come skill è l'abitudine che ti rende veloce.

Usalo quando: hai un compito in più passaggi che ripeterai per mesi — un rapporto settimanale, una revisione standard, una pipeline di formattazione.

1---
2name: rapporto-settimanale
3description: Trasforma i miei appunti grezzi nel rapporto settimanale standard. Usa quando incollo appunti e chiedo "il settimanale."
4---
5
6# Rapporto settimanale
7
8## Passaggi
91. Raggruppa gli appunti in: Consegnato, In corso, Bloccato.
102. Scrivi 2–3 punti elenco per gruppo, al passato, senza fronzoli.
113. Concludi con "Prossima settimana" — esattamente 3 priorità.
12
13## Formato
14- Titolo: "Settimanale — <data>"
15- Meno di 200 parole. Nessun hype.

Fallo ora: scegli il tuo compito più ripetuto, scrivilo come SKILL.md con una descrizione precisa. Quella descrizione è ciò che lo fa scattare al momento giusto — dedicaci un vero sforzo.

Errori tipici (e la soluzione)

1. Prompt vaghi. "Scrivi su X" fa sì che il modello indovini la tua intenzione — e indovina nella media. Soluzione: dai sempre ruolo + contesto + formato. Sei <ruolo>. Compito: <una frase>. Output: <formato esatto>.

2. Prompt eccessivi con urgenza IN MAIUSCOLO. I modelli più recenti seguono le istruzioni in modo preciso e reagiscono in modo eccessivo a "CRITICO!!! DEVI." La guida di Anthropic stessa: ridimensiona con frasi normali come "Usa questo strumento quando…". Soluzione: scrivi le istruzioni come se stessi dando indicazioni a un adulto competente, non urlando a un cane.

3. Descrivere invece di mostrare. Gli aggettivi ("rendilo professionale") sono deboli; gli esempi sono forti. Soluzione: aggiungi 3–5 esempi diversificati nei tag <esempio> e lascia che lo schema faccia il lavoro.

4. Formulare come "non fare." "Non essere prolisso" fa pensare il modello alla prolissità. Soluzione: dì cosa fare — "Rispondi in 2 brevi frasi." Le istruzioni positive attecchiscono più dei divieti.

5. Fidarsi dell'output senza verificarlo. Copiare e incollare una risposta non verificata è come gli errori vengono distribuiti. Soluzione: per lavori basati sui fatti, chiedigli di ancorare le affermazioni a citazioni della fonte e di autoverificarsi prima di finire: Verifica ogni affermazione rispetto al testo sopra; segnala qualsiasi cosa di cui non sei sicuro.

6. Fare a mano ciò che un ciclo potrebbe fare. Eseguire lo stesso prompt 50 volte in chat è la cosa più costosa che tu possa fare con il tuo pomeriggio. Soluzione: nel momento in cui colpisci la ripetizione, scrivi il ciclo del Blocco 08. Il tuo tempo è la risorsa scarsa, non i token.

Conclusione: il sistema è l'abilità

Trenta giorni non ti rendono un ricercatore di IA. Ti rendono qualcosa di più utile: qualcuno con un sistema. Puoi prendere qualsiasi compito, dargli un brief pulito, mostrargli esempi, spingerlo a pensare e — quando si ripete — automatizzarlo, metterlo in cache e confezionarlo in una skill che evochi per nome.

Questo è l'intero segreto che il gruppo del 10x non ha mai nascosto. Non più prompt. Non un modello migliore. Un piccolo insieme di mosse, eseguite fino a diventare riflesso. Ora hai le mosse. L'unica variabile rimasta sono le ripetizioni.

La tua checklist di 30 giorni — inizia oggi:

1. Realizza un compito reale con un prompt ruolo + contesto + formato (Blocco 01).
2. Avvia libreria_prompt.py e sposta i tuoi 3 migliori prompt come template (Blocco 06).
3. Fai la tua prima chiamata API con la funzione chiedi() di 10 righe (Blocco 07).
4. Automatizza un compito in blocco con il ciclo sulle cartelle (Blocco 08).
5. Scrivi un SKILL.md per il tuo flusso di lavoro più ripetuto (Blocco 12).

Fai queste cinque cose e avrai superato il 90% di tutti quelli che "hanno intenzione di addentrarsi nell'IA." Poi continua semplicemente a eseguire il ciclo.