Uso Serena MCP da diversi mesi. È diventata parte del mio flusso di lavoro quotidiano con Claude Code: le memorie persistenti mi permettevano di non ripetere ogni volta le stesse cose al modello, e i tool LSP mi davano una navigazione del codice che Claude Code da solo non ha — "Go to Definition", "Find All References", editing a livello di simbolo.
Poi, il 26 febbraio 2026, Anthropic ha rilasciato la versione 2.1.59 di Claude Code con una feature che cambia le carte in tavola: auto memory. Claude ora prende appunti da solo durante le sessioni — pattern del progetto, comandi, convenzioni, soluzioni a problemi — e li ricarica automaticamente la volta dopo.
La domanda è stata immediata: ha senso continuare a usare le memorie di Serena, o quelle native di Claude Code le rendono ridondanti?
Ho fatto una piccola analisi comparativa sul mio progetto. Il risultato: ho disattivato 15 tool di Serena e ne ho tenuti 12. Ecco il ragionamento.
Come usavo Serena prima
Serena ha un sistema di memorie in .serena/memories/ — file markdown per topic (project_overview.md, code_style.md, suggested_commands.md) generati durante un onboarding iniziale. Ad ogni nuova sessione, Claude poteva leggere queste memorie per avere contesto sul progetto senza dover rileggere i file.
Oltre alle memorie, Serena fornisce tool per leggere file, scrivere file, eseguire comandi shell, e soprattutto i tool LSP per navigare e modificare il codice a livello semantico — trovare una funzione per nome, scoprire chi la chiama, sostituire il corpo di un metodo senza toccare il resto del file.
In totale, Serena caricava 27 tool nel contesto di Claude. Tutti. Sempre. Che servissero o no.
Come funziona la memoria nativa di Claude Code
Il sistema nativo si compone di tre livelli.
CLAUDE.md — le istruzioni che dai tu
Un file markdown nella root del progetto. Viene caricato per intero nel contesto a ogni sessione. È pensato per le direttive — le regole che vuoi che Claude segua:
## Regole
- Rispondi sempre in italiano
- Non committare senza che te lo chieda
- Tutte le query SQL devono usare prepared statements
- Per inserire articoli: segui @documentazione/routine-inserimento-articoli.mdCLAUDE.md non è documentazione. È un file di configurazione per il comportamento di Claude. Più simile a un .editorconfig che a un README.
Esiste in una gerarchia precisa:
| Tipo | Posizione | Condiviso con |
|---|---|---|
| Managed policy | /Library/Application Support/ClaudeCode/CLAUDE.md |
Tutti gli utenti (macchina) |
| Progetto | ./CLAUDE.md |
Il team (via git) |
| Regole modulari | .claude/rules/*.md |
Il team (via git) |
| Utente | ~/.claude/CLAUDE.md |
Solo te (tutti i progetti) |
| Locale | ./CLAUDE.local.md |
Solo te (questo progetto) |
Le istruzioni più specifiche hanno priorità su quelle più generiche.
Auto memory — gli appunti che Claude prende da solo
Claude scrive automaticamente in ~/.claude/projects/<progetto>/memory/MEMORY.md durante le sessioni. Le prime 200 righe vengono caricate nel contesto alla sessione successiva.
Cosa ci finisce:
- Pattern del progetto: comandi di build, convenzioni di test, stile del codice
- Soluzioni a problemi: "l'ultima volta il bug era nel parsing delle date"
- Architettura: file chiave, relazioni tra moduli
- Preferenze personali: workflow, stile di comunicazione
Se servono più dettagli, Claude crea file topic separati (debugging.md, api-conventions.md) che non vengono caricati automaticamente ma letti on-demand.
Puoi anche dire esplicitamente: "ricordati che usiamo pnpm, non npm" — e Claude lo salva.
Regole modulari — istruzioni per contesto
La feature meno conosciuta e più potente. Puoi creare file in .claude/rules/ con regole che si attivano solo quando Claude lavora su certi file:
# .claude/rules/database.md
---
paths:
- "includes/db.php"
- "setup.php"
---
- Usa sempre prepared statements PDO
- Wrappa le operazioni multiple in transazioni
- I nomi delle funzioni DB sono in camelCaseQuesta regola si carica solo quando tocco db.php o setup.php. Zero overhead per il resto delle sessioni. È una cosa che né Serena né nessun altro sistema di memorie offre.
La sovrapposizione che ho trovato
Sul mio progetto, le stesse informazioni esistevano in tre posti diversi:
| Informazione | CLAUDE.md | Auto memory | Serena memories |
|---|---|---|---|
| Struttura file | Sì (obsoleto!) | Sì | Sì |
| Schema database | No | Sì | Sì |
| Convenzioni CSS | Sì | No | Sì |
| Admin panel | No | Sì | Sì |
| Routing | No | Parziale | Sì |
| Comandi suggeriti | No | No | Sì |
Tre fonti di verità, parzialmente sovrapposte, una attivamente sbagliata. Il CLAUDE.md descriveva ancora un "sito statico single-page" quando il progetto era già diventato un blog PHP con database.
Ma il problema più grande non erano le memorie duplicate. Era il costo nel contesto.
I numeri
Ogni volta che apri Claude Code con Serena connessa, il contesto viene pre-caricato con:
CLAUDE CODE NATIVO
├── CLAUDE.md ~426 token (sempre)
├── MEMORY.md (prime 200 righe) ~365 token (sempre)
└── Totale fisso ~791 token
SERENA MCP (27 tool)
├── 27 tool definitions ~3,350 token (sempre)
├── Istruzioni MCP ~1,625 token (sempre)
├── initial_prompt project.yml ~60 token (sempre)
└── Totale fisso ~5,035 token
Memorie Serena ~1,265 token (solo on-demand)Le memorie Serena sono on-demand — non costano nulla se non le chiedi. Ma i 27 tool definitions sono sempre nel contesto, che tu li usi o no. 5,000 token di overhead fisso, anche per sessioni in cui devi solo scrivere un articolo o cambiare un colore nel CSS.
E qui la domanda è diventata più precisa: di quei 27 tool, quanti mi servono davvero?
Cosa ho disattivato e perché
Analizzando i 27 tool di Serena, ho trovato che la maggior parte fa cose che Claude Code sa già fare nativamente:
| Categoria | Tool Serena | Equivalente Claude Code |
|---|---|---|
| Lettura file | read_file |
Read |
| Scrittura file | create_text_file |
Write |
| Cerca file | find_file, list_dir |
Glob, LS |
| Shell | execute_shell_command |
Bash |
| Memorie | write_memory, read_memory, list_memories, delete_memory, edit_memory, rename_memory |
Auto memory nativa |
| Onboarding | onboarding, check_onboarding_performed, prepare_for_new_conversation |
CLAUDE.md + MEMORY.md |
| System prompt | initial_instructions |
Non serve (Claude Code ha il suo) |
15 tool ridondanti. Ognuno occupa spazio nel contesto e crea ambiguità su quale strumento usare. Li ho disattivati tutti.
Cosa ho tenuto
I 12 tool rimasti sono quelli che Claude Code non ha — i tool LSP per navigazione ed editing semantico del codice:
Navigazione codice
| Tool | Cosa fa |
|---|---|
find_symbol |
Trova classi, funzioni, metodi per nome in tutto il progetto |
find_referencing_symbols |
"Chi chiama questa funzione?" — risposta semantica, non grep |
get_symbols_overview |
Panoramica di classi, funzioni, costanti in un file senza leggerlo |
search_for_pattern |
Cerca pattern regex nel codebase |
Editing semantico
| Tool | Cosa fa |
|---|---|
replace_symbol_body |
Sostituisce l'intera definizione di una funzione |
replace_content |
Sostituisce testo con regex (per modifiche parziali) |
insert_before_symbol |
Inserisce codice prima di un simbolo |
insert_after_symbol |
Inserisce codice dopo un simbolo |
rename_symbol |
Rinomina un simbolo in tutto il codebase |
Utilità
| Tool | Cosa fa |
|---|---|
activate_project |
Cambia progetto attivo |
get_current_config |
Mostra configurazione corrente |
switch_modes |
Cambia modalità (editing, planning, ecc.) |
Senza questi tool, Claude Code legge file interi, cerca pattern con grep, calcola le righe e fa editing con ricerca/sostituzione testuale. Funziona, ma è come navigare una città senza mappa. Con i tool LSP, Claude ha l'equivalente del "Go to Definition" e "Find All References" di un IDE.
Come ho configurato tutto
La configurazione si fa nel file .serena/project.yml del progetto. La sezione chiave è excluded_tools:
project_name: "nome-progetto"
languages:
- php
- typescript
encoding: "utf-8"
ignore_all_files_in_gitignore: true
ignored_paths:
- "vendor/**"
- "node_modules/**"
read_only: false
excluded_tools:
# Memorie — ridondanti con auto memory nativa di Claude Code
- write_memory
- read_memory
- list_memories
- delete_memory
- edit_memory
- rename_memory
# Onboarding — ridondante con CLAUDE.md e MEMORY.md
- onboarding
- check_onboarding_performed
- prepare_for_new_conversation
# File I/O — ridondanti con Read, Write, Glob, Bash di Claude Code
- list_dir
- find_file
- read_file
- create_text_file
- execute_shell_command
# Non necessario in Claude Code (serve solo per client senza system prompt)
- initial_instructions
included_optional_tools: []
fixed_tools: []
base_modes:
default_modes:
initial_prompt: ""
symbol_info_budget:Poi nel CLAUDE.md del progetto ho aggiunto:
## Serena MCP
- Serena è configurata solo per i tool LSP (navigazione e editing semantico)
- Le memorie sono gestite dall'auto memory nativa di Claude Code, NON da Serena
- Usa `find_symbol`, `find_referencing_symbols`, `get_symbols_overview` per navigare il codice
- Usa `replace_symbol_body`, `insert_after_symbol` per editing precisoQuesto dice esplicitamente a Claude di non provare a usare i tool memorie di Serena (che non troverebbe comunque) e di affidarsi al sistema nativo.
Verifica
Per controllare che tutto sia configurato correttamente, basta chiedere a Claude Code di usare get_current_config di Serena. I tool attivi devono essere esattamente 12 — quelli elencati sopra. Se ne vedi di più, c'è qualcosa da rivedere nel project.yml.
Cosa cambia in pratica
Prima della riconfigurazione, il mio system prompt aveva ~5,035 token solo per Serena. Dopo, con i 12 tool LSP rimasti, l'overhead si è ridotto a circa ~3,100 token — il 40% in meno. Meno tool definitions da caricare, meno istruzioni inutili nel contesto.
Le memorie non sono più duplicate. Claude usa il suo sistema nativo — CLAUDE.md per le direttive, MEMORY.md per i fatti sul progetto, .claude/rules/ per regole condizionali. E quando serve navigare il codice a livello semantico, i tool LSP di Serena sono ancora lì.
La differenza che pochi capiscono
Molte guide suggeriscono di mettere la descrizione del progetto in CLAUDE.md. È un errore concettuale.
CLAUDE.md è per le direttive — cose che Claude deve fare o non deve fare. Sono imperative.
Auto memory è per i fatti — cose che Claude ha scoperto sul progetto. Sono descrittive.
| Informazione | Dove va | Perché |
|---|---|---|
| "Rispondi in italiano" | CLAUDE.md | È un ordine |
| "Il progetto usa SQLite in db/blog.sqlite" | Auto memory | È un fatto scoperto da Claude |
| "Non committare senza chiedere" | CLAUDE.md | È una regola |
| "Il routing è in index.php con pattern regex" | Auto memory | Claude lo vede leggendo il codice |
"Per i test usa make test" |
CLAUDE.md | È un comando che il team condivide |
| "L'ultima volta il bug era nel parsing delle date" | Auto memory | È un appunto personale |
Quando metti tutto in CLAUDE.md — descrizioni, fatti, regole — ottieni un file lungo, che si aggiorna male, che contiene informazioni che diventano obsolete. È esattamente quello che mi è successo.
Quando serve cosa
| Scenario | Memorie native bastano? | Tool LSP Serena servono? |
|---|---|---|
| Scrivere un articolo per il blog | Sì | No |
| Modificare il CSS | Sì | No |
| Aggiungere una funzione in db.php | Sì | Sì — insert_after_symbol |
| Refactorare il routing in più file | Sì | Sì — find_referencing_symbols |
| Capire chi usa una funzione | No (solo grep) | Sì — analisi semantica |
| Rinominare un metodo ovunque | No | Sì — rename_symbol |
| Progetto piccolo (<20 file) | Sì | Raramente utile |
| Progetto grande (100+ file) | Sì per memorie | Essenziale per navigazione |
Nota importante
Questa configurazione è per Claude Code (CLI e desktop). Se usi Serena con Claude Desktop o altri client MCP che non hanno tool nativi per leggere file, eseguire comandi o gestire memorie, non disattivare quei tool — ti servono tutti.
La ragione per cui posso disattivarli è che Claude Code ha già Read, Write, Glob, Bash e il suo sistema di auto memory. La sovrapposizione esiste solo in questo contesto specifico.
In sintesi
| Cosa | Prima | Dopo |
|---|---|---|
| Tool Serena attivi | 27 | 12 |
| Sistemi di memoria | 3 (CLAUDE.md + auto memory + Serena) | 2 (CLAUDE.md + auto memory) |
| Token overhead Serena | ~5,035 | ~3,100 |
| Navigazione semantica | Sì | Sì (invariata) |
| Editing a livello di simbolo | Sì | Sì (invariato) |
| Informazioni duplicate tra sistemi | Sì (3 fonti sovrapposte) | No (ogni sistema ha il suo ruolo) |
Serena resta attiva — ma fa solo quello che sa fare meglio e che Claude Code non sa fare: navigare e modificare il codice a livello semantico. Tutto il resto lo gestisce il sistema nativo, che è più integrato, si aggiorna da solo, e non costa token di overhead inutili.
Il prompt per configurare tutto in automatico
Se vuoi replicare questa configurazione su un tuo progetto, copia il prompt qui sotto in Claude Code. Prerequisito: Serena MCP connessa e serena init già eseguito.
Configura Serena MCP per questo progetto in modo da disattivare tutti
i tool ridondanti con Claude Code e tenere attivi solo i tool LSP.
Passo 1 — Modifica .serena/project.yml
Apri .serena/project.yml e cerca la sezione excluded_tools (potrebbe
essere vuota, commentata o già popolata). Sostituiscila con questo
blocco YAML, mantenendo l'indentazione corretta e senza modificare
le altre sezioni del file:
excluded_tools:
- write_memory
- read_memory
- list_memories
- delete_memory
- edit_memory
- rename_memory
- onboarding
- check_onboarding_performed
- prepare_for_new_conversation
- list_dir
- find_file
- read_file
- create_text_file
- execute_shell_command
- initial_instructions
Passo 2 — Aggiorna CLAUDE.md
Se il CLAUDE.md del progetto ha già una sezione "## Serena MCP",
aggiornala. Se non c'è, aggiungila in fondo. Se il file CLAUDE.md
non esiste, crealo.
## Serena MCP
- Configurata solo per i tool LSP (navigazione e editing semantico)
- Le memorie sono gestite dall'auto memory nativa di Claude Code,
NON da Serena
- Navigazione: find_symbol, find_referencing_symbols,
get_symbols_overview
- Editing: replace_symbol_body, insert_after_symbol, replace_content
Passo 3 — Verifica
Attiva il progetto in Serena e chiama get_current_config. I tool
attivi devono essere esattamente questi 12:
activate_project, find_referencing_symbols, find_symbol,
get_current_config, get_symbols_overview, insert_after_symbol,
insert_before_symbol, rename_symbol, replace_content,
replace_symbol_body, search_for_pattern, switch_modes.
Se non corrispondono, dimmi quali tool attivi vedi.