Come lavoro con l'AI nello sviluppo: il mio metodo

Sono Giorgio Alfredo Pagano e lavoro con l'AI seguendo un filo conduttore: un metodo mio, che decide cosa chiedere, a chi e come verificarlo. Con Claude Code analizzo il problema, lo scompongo in task atomici e li delego a un server che smista il lavoro fra Opus, Sonnet e due modelli Qwen3, accende gli ambienti su richiesta e tiene in ctx-memory le decisioni condivise fra le sessioni. Ogni consegna la verifico io.

Lavoro con l'AI seguendo un filo conduttore. Nella mia esperienza, chiedere a Claude o a ChatGPT una cosa alla volta produce pezzi che funzionano da soli e non si tengono insieme. Il mio metodo decide invece cosa chiedere, a quale modello, con quale contesto, e come verificare il risultato.

L'AI ha cambiato il mio modo di lavorare da sviluppatore Drupal freelance, e il metodo resta mio. Le deleghe arrivano a un server che fa da nucleo remoto: smista i task fra i modelli, accende gli ambienti su richiesta e ricorda le decisioni prese. Qui racconto come è fatto, e cosa dicono le misure.

Qual è il filo conduttore quando lavoro con l'AI?

Il filo conduttore sono quattro passaggi, che seguo sempre nello stesso ordine:

  1. Analizzo il problema. Raccolgo in un brief tutte le informazioni: cosa va fatto, perché, con quali vincoli.
  2. Definisco il flusso scomponendo il problema in task atomici. Scrivo la lista completa dei passi e uso l'AI per controllarla: coprire tutti i passi, trovare le lacune funzionali che la lista lascia scoperte, tenere il filo fra una sessione e l'altra. Il lavoro nasce da una issue su GitLab, il codice passa da un change di OpenSpec che fissa la specifica, e le scelte di architettura finiscono in un ADR.
  3. Delego al sistema. Ogni task va al modello adatto, con una specifica precisa.
  4. Verifico e decido. Rileggo tutto quello che torna, prima del push. Il giudizio finale resta mio.

L'AI lavora dentro questi passaggi e mi toglie il volume di lavoro: scrivere e rileggere log. La direzione resta mia.

Che ruolo ha il server nel flusso?

Il server è il centro di tutto il flusso: nel tempo è diventato un sistema di microservizi che accompagnano lo sviluppo e centralizzano le attività comuni: oggi è fatto di molti container, divisi in progetti Docker Compose separati. Sulla stessa macchina girano GitLab con la CI, Ollama con i modelli locali, ctx-memory con la memoria delle decisioni, il registro delle skill e gli ambienti di sviluppo dei progetti.

Centralizzare tiene tutto allineato. Le skill stanno in un registro sul server, e il sistema propaga gli aggiornamenti in automatico a ogni macchina da cui lavoro. Alcune girano direttamente sul server, accanto a Ollama, e restituiscono a Claude solo l'esito. Nel sistema ci sono anche una gestione a parte per i dati sensibili e la condensazione del testo con Caveman, che accorcia i messaggi prima che arrivino a Claude.

L'hardware è un AMD Ryzen 9 9950X con molta RAM e senza scheda grafica: per ora bastano CPU e RAM.

Come smista il lavoro il server?

Con una tabella di regole scritta nelle istruzioni globali di Claude Code, che vale in ogni sessione senza doverla ripetere. Un server MCP riceve le deleghe e le manda a destinazione:

Il lavoro è… Va a
un file nuovo e autocontenuto di al massimo 150 righe, una modifica meccanica, una ricerca nel repository un sotto-agente Haiku
codice che chiede il contesto del repository, più file insieme, test un sotto-agente Sonnet
un ramo irreversibile, con una specifica che non si riesce a scrivere per intero un sotto-agente Opus dedicato
un log lungo da capire, i controlli dei testi delle skill, dati che restano nella mia rete Qwen3 instruct su Ollama
una modifica di poche righe Opus, direttamente
architettura, sintesi, revisione, decisioni Opus

Opus, il modello che guida la sessione, progetta e rivede, e il volume di codice lo scrivono i sotto-agenti. Ogni sotto-agente lavora nel proprio contesto: Opus manda la specifica, riceve un resoconto breve e legge il codice solo quando lo rivede. I token che così restano fuori dal contesto, e il modo in cui verifico il lavoro dei sotto-agenti, sono in Perché delego il codice ai sotto-agenti di Claude Code?

Una regola riguarda Ollama spento. Svegliarlo costa del tempo, una volta per sessione, e il sistema lo considera un costo da pagare, perché vale per tutto il lavoro che segue. Quando Ollama è irraggiungibile, il log va a Haiku.

Come si accendono gli ambienti solo quando servono?

Gli ambienti si accendono da soli grazie a Traefik e Sablier. Traefik riceve le richieste per tutti i servizi del server, e Sablier tiene spenti i container finché qualcuno li chiama, li avvia alla prima richiesta e li ferma dopo un periodo di inattività. La maggior parte dei container funziona così, divisa in gruppi: gli ambienti dei siti, ctx-memory, gli strumenti AI, perfino il browser che uso per generare le immagini. Mentre scrivo, la maggior parte di questi dorme.

Il risultato è che ogni ambiente è pronto quando lo apro, e la macchina lascia la memoria a Ollama quando gli ambienti dormono.

Come evito di rispiegare il contesto a ogni sessione?

Con ctx-memory, il mio sistema RAG di attività e decisioni, costruito su Drupal 11 e Typesense. Le issue dicono cosa è stato fatto, mentre ctx-memory tiene il perché, con la prova accanto, e lo condivide fra le sessioni di Claude. Così una sessione nuova parte dal contesto già definito, invece di ridefinire attività e decisioni da capo.

Lo uso sempre da Claude. Un server MCP espone tre strumenti, cerca, leggi e cattura, e una skill dedicata insegna all'agente come usarli: quando apro una sessione su un progetto, l'agente recupera le decisioni che lo riguardano e lavora con quel contesto davanti. Quando decido qualcosa, la stessa skill la scrive nel grafo. Due hook catturano da soli: ogni proposal.md di un change OpenSpec entra come evidenza con la decisione che dichiara, e ogni ADR committato entra con il permalink al commit.

Sotto, Drupal fa da database del grafo: contesti, decisioni, evidenze e relazioni sono entità Drupal con revisioni e permessi, e Typesense, collegato con Search API, le indicizza per la ricerca. Una decisione catturata nasce sempre «proposta», e la conferma solo io. I componenti e le quattro regole che tengono affidabile la memoria sono in ctx-memory: come ho costruito su Drupal la memoria delle decisioni per Claude.

Quanto lavoro passa dal modello locale?

Il modello locale prende il lavoro di lettura: log da riassumere e i controlli dei testi delle skill. Fino al 21 ottobre 2026 scriveva anche file e diff; da allora il codice va ai sotto-agenti di Claude. Il sistema registra ogni delega, con i token che il modello locale legge e quelli che scrive, e il conteggio riguarda solo il lavoro con Claude, cioè skill e tool MCP, senza le altre applicazioni che usano Ollama sul server.

I token letti sono i log e i file che altrimenti avrebbe letto Claude, insieme alle istruzioni che servono al modello locale. Quelli scritti sono il risultato che avrebbe dovuto produrre Claude.

Il risparmio reale è più ampio, perché ogni file che Claude legge resta nel suo contesto per i turni successivi. Il dato che conta per me è pratico: con la delega arrivo a fine settimana, prima arrivavo a metà.

Quanto rende un modello locale su CPU?

Qwen3 su CPU chiude un lavoro breve in tempi che non fanno aspettare: vale per una skill eseguita sul server e per il riassunto di un log.

Le guide in rete sconsigliano Qwen3-Coder senza una scheda grafica adatta. Quella di Conduction misura circa 6 minuti per risposta con una GPU da 8 GB, che lascia il 68% del modello sulla CPU. La differenza sta nel modello: i Qwen3 che ho usato sono 30B-A3B, mixture-of-experts da 30 miliardi di parametri, di cui circa 3 miliardi lavorano per ogni token, quantizzati a 4 bit per occupare poca memoria. Per questo rispondono alla velocità di un modello molto più piccolo. Questi tempi valgono per questa macchina e per lavori brevi, come una skill o il riassunto di un log.

Anche l'affidabilità regge: i tentativi a vuoto sono rari, e il sistema li conta a parte, fuori dalle statistiche dei risparmi.

Come verifico quello che torna dalle deleghe?

Rileggo ogni consegna prima del push, perché delegare la stesura lascia a me la responsabilità del risultato. In una giornata di lavoro ho annotato i difetti di ogni consegna delegata, e ognuna ne aveva almeno uno: un'opzione --quiet che lasciava passare l'output, un comm lanciato su file non ordinati, commenti di esempio copiati da un modulo del core, un verdetto dichiarato senza una prova a sostegno. Sono difetti piccoli, e passano proprio per questo. Skill e script della pipeline fanno controlli automatici prima del merge: identificatori in inglese, traduzioni, configurazione esportata.

Un caso reale

Su AI Disclosure, il modulo che ho creato su drupal.org, è arrivata una segnalazione: sostituendo un'immagine, il sito teneva la decisione presa per quella vecchia. Il giro è stato quello descritto sopra, con il mio ok a ogni passaggio pubblico. A ogni passaggio ho verificato il flusso completo su un sito di prova, ho provato il codice dal vivo e ne ho controllato la qualità riga per riga, e la correzione è entrata nel modulo in giornata. L'AI è uno strumento in più: il lavoro e la responsabilità restano miei. (La issue su drupal.org (si apre in una nuova scheda))

Fonti

Le informazioni sul sistema sono state lette il 1 ottobre 2026 sul server dove gira il sistema; la tabella di smistamento è aggiornata al 24 ottobre 2026.

Modificato dall'AI

Questo contenuto è stato prodotto dall'AI e rivisto da una persona.

Come è stata usata l'AI?

Le bozze sono prodotte con l'assistenza dell'AI, poi dirette, rivedute e verificate da una persona. Numeri, date e versioni sono confrontati con le fonti pubbliche prima della pubblicazione, e la data di quel controllo è indicata nel testo.