Come Skills, Agenti e Server MCP Lavorano Insieme in Claude Code

Probabilmente ti sei già scontrato con questo problema: incolli l'intera codebase in una chat AI, aggiungi un prompt dettagliato e ottieni... niente di utile. O peggio, il modello inizia ad allucinare nomi di funzioni che non esistono perché ha perso traccia di ciò che ha letto 50.000 token fa.

Questo è il problema della finestra di contesto. Ed è per questo che buttare più codice a un LLM non lo rende più intelligente.

Claude Code risolve questo problema in modo diverso. Non avendo una finestra di contesto più grande (anche se aiuta), ma essendo intelligente su come usa lo spazio che ha. Lo fa attraverso tre elementi che lavorano insieme: skills, sotto-agenti e server MCP.

Lascia che ti mostri come questi pezzi si incastrano. Una volta compreso questo, smetterai di combattere contro l'AI e inizierai a lavorare con essa.

Il Problema della Finestra di Contesto

Ecco qualcosa che mi ci è voluto un po' per interiorizzare: gli LLM non "ricordano" effettivamente l'inizio di una lunga conversazione come ti aspetteresti. La finestra di contesto è più simile a un riflettore che a un archivio. Man mano che aggiungi più token, i contenuti precedenti ricevono meno attenzione. Incolla 100.000 token di codice e il modello sta essenzialmente sfogliando quando arriva alla tua domanda.

Questo spiega molti comportamenti frustranti dell'AI. Il modello sembra intelligente all'inizio, poi si confonde. Dimentica cose che gli hai detto prima. Allucina dettagli da file che ha "letto" ma chiaramente non ha memorizzato.

La soluzione non è una finestra di contesto più grande. La soluzione è non averne bisogno.

Come Pensa Realmente Claude Code

Claude Code è un agente. Suona elegante, ma significa semplicemente che può pianificare, eseguire, osservare i risultati e iterare. Quando gli chiedi di "correggere i test che falliscono nel mio progetto", non cerca di capire l'intera codebase in una volta. Invece, lavora in passaggi mirati:

1. Legge la struttura del progetto per capire cosa c'è dove
2. Esegue i test per vedere cosa sta effettivamente fallendo
3. Guarda il test specifico che fallisce e il codice che testa
4. Fa una correzione
5. Esegue di nuovo i test
6. Se ancora rotto, prova qualcos'altro

Ogni passaggio lavora solo con il contesto di cui ha bisogno. L'agente mantiene un riepilogo funzionale di ciò che ha imparato, non un registro grezzo di tutto ciò che ha visto. È così che Claude Code può iterare 20 volte su un bug complesso senza esaurire lo spazio di contesto.

Pensalo come faresti effettivamente il debug di qualcosa. Non tieni l'intera codebase nella tua testa. Ti concentri su un'area, formi un'ipotesi, la testi e ti adatti. Claude Code funziona allo stesso modo.

Sotto-Agenti: Il Vero Game Changer

Ecco dove diventa davvero interessante. Claude Code può generare sotto-agenti.

Un sotto-agente è un'istanza Claude separata con la propria finestra di contesto pulita. Puoi dire a Claude Code di crearne uno, dargli un compito mirato, lasciarlo lavorare in modo indipendente e ottenere un riepilogo di ciò che ha trovato. Il contesto completo del sotto-agente non inquina mai la tua conversazione principale.

Questo è enorme. Invece di un agente che cerca di tenere tutto:

Tu: "Analizza questa codebase per problemi di sicurezza, problemi di performance e copertura dei test"

L'agente principale genera sotto-agenti: ├── Sotto-agente 1: Analisi sicurezza (proprio contesto, legge file rilevanti per la sicurezza) ├── Sotto-agente 2: Revisione performance (proprio contesto, si concentra sui percorsi critici)
└── Sotto-agente 3: Copertura test (proprio contesto, esamina i file di test)

Ogni sotto-agente restituisce un riepilogo all'agente principale L'agente principale sintetizza tutto in una risposta

I sotto-agenti possono leggere migliaia di righe di codice ciascuno. Ma l'agente principale riceve solo i loro risultati condensati. Il tuo contesto principale rimane pulito pur ottenendo un'analisi approfondita su più aree.

Pensalo come delegare a sviluppatori junior. Non hai bisogno di leggere ogni riga che hanno revisionato. Hai bisogno delle loro conclusioni e di eventuali segnali d'allarme che hanno trovato. I sotto-agenti funzionano allo stesso modo.

Come Usare Effettivamente i Sotto-Agenti

Puoi chiedere esplicitamente a Claude Code di generare un sotto-agente:

• "Genera un sotto-agente per analizzare in profondità il modulo di autenticazione"
• "Usa un sotto-agente per rivedere tutte le query del database per problemi N+1"
• "Fai in modo che un sotto-agente esamini i file di test e riporti le lacune nella copertura"

Il sotto-agente ottiene il proprio contesto fresco, fa il lavoro approfondito e restituisce un riepilogo. La tua conversazione principale non si gonfia con tutta l'analisi grezza.

Questo è particolarmente potente per codebase di grandi dimensioni. Invece che Claude Code perda traccia delle cose a metà strada, ottieni un'analisi mirata che scala effettivamente.

Dove Entrano in Gioco le Skills

Quindi Claude Code può suddividere i compiti, generare sotto-agenti e lavorare in passaggi mirati. Ma come fa a sapere come fare cose specifiche bene? È qui che entrano in gioco le skills.

Le skills sono istruzioni confezionate che Claude legge prima di affrontare tipi specifici di compiti. Quando chiedi a Claude Code di creare una presentazione PowerPoint, prima legge il file skill in /mnt/skills/public/pptx/SKILL.md. Questo file contiene best practice, insidie comuni e pattern di codice esatti che funzionano effettivamente.

Una skill include tipicamente:

• Un file SKILL.md con istruzioni dettagliate
• Template di codice ed esempi
• Limitazioni note e soluzioni alternative
• Specifiche del formato di output

L'intuizione chiave è che le skills vengono caricate su richiesta. Claude non spreca spazio nella finestra di contesto con istruzioni PowerPoint quando stai facendo il debug di Python. Carica la skill rilevante quando ne ha bisogno, usa quell'expertise per il compito e va avanti.

Questo è diverso dagli strumenti. Gli strumenti sono funzioni che Claude chiama per ottenere dati, come web_search o bash_tool. Le skills sono pacchetti di conoscenza che cambiano il modo in cui Claude affronta i problemi. La distinzione è importante perché gli strumenti costano token nel prompt di sistema (più strumenti = meno spazio per il tuo codice), mentre le skills vengono caricate solo quando rilevanti.

Anche i sotto-agenti possono caricare skills. Un sotto-agente che analizza la sicurezza può caricare skills specifiche per la sicurezza senza che quelle istruzioni ingombrino la tua conversazione principale.

Il Ciclo di Iterazione

Un pattern che vedrai costantemente è il ciclo di iterazione. Claude Code genera qualcosa, controlla se funziona e corregge i problemi finché non è giusto.

1. Genera codice
2. Eseguilo (o fai il lint, o il type-check)
3. Vedi se funziona
4. Se no, analizza l'errore e riprova
5. Ripeti finché non passa

È per questo che Claude Code può correggere bug che un prompt singolo perderebbe. Non sta solo generando codice e sperando. Sta testando il proprio lavoro e rispondendo a feedback reali.

Quando Claude Code crea un componente React e poi esegue il server di sviluppo per controllare gli errori, sta usando questo ciclo. Quando scrive una funzione ed esegue i test per verificare che funzioni, stessa cosa. I passaggi di generazione e verifica lavorano insieme.

Questo spiega anche perché Claude Code a volte impiega più tempo del previsto. Non è lento. È accurato. Sta eseguendo i tuoi test, controllando gli errori di tipo e iterando finché le cose non funzionano effettivamente.

Server MCP: Connessione a Sistemi Esterni

Finora abbiamo parlato di come pensa Claude Code (passaggi agentici, sotto-agenti) e cosa sa (skills). Ma per quanto riguarda la connessione a sistemi esterni? È qui che entra in gioco MCP.

Il Model Context Protocol è il modo in cui Claude Code parla con database, GitHub, file system, pipeline CI/CD e praticamente qualsiasi altra cosa. Pensa a MCP come USB-C per l'AI: un'interfaccia standard che permette a qualsiasi sistema AI compatibile di connettersi a qualsiasi servizio compatibile.

I server MCP espongono tre tipi di capacità:

Strumenti: Funzioni che Claude può chiamare, come interrogare un database o creare una pull request

Risorse: Sorgenti di dati che Claude può leggere, come contenuti di file o schemi di database

Prompt: Template riutilizzabili per interazioni comuni

Per lo sviluppo web, i server MCP più utili includono:

• Server filesystem: Legge e scrive file nel tuo progetto (sandboxed per sicurezza)
• Server GitHub: Gestisce repo, PR, issue e workflow
• Server database: Interroga PostgreSQL, MySQL, SQLite attraverso linguaggio naturale

Ecco come appare un semplice server MCP in TypeScript: typescript import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new McpServer({ name: 'code-analyzer', version: '1.0.0' });

server.registerTool( 'analyze_complexity', { description: 'Analyze cyclomatic complexity of a file', inputSchema: { filePath: { type: 'string' } } }, async ({ filePath }) => { const result = await analyzeFile(filePath); return { content: [{ type: 'text', text: JSON.stringify(result) }] }; } );

const transport = new StdioServerTransport(); await server.connect(transport);

Il potere dei server MCP deriva da come lavorano con i sotto-agenti. Un sotto-agente può interrogare un database attraverso MCP, analizzare migliaia di righe e restituire solo i risultati rilevanti. I dati grezzi non toccano mai il tuo contesto principale.

Mettere Tutto Insieme

Percorriamo un esempio reale. Chiedi a Claude Code: "Rivedi questa PR e controlla se le migrazioni del database sono sicure."

Ecco cosa succede effettivamente:

1. L'agente principale carica le skills rilevanti per la revisione del codice
2. Genera un sotto-agente per analizzare in profondità le modifiche della PR
3. Quel sotto-agente chiama il server MCP di GitHub per recuperare i dettagli della PR
4. Un altro sotto-agente legge i file di migrazione e interroga lo schema del database corrente attraverso MCP
5. I sotto-agenti restituiscono riepiloghi mirati: "La migrazione aggiunge un indice, sembra sicura" o "Attenzione: questo elimina una colonna ancora referenziata"
6. L'agente principale sintetizza i risultati dei sotto-agenti in una risposta chiara

Nota come il lavoro pesante avviene nei sotto-agenti con i propri contesti. L'agente principale orchestra e riassume. La tua conversazione rimane pulita pur ottenendo un'analisi approfondita.

Perché Questo È Importante Per Il Tuo Flusso di Lavoro

Comprendere questa architettura cambia il modo in cui lavori con Claude Code:

Smetti di combattere contro la finestra di contesto. Una volta che realizzi che i sotto-agenti gestiscono l'analisi approfondita separatamente, smetti di cercare di incollare l'intera codebase nella conversazione principale. Lascia che i sotto-agenti facciano la lettura pesante.

Usi esplicitamente i sotto-agenti per compiti grandi. Invece di sperare che Claude Code lo capisca, digli: "Usa un sotto-agente per analizzare il modulo di pagamento" o "Genera sotto-agenti per revisione sicurezza, performance e test." Stai lavorando con l'architettura invece che contro di essa.

Capisci perché alcuni compiti funzionano meglio di altri. I compiti che possono essere delegati ai sotto-agenti scalano benissimo. I compiti che richiedono continui scambi in un contesto raggiungono i limiti più velocemente.

Ti fidi del ciclo di iterazione. Quando correggi bug, lascia iterare Claude. Spesso troverà problemi che non avevi anticipato eseguendo effettivamente il codice e osservando i fallimenti. Non interromperlo dopo il primo tentativo.

Consigli Pratici

Chiedi esplicitamente sotto-agenti per compiti grandi. "Genera un sotto-agente per rivedere il sistema di autenticazione" funziona meglio che sperare che Claude Code capisca che deve delegare.

Lascia che Claude legga prima le skills. Se stai creando documenti o lavorando con formati di file specifici, Claude performa meglio quando legge il file skill rilevante prima di iniziare.

Connetti server MCP per integrazioni ripetitive. Invece di copiare e incollare output di database o dettagli di PR di GitHub nei tuoi prompt, connetti i server MCP rilevanti. Claude estrae esattamente ciò di cui ha bisogno.

Controlla l'ecosistema prima di costruire strumenti personalizzati. L'ecosistema MCP è cresciuto fino a oltre 5.000 server della community che coprono Stripe, Cloudflare, sistemi CI e la maggior parte dei servizi che vorresti integrare. Probabilmente qualcuno ha già costruito ciò di cui hai bisogno.

Dai feedback quando sbaglia. Quando Claude Code produce risultati sbagliati, digli cosa è andato storto. Il ciclo di iterazione funziona anche per il tuo feedback.

Il Quadro Generale

MCP è stato recentemente donato alla Linux Foundation, con OpenAI, Google e Microsoft che si sono uniti come membri sostenitori. Questo segnala che il protocollo sta diventando un'infrastruttura standard del settore, non solo una cosa di Anthropic.

La combinazione di sotto-agenti (lavoro parallelo in contesti separati), skills (expertise di dominio caricata su richiesta) e server MCP (connessioni pulite a sistemi esterni) rappresenta come funzionano effettivamente gli assistenti di codifica AI moderni. Non è magia. È una buona architettura che risolve vincoli reali.

Il pattern dei sotto-agenti in particolare vale la pena comprendere profondamente. È la differenza tra un'AI che si blocca su codebase grandi e una che scala. Quando chiedi a Claude Code di analizzare qualcosa di grande, non sta stipando tutto in un contesto e pregando. Sta delegando a sotto-agenti mirati, ciascuno con contesto pulito, e sintetizzando i loro risultati.

Comprendere questi pezzi ti aiuta a lavorare con il sistema invece che contro di esso. Otterrai risultati migliori, incontrerai meno ostacoli e saprai quando fidarti dell'AI rispetto a quando prendere il controllo manualmente.