C’è un momento preciso in cui un semplice chatbot diventa un agente. Non succede quando risponde bene, e nemmeno quando capisce il contesto. Succede quando agisce. Quando non si limita a dirti cosa fare, ma lo fa. Apre un file, esegue un comando, interroga un database, invia un riepilogo. In quel momento il confine è superato: non stai più chattando con un modello linguistico, stai delegando un compito a un agente AI.

Per molto tempo costruire un agente AI del genere ha significato scrivere codice. Loop di esecuzione, gestione dei tool, parsing delle risposte, retry, memoria. Non era complicato in senso assoluto, ma serviva saper programmare.

Poi è arrivato Claude Code, e la domanda è diventata un’altra: quanto può fare un agente se lo descrivi invece di programmarlo?

La risposta, dopo averci passato qualche settimana, è: molto più di quanto pensassi. E in questo articolo ti mostro esattamente come costruire il tuo primo agente AI funzionante in meno di un’ora — senza scrivere codice, usando solo linguaggio naturale e un file di configurazione.

Partiamo da zero. Claude Code è un assistente agentico che gira nel tuo terminale. Sembra una frase da scheda prodotto, ma nasconde un concetto potente: non è un’interfaccia di chat. È un harness agentico — un’impalcatura software che trasforma un modello linguistico in un agente capace di agire.

La differenza è strutturale.

Chat tradizionale

Agente con Claude Code

Tu chiedi, lui risponde

Tu definisci un lavoro, lui lo esegue in autonomia

Parla di cose da fare

Chiama strumenti per farle davvero

Dimentica tutto tra una sessione e l’altra

Legge CLAUDE.md a ogni avvio e ricorda il suo compito

Una conversazione fa tutto

Sub-agenti specializzati gestiscono pezzi diversi

Se hai mai provato frustrazione nel dover rispiegare ogni volta al modello cosa deve fare, sei già nel caso d’uso perfetto per un agente. Perché un agente non lo rispieghi: lo configuri una volta e poi lo esegui cento volte.

Prima di sporcarci le mani, vale la pena capire cosa succede sotto il cofano. Non perché serva a costruire l’agente — ti ho promesso che non scriviamo codice e mantengo la promessa — ma perché capire il meccanismo ti aiuta a dare istruzioni migliori.

Claude Code funziona con un ciclo a tre fasi che si ripete fino al completamento del compito:

Fase 1 — Raccogli contesto. Claude legge file, cerca nel codice, esplora la struttura del progetto. Non parte mai alla cieca: prima capisce dove si trova e cosa ha a disposizione.

Fase 2 — Agisci. Usa i tool a sua disposizione: modifica file, esegue comandi, interroga servizi esterni. Ogni azione produce un risultato che alimenta il ciclo.

Fase 3 — Verifica. Dopo ogni azione, controlla se il risultato è corretto. Se qualcosa non torna, torna alla fase 1 con le nuove informazioni e corregge la rotta.

È un ciclo che si auto-corregge. Claude decide da solo quale strumento usare a ogni passaggio, basandosi su ciò che ha imparato nel passaggio precedente. Tu puoi intervenire in qualsiasi momento — premendo Esc o scrivendo un’istruzione — ma non devi farlo. L’agente lavora in autonomia.

Questo loop è alimentato da due cose: il modello (Claude Sonnet o Opus) che ragiona, e i tool che eseguono. Claude Code è l’harness che tiene insieme entrambi.

Ora entriamo nel pratico. Per costruire un agente con Claude Code ti servono tre cose. Tre. Non quindici, non un’infrastruttura cloud, non un database vettoriale.

Il primo ingrediente è anche il più sottovalutato: una descrizione precisa di cosa deve fare l’agente. In Claude Code questa descrizione vive in un file chiamato CLAUDE.md, che metti nella root del tuo progetto.

Non è codice. È un file Markdown. Scritto in linguaggio naturale. Ecco un esempio reale:

Questo file è il brief del tuo agente. Lo legge a ogni avvio. Non devi rispiegare nulla. Se dopo qualche esecuzione noti che l’output non ti soddisfa, modifichi CLAUDE.md e riprovi. È iterazione, non programmazione.

La regola d’oro: se non riesci a descrivere il compito in una frase, l’ambito è troppo largo. Restringilo. Un agente che fa una cosa sola ma la fa bene vale più di un agente che prova a fare tutto e fallisce in silenzio.

Il secondo ingrediente sono i tool: i mezzi con cui l’agente interagisce col mondo. Senza tool, Claude può solo pensare ad alta voce. Con i tool, può leggere file, eseguire comandi, interrogare API, consultare database.

Claude Code ha già strumenti integrati:

Categoria

Cosa può fare l’agente

File

Leggere, modificare, creare, rinominare file

Ricerca

Cercare file per pattern, cercare testo con regex

Esecuzione

Lanciare comandi shell, avviare server, usare git

Web

Cercare online, recuperare documentazione

E qui arriva la parte interessante per il no-code: MCP, il Model Context Protocol. MCP è lo standard per connettere Claude Code a servizi esterni. Invece di scrivere integrazioni per Gmail, Slack, Notion o Postgres, installi un server MCP già pronto e lo configuri.

Si fa in due passaggi:

Il file di configurazione è JSON, sì — ma è configurazione, non logica. Copi e incolli un template. Ecco come si presenta:

Fatto questo, il tuo agente ha accesso a Gmail. Può leggere le email. Può cercare per mittente. Può — se glielo permetti — anche inviare risposte (anche se per il primo agente ti consiglio caldamente di tenere tutto in sola lettura).

Lo stesso pattern funziona per qualsiasi cosa: Slack, Google Drive, PostgreSQL, Jira, GitHub. Ogni servizio diventa un tool che l’agente può chiamare in autonomia. E tu non hai scritto una riga di codice.

Il terzo ingrediente è opzionale ma potente: i sub-agents. Sono agenti specializzati che Claude può chiamare per delegare compiti specifici. Ognuno ha il proprio contesto separato, il proprio CLAUDE.md, i propri tool.

Perché servono? Perché un agente monolitico che prova a fare tutto in una conversazione lunghissima prima o poi perde il filo. Il contesto si riempie, le istruzioni iniziali vengono compattate e dimenticate, l’output peggiora.

Con i sub-agents dividi il lavoro:

Ogni sub-agente ha il suo contesto fresco. L’agente principale riceve solo i risultati finali. Nessun inquinamento del contesto, output più pulito.

La cosa bella è che i sub-agents si configurano esattamente come un agente: un file CLAUDE.md nella loro cartella, una descrizione chiara del loro compito, e via. Anche qui, zero codice.

Basta teoria. Prendiamo il caso concreto dell’agente di riepilogo inbox e costruiamolo insieme. Tempo stimato: 45 minuti.

Apri il terminale e installa Claude Code globalmente con npm:

Poi autenticati con il tuo account Anthropic:

Ti si aprirà il browser per l’autenticazione. Fatto questo, Claude Code è pronto.

Ora crea il file CLAUDE.md con il contenuto che abbiamo visto prima. Puoi farlo con qualsiasi editor di testo, oppure chiedere direttamente a Claude di generarlo:

Claude analizzerà la richiesta, farà domande se servono dettagli, e scriverà il file per te. Tu controlli il risultato e, se ti piace, lo tieni. Altrimenti chiedi modifiche. È una conversazione, non un deploy.

Qui serve un passaggio tecnico ma una tantum. Devi creare le credenziali OAuth per Gmail nella Google Cloud Console, poi configurare il server MCP.

Claude Code ti guida in questo passaggio se glielo chiedi:

Claude ti dirà esattamente cosa fare: abilitare l’API Gmail, creare un OAuth consent screen, generare le credenziali. Non sto a elencare i passaggi qui perché la procedura esatta cambia nel tempo, ma la sostanza è: segui le istruzioni di Claude, copia e incolla quello che ti dice, e in dieci minuti hai Gmail connessa in sola lettura.

Ora esegui l’agente:

Claude partirà con l’agentic loop: leggerà CLAUDE.md, si connetterà a Gmail via MCP, recupererà i messaggi, li analizzerà, e produrrà il riepilogo. Vedrai il ragionamento scorrere a schermo — ogni tool chiamato, ogni decisione presa.

Ora viene la parte più importante: valuta l’output. Il riepilogo è utile? Manca qualcosa? Classifica male le urgenze? Il tono non ti piace?

Ogni modifica la fai in CLAUDE.md. Non tocchi codice. Aggiungi una regola, cambi un vincolo, modifichi il formato dell’output. Poi riesegui.

Io di solito faccio tre o quattro iterazioni prima di essere soddisfatto. È normale. L’agente migliora a ogni giro perché le istruzioni diventano più precise.

Dopo qualche esecuzione potresti notare che la classificazione delle urgenze non è sempre consistente. Qui entra in gioco il sub-agente.

Crea una cartella subagents/ e dentro un file classificatore-urgenze/CLAUDE.md:

Il contenuto di CLAUDE.md per il sub-agente:

Poi modifichi il CLAUDE.md dell’agente principale per delegare la classificazione a questo sub-agente. Di nuovo, puoi chiedere a Claude di farlo per te:

L’agente funziona. Ora vuoi poterlo eseguire con un solo comando, tutte le volte che ti serve. Crea uno skill — un comando personalizzato che incapsula l’intera routine.

Nella cartella .claude/skills/ crei un file riepilogo-inbox.md:

Ora puoi eseguire il tuo agente con:

E se un giorno vuoi automatizzarlo del tutto, puoi schedulare questo comando con un cron job o un’automazione CI/CD. Zero codice aggiuntivo.

Ho visto abbastanza progetti di agenti per riconoscere il pattern di fallimento più comune. Non è la tecnologia. Non è il modello sbagliato. Non è la mancanza di tool.

È lo scope creep. Inizi con “riepiloga le email”, e dopo due ore hai deciso che l’agente deve anche auto-rispondere, archiviare in cartelle, sincronizzare col calendario e scrivere la newsletter. Ora niente funziona, non sai quale parte è rotta, e molli tutto.

La disciplina più importante nella costruzione di agenti non è tecnica: è dire di no. Dire no a funzionalità extra prima che il nucleo funzioni. Dire no a tool di scrittura quando la sola lettura basta. Dire no all’automazione completa prima di aver validato il loop manualmente per una settimana.

L’agente che abbiamo costruito è piccolo, mirato, con un compito solo. Proprio per questo funziona. E una volta che funziona, aggiungere un secondo tool o un altro sub-agente è facile e prevedibile. Partire piccoli non è una limitazione: è la strategia vincente.

Una volta padroneggiato il pattern — CLAUDE.md + MCP + sub-agents — il ventaglio di possibilità si allarga in modo naturale. Qualche idea concreta:

Agente di code review. Legge le pull request del giorno, controlla pattern di bug noti, suggerisce miglioramenti. Connesso a GitHub via MCP, esegue test, commenta direttamente sulla PR.

Agente di ricerca e report. Monitora un topic su più fonti (news, paper, social), estrae i punti chiave, produce un briefing settimanale. Connesso a web search e Perplexity via MCP.

Agente di manutenzione database. Controlla lo stato delle tabelle, trova indici mancanti, segnala query lente. Connesso a PostgreSQL via MCP, produce un report Markdown.

Agente di onboarding. Quando arriva un nuovo sviluppatore, legge la documentazione del progetto, genera un percorso di onboarding personalizzato, risponde a domande sul codice. Connesso al repository e alla wiki aziendale.

Il pattern è sempre lo stesso. Cambiano i tool MCP, cambia il CLAUDE.md, ma l’architettura è identica. È il bello di un approccio dichiarativo: descrivi il comportamento, non lo implementi.

Nessuna tecnologia è magica, e Claude Code non fa eccezione. Ecco le cose da sapere prima di entusiasmarti troppo.

Il contesto ha un limite. Claude ha una finestra di contesto ampia ma non infinita. In sessioni molto lunghe, le istruzioni iniziali possono essere compattate e dimenticate. Per questo le regole permanenti vanno in CLAUDE.md (che viene ricaricato) e i compiti complessi vanno delegati a sub-agents.

I tool hanno costi reali. Ogni chiamata API a Gmail, ogni query al database, ogni ricerca web consuma risorse. Non è gratis. Inizia con agenti leggeri — poche chiamate, contesto ridotto — e scala solo quando hai validato il valore.

La verifica è ancora umana. Per quanto l’agente verifichi il proprio output, la responsabilità finale è tua. Non delegare azioni irreversibili (invio email, cancellazione dati, transazioni finanziarie) senza un controllo umano. Almeno finché non hai fiducia assoluta nel loop, e anche in quel caso, un controllo esplicito è la scelta saggia.

Non tutto si presta al no-code. Claude Code è straordinario per compiti basati su tool esistenti. Ma se il tuo agente deve eseguire logica di business complessa, trasformazioni dati arbitrarie o integrazioni con sistemi legacy senza API, prima o poi il codice servirà. Il no-code eccelle nel collegare mattoni esistenti; quando i mattoni non esistono, qualcuno li deve costruire.

Abbiamo iniziato con una domanda: quanto può fare un agente se lo descrivi invece di programmarlo? La risposta, dopo aver costruito insieme un agente funzionante in meno di un’ora, è che puoi fare moltissimo.

Claude Code ribalta la prospettiva tradizionale. Invece di chiederti “quale codice devo scrivere per far fare X al computer”, ti chiedi “quali istruzioni devo dare a un modello linguistico perché faccia X usando i tool che ha a disposizione”. Sembra una differenza sottile, ma è un cambio di paradigma.

Non stai programmando un agente. Lo stai addestrando, con istruzioni in linguaggio naturale, iterazioni rapide, e una disciplina da product manager più che da sviluppatore. Il ciclo è: descrivi il compito, esegui, valuti l’output, aggiusti CLAUDE.md, riesegui. Non è diverso da come daresti istruzioni a un nuovo collaboratore, se ci pensi.

Il punto non è se questo approccio sostituirà del tutto la programmazione tradizionale — non lo farà, e non deve farlo. Il punto è che apre la costruzione di agenti a chi non sa programmare, e accelera drasticamente la prototipazione per chi sa programmare ma vuole validare un’idea in un pomeriggio invece che in una settimana.

Il primo agente è sempre il più difficile. Poi diventa un pattern. Poi diventa un’abitudine. Poi ti ritrovi con una piccola squadra di agenti che fanno cose mentre tu fai altro. E a quel punto ti chiedi come facevi prima.

AI Disclaimer