Cinque sviluppatori, un repository, cinque sessioni di Claude Code. Ognuna parte con la finestra di contesto vuota, e ognuna impara piano piano le stesse cose: come si lanciano i test, quale cartella non va toccata, perché il modulo della fatturazione è fatto così. Una parte di quello che impara arriva al resto del team. Molto no.
Questo articolo separa le due cose. Cosa Claude Code condivide già attraverso il repository, cosa resta sul computer di ognuno, e come dare a tutto il team una memoria sola che copra anche quello che nel codice non ci sta. I fatti su Claude Code sono verificati sulla documentazione ufficiale il 9 novembre 2026.
Cosa Claude Code condivide con il team: il CLAUDE.md in git
La documentazione elenca quattro posti per il CLAUDE.md, e per ognuno dice con chi è condiviso. Il file di progetto, ./CLAUDE.md o ./.claude/CLAUDE.md, è condiviso con i membri del team «via source control»: lo committi come qualsiasi altro file, e chiunque scarichi il repository riceve le stesse istruzioni all'inizio delle sue sessioni.
Gli altri tre sono più stretti. ~/.claude/CLAUDE.md è tuo, per tutti i tuoi progetti. CLAUDE.local.md nella cartella principale del progetto serve per le tue preferenze private su quel progetto, e la documentazione dice di non metterlo sotto controllo di versione. Poi c'è il file gestito centralmente, che un'azienda distribuisce sulle macchine (su Linux sta in /etc/claude-code/CLAUDE.md) e che vale per tutti gli utenti di quel computer.
In un progetto grande le istruzioni si possono dividere in più file dentro .claude/rules/. Una regola senza il campo paths si carica all'avvio come il CLAUDE.md. Una regola con paths nel frontmatter si carica solo quando Claude legge o modifica un file che corrisponde, così le convenzioni del frontend non occupano spazio mentre qualcuno lavora sul database.
Anche i subagent possono avere una memoria. Con memory: project nella definizione del subagent, i suoi appunti finiscono in .claude/agent-memory/<nome>/ dentro il repository, e la documentazione dice che in quel caso si condividono con il controllo di versione.
Cosa resta sul computer di ogni sviluppatore
La memoria automatica è la parte che molti pensano condivisa, e non lo è. Claude Code la scrive in ~/.claude/projects/<progetto>/memory/, nella tua cartella utente, e la documentazione è chiara: la memoria automatica resta sulla macchina, e i file non si condividono tra computer o ambienti cloud. Come funziona l'abbiamo spiegato in La memoria di Claude Code.
Dove sta ogni pezzo
repository/CLAUDE.mdil team, via git.claude/rules/il team, via git.claude/agent-memory/il team, con memory: projectCLAUDE.local.mdsolo tu, non si committa~/.claude/CLAUDE.mdsolo tu, tutti i progettiprojects/<progetto>/memory/solo tu, questo computer
Quindi la lezione che il tuo Claude Code ha imparato martedì, per esempio che i test delle API vogliono un Redis locale, sta in una cartella del tuo portatile. Il Claude Code del tuo collega la scopre di nuovo da solo, oppure no. Non c'è niente di rotto: la memoria automatica è nata per ricordare come lavori tu. Solo che non è uno strumento di team.
Dove il repository non basta più
Mettere le conoscenze in git funziona bene per tutto quello che riguarda il codice e cambia insieme a lui: comandi di build e convenzioni del progetto, per esempio. Con il resto diventa scomodo.
Ogni appunto diventa un commit. Scrivere «il cliente ha approvato il nuovo checkout» vuol dire un ramo, una pull request e una revisione, per una frase che non è codice. Dopo una settimana non lo fa più nessuno, e la decisione finisce in una chat.
Molte delle persone che sanno le cose il repository non ce l'hanno. Il project manager che ha concordato la scadenza lavora nell'app di Claude, o in ChatGPT. La designer non ha mai clonato niente. Quello che decidono non arriva nel CLAUDE.md, a meno che uno sviluppatore non lo copi a mano.
Le conoscenze su un cliente stanno sparse fra più repository. Un'agenzia che fa sito, app e backend per lo stesso cliente ha tre CLAUDE.md e nessun posto unico per quello che il cliente vuole.
E il CLAUDE.md si carica tutto a ogni sessione. Più storia ci metti, più contesto occupa prima che qualcuno abbia scritto una parola. Un anno di decisioni lì dentro non ci sta.
| Nel repository | Note condivise via MCP | |
|---|---|---|
| Arriva a ogni sviluppatore | ||
| Scrivere un appunto | un commit e una revisione | lo scrive Claude |
| Chi non ha il repository | ||
| La leggono altre AI | ||
| Cosa si carica a ogni sessione | tutto il CLAUDE.md | quello che si cerca |
Una memoria condivisa per Claude Code, impostata una volta per tutto il team
Claude Code si collega ai server MCP, e la documentazione prevede tre ambiti (scope). L'ambito di progetto scrive il server in un file .mcp.json nella cartella principale del repository, e la documentazione consiglia di committarlo perché tutto il team abbia gli stessi strumenti.
È il pezzo che trasforma una memoria condivisa in un'impostazione del team. Uno sviluppatore aggiunge il server della memoria con l'ambito di progetto, per esempio claude mcp add --transport http --scope project <nome> <url>, e committa .mcp.json. Gli altri lo ricevono al prossimo pull. Per sicurezza, Claude Code chiede a ognuno di approvare un server di progetto prima di usarlo in una sessione interattiva. Se il server usa OAuth, ognuno entra da /mcp nel suo browser.
Una memoria per tutto il team
- 1Aggiungi il servercon --scope project
- 2Committa .mcp.jsonparte con git
- 3Ognuno approvaed entra da /mcp
- 4Due righe nel CLAUDE.mdquando leggere, quando scrivere
Poi bastano due righe nel CLAUDE.md del progetto per dire a Claude Code cosa farne: caricare le note del progetto all'inizio della sessione e scrivere lì le decisioni nuove, invece che in un file locale. Da quel momento la trappola scoperta martedì è una nota che il Claude Code di ogni collega trova mercoledì.
Dove entra Cobrain
Cobrain è una memoria condivisa fatta di note Markdown in cartelle, dietro un indirizzo MCP remoto. Lo colleghi a Claude Code in pochi minuti (i passi sono nella guida), e le stesse note le leggono anche l'app di Claude, ChatGPT, Codex e Cursor. Ogni cliente o progetto è una cartella con le sue regole e decisioni. start_session dà a Claude il briefing di quella cartella: regole, scheda, ultime decisioni e ultime modifiche. Poi Claude cerca nelle note e legge solo quello che serve, invece di caricare tutto all'avvio: perché conta lo spieghiamo in costi di contesto.
Ognuno entra con il suo account, quindi ogni Claude Code vede quello che vede la sua persona. Condividi una cartella via email, in sola lettura o con permesso di scrittura. Ogni nota dice chi l'ha cambiata, una persona o una delle sue AI, e la versione precedente resta. Chi riceve una condivisione non paga mai; col Pro scrive una persona oltre a te, e il piano Team aggiunge un brain per tutta la squadra con un posto per ognuno. I dettagli sono in Cobrain in team.
La divisione che suggeriamo è semplice. Il CLAUDE.md resta nel repository e resta corto, perché parla di come si lavora sul codice, e la memoria automatica può tenersi le tue abitudini. Quello che sa il team va in un posto dove ogni AI del team ci arriva.
Domande rapide
Claude Code condivide la memoria tra i membri del team?
Solo quello che sta nel repository. Il CLAUDE.md di progetto, .claude/rules/ e la memoria dei subagent con ambito project viaggiano con git. La memoria automatica resta sul computer di ogni sviluppatore.
La memoria automatica di Claude Code si condivide tra computer? No. La documentazione dice che resta sulla macchina e che i suoi file non si condividono tra computer o ambienti cloud.
CLAUDE.local.md va committato? No. Serve per le tue preferenze private su un progetto, e la documentazione dice di non metterlo sotto controllo di versione.
Come do a tutto il team lo stesso server MCP in Claude Code?
Aggiungilo con l'ambito di progetto, che lo scrive in .mcp.json nella cartella principale del repository, e committa quel file. Ognuno approva il server la prima volta e, se usa OAuth, entra da /mcp.
Dove tiene un team le decisioni che non riguardano il codice? Fuori dal repository, in note che ogni AI raggiunge. Una memoria condivisa via MCP permette a Claude Code di leggerle e scriverle senza un commit, e le leggono anche le persone che il repository non lo usano.
