# Cleaner Mac con AI: cosa un modello dovrebbe e non dovrebbe decidere
> Classificazione e attribuzione possono essere probabilistiche, la decisione di cancellare no. Come cc-cleaner, DevCleaner, le skill degli agent e Mole tracciano quel confine, e quale si adatta al tuo disco.
Published: 2026-08-20 | Updated: 2026-08-22
"AI Mac cleaner" si risolve in due prodotti diversi. Uno è un'app di pulizia con un modello
da qualche parte al suo interno, venduta sull'intelligenza dei suoi suggerimenti. L'altro è
uno strumento per recuperare il disco che Claude Code, Cursor, Ollama e le loro cache hanno
silenziosamente occupato nell'ultimo anno. Il secondo è ciò che la maggior parte delle
persone che digitano quella frase nel 2026 vuole davvero. Il primo vale la pena affrontarlo
per primo, perché la risposta decide quanto fidarsi di qualsiasi cosa nel secondo gruppo.
## Parte uno: cosa sta decidendo davvero il modello
Un cleaner che pubblicizza l'AI sta facendo un'affermazione su un passo di una pipeline che
ne ha almeno quattro:
1. **Enumerare.** Percorrere il disco e misurarlo. Lavoro a forma di `du`, senza alcun
giudizio dentro.
2. **Attribuire.** Decidere quale app o toolchain possiede ogni percorso.
3. **Classificare e spiegare.** Decidere quali dodici su quattromila candidati meritano
attenzione, e dire in una frase cos'è ciascuno.
4. **Decidere e cancellare.** Decidere cosa è sicuro rimuovere, poi rimuoverlo.
I passi 2 e 3 sono genuinamente sfumati, e un modello lì aiuta davvero. Il passo 4 è un tipo
di problema diverso, e un modello è lo strumento sbagliato per affrontarlo. Quasi ogni
discussione sui cleaner AI è in realtà una discussione su quale passo intende il fornitore.
### Dove un modello guadagna il suo posto
L'attribuzione è il caso difficile onesto. Supponi di trovare
`~/Library/Application Support/Foo Labs` che contiene 3 GB senza alcuna app chiamata Foo
Labs sul disco. Le prove sono deboli e sparse: frammenti di bundle identifier dentro i
plist della cartella stessa, un prefisso corrispondente in `~/Library/HTTPStorages`, un
bundle `.savedState` sotto `~/Library/Saved Application State`, una ricevuta di installazione
in `/var/db/receipts`. L'uguaglianza dei nomi fallisce subito, perché il fornitore scrive
"Foo Labs" in un posto e `com.foolabs.editor` in un altro, e un catalogo scritto a mano
copre le prime poche centinaia di app poi crolla. Questa è esattamente la forma in cui un
modello batte una regola: molti segnali deboli, nessuno decisivo, una lunga coda che
nessuno finirà mai di catalogare.
La classificazione ha la stessa forma: una scansione che restituisce 4.000 percorsi e 60 GB
è un secondo problema, non un risultato. La spiegazione è ancora più facile, dato che
trasformare `~/Library/Caches/com.apple.nsurlsessiond` in una frase semplice è traduzione.
Uno strumento che usa un modello per questi tre lavori, e lo dice, pubblicizza una funzione
reale.
### Perché l'ultimo cancello deve essere deterministico
La decisione di cancellazione richiede tre proprietà che un modello non può fornire.
**Determinismo.** Stesso disco, stessa versione, stessa risposta, ogni volta. La
temperatura zero non compra questo, perché il prompt porta con sé i contenuti della tua
macchina: installi un'app in più, l'elenco dei file cambia, e i token su cui si regge la
decisione cambiano con esso. Una regola di sicurezza che vale sul tuo Mac ma non su quello
del tuo collega non è una regola di sicurezza.
**Verificabilità prima del fatto.** Una lista di protezione è un insieme di prefissi di
percorso, leggibile per intero in un minuto e confrontabile tra due release. Pesi più un
prompt non possono essere letti come una lista di cosa verrà rifiutato, quindi niente ti
mostra il confine prima che tu lo attraversi.
**Verificabilità dopo il fatto.** Quando una regola deterministica cancella la cosa
sbagliata ottieni un bug riproducibile: ecco il percorso, ecco la riga che l'ha permesso,
ecco il test che ora fallisce. Quando lo fa un modello, l'artefatto è una trascrizione, la
correzione è una modifica al prompt, e l'effetto di quella modifica su ogni altro caso non
è misurato.
Anche le modalità di fallimento sono asimmetriche. Una classificazione sbagliata costa uno
scroll; una cancellazione sbagliata di `~/.claude/projects` costa ogni trascrizione che hai.
Quindi la cornice non è "AI buona, AI cattiva", è una divisione a metà della pipeline:
probabilistica dove sbagliare costa attenzione, deterministica dove sbagliare costa dati.
La divisione non è tra strumenti intelligenti e stupidi, è tra la metà della pipeline dove sbagliare spreca uno scroll e la metà dove sbagliare perde un file.
### Da che parte sta Mole
[Mole](https://mole.fit/) non spedisce alcun modello e non esegue alcuna inferenza. Se un percorso può mai
diventare candidato alla cancellazione è deciso da un array fisso di prefissi relativi
bloccati compilato nell'app, con voci come `.ollama/models`, `.lmstudio/models`,
`.cache/huggingface`, `.cache/torch`, `.claude/projects`, `.codex/sessions`,
`.grok/sessions` e `Library/Caches/com.apple.e5rt.e5bundlecache`. La metà modificabile
dall'utente è un semplice file di testo che puoi leggere con
`cat ~/.config/mole/whitelist`. Il gratuito [Mole CLI](https://github.com/tw93/Mole) è open
source sotto GPL-3.0 e applica la stessa lista, quindi il codice che la applica è pubblico.
Quell'ultima voce è l'argomento in miniatura. `com.apple.e5rt.e5bundlecache` sta in
`~/Library/Caches` e la parola nel suo nome è "cache", quindi ogni euristica sulla terra la
classifica come eliminabile. Contiene modelli compilati per l'Apple Neural Engine, e
svuotarla mentre un'app ha modelli caricati rompe le chiamate di riconoscimento finché la
macchina non si riavvia. È protetta perché qualcuno ha incontrato quel fallimento e ha
scritto la riga.
Quindi il test pratico per qualsiasi strumento qui è una domanda: quale dei quattro passi
esegue il modello? Enumerazione, attribuzione, classificazione e spiegazione sono risposte
credibili. "Decide cosa è sicuro cancellare" è una risposta a cui rispondere chiedendo di
vedere la lista, e se non c'è lista non c'è niente da verificare.
## Parte due: strumenti per fare pulizia dopo gli strumenti AI
Questa è la domanda che intende la maggior parte delle persone. L'impronta si divide in
quattro tipi di dati con quattro regole diverse, e confonderli è dove avvengono gli
incidenti:
- **Cache e log degli strumenti.** `~/Library/Caches/claude-cli-nodejs`, le cache Electron
di Cursor, directory di telemetria e debug sotto `~/.claude`. Rigenerabili e noiose.
- **Trascrizioni e stato dei progetti.** `~/.claude/projects`, `~/.codex/sessions`,
`~/.grok/sessions`. Spesso la sorpresa più grande in una scansione, e insostituibili.
- **Vecchie versioni CLI.** Le CLI degli agent che si autoaggiornano lasciano indietro le
release precedenti. Su Codex questo misura circa 300 MB per release, quindi cinque
release accumulate raggiungono 1,2 GB con una sola attiva.
- **Pesi dei modelli.** `~/.ollama/models`, `~/.cache/huggingface/hub`, la directory dei
modelli di LM Studio. Di gran lunga i più grandi, posseduti dallo strumento che li ha
scaricati.
Misura prima di scegliere uno strumento:
```
du -sh ~/.claude ~/.codex ~/.ollama/models ~/.cache/huggingface 2>/dev/null | sort -h
```
### Mole, per una scansione revisionata che già conosce questi percorsi
Lo strumento Clean scansiona prima e mostra un risultato che rivedi prima che qualsiasi cosa
si muova. Ogni riga candidata porta il suo percorso esatto, proprietario e dimensione, e
qualsiasi cosa su cui lo scanner non è sicuro arriva deselezionata così il clic predefinito
è l'azione più piccola. Le rimozioni vanno nel Cestino invece di essere scollegate, e ogni
operazione viene aggiunta a `~/Library/Logs/mole/operations.log` dove `TRASHED` e `DELETED`
sono parole diverse.
La scansione finisce prima che appaia la schermata di revisione, così non stai mai scegliendo elementi da una lista costruita a metà.
Due comportamenti contano specificamente per gli strumenti AI. Le directory delle vecchie
versioni CLI degli agent vengono offerte, ma la release attiva non diventa mai candidata: il
target del launcher viene risolto e fissato per primo, così la versione che stai usando è
esclusa per costruzione invece che per una supposizione sul numero di versione. E la
disinstallazione ragiona sulla proprietà invece che sul confronto per nome, quindi rimuovere
un'app di un fornitore non offre il genitore condiviso `Application Support` che un'app
sorella ancora installata possiede.
Per eseguire il lavoro: apri Clean, lascia finire la scansione, espandi i gruppi che sembrano
grandi, deseleziona ciò che vuoi tenere, poi pulisci e verifica lo spazio liberato. La
scansione è gratuita e ogni strumento a pagamento gira due volte gratis, così l'intera
revisione è verificabile prima di decidere se 19 dollari valgono la spesa.
### Mole CLI, quando preferisci restare nel terminale
Un prodotto separato e gratuito, open source sotto GPL-3.0, installato con
`brew install mole`. Anteprima sempre prima:
```
mo clean --dry-run
mo purge --dry-run
```
`mo clean` gestisce cache e log, `mo purge` mira ai vecchi artefatti di build dei progetti,
e ogni comando distruttivo accetta `--dry-run` così leggi la lista esatta dei percorsi
prima. Condivide la lista di protezione e il log delle operazioni con l'app Mac. Una
differenza prima di togliere il flag: la pulizia cache da CLI rimuove i file
permanentemente, mentre disinstallazione e rimozione residui vanno ancora nel Cestino.
### cc-cleaner, l'opzione da terminale open source costruita per questo problema
[cc-cleaner](https://github.com/elexingyu/cc-cleaner) ha licenza MIT, richiede Python 3.10
o successivo, installabile con `pipx install cc-cleaner`. Include 22 cleaner tra cui Claude
Code, npm, uv, cargo, Docker, Playwright, cache del browser, e un gruppo AI/ML per modelli
che copre Hugging Face, PyTorch, Whisper e Ollama. `cc-cleaner status` stampa una tabella di
dimensioni, `cc-cleaner clean` apre un selettore interattivo, `-n` è una simulazione a
secco.
Il suo modello di rischio è esplicito: gli elementi Safe si puliscono di default mentre gli
elementi Moderate e Dangerous richiedono `--force`, e il suo README mette "trascrizioni di
conversazioni, store condivisi" nel livello Moderate. Il codice sorgente racconta il resto.
Il suo cleaner Ollama rimuove l'intera `~/.ollama/models` come una singola directory, il suo
cleaner Hugging Face fa lo stesso con `~/.cache/huggingface/hub` e `datasets`, e il suo
cleaner Claude offre le trascrizioni `*.jsonl` sotto `~/.claude/projects`. La cancellazione
usa `shutil.rmtree` e `Path.unlink`, quindi niente finisce nel Cestino. Il suo livello di
sicurezza è un insieme congelato di percorsi di sistema vietati più un requisito che ogni
target stia sotto la tua home directory: una lista deterministica scritta da un umano,
esattamente come dovrebbe essere. La differenza è dove sta la linea, non il rigore.
cc-cleaner mette store di modelli e trascrizioni dietro un flag; Mole li rifiuta.
### DevCleaner, se vuoi un'app nella barra dei menu per lo stesso terreno
[DevCleaner](https://devcleaner.app) è un'utility per la barra dei menu per macOS 14+,
attualmente alla 1.9.0, che copre 23 ecosistemi da Xcode DerivedData e Gradle a npm e
Docker, con scanner dedicati per Claude, ChatGPT, Cursor, Ollama e LM Studio. Gli elementi
Safe vengono cancellati di default, gli elementi Warning sono "una tua scelta", gli elementi
Danger non sono mai preselezionati, e mantiene una deny-list rigida per credenziali e file
di sessione più un avviso prima di toccare le cache di un'app in esecuzione. La pulizia
base è gratuita e Pro si vende come acquisto una tantum o abbonamento annuale; verifica le
cifre attuali sulla pagina del fornitore. Il suo sito non dice se le rimozioni vanno nel
Cestino, ed è la cosa che vale la pena chiedere prima di un primo avvio.
MacPaw distribuisce anche una CLI di CleanMyMac come beta pubblica, tramite un cask
Homebrew, mirata agli stessi artefatti. È proprietaria, il suo repository è un issue
tracker invece che codice sorgente, e il suo comportamento è esplicitamente ancora in
cambiamento, quindi leggi cosa mostra il suo passo di conferma piuttosto che qualsiasi
descrizione pubblicata.
### Puntare un agent sul tuo stesso disco
L'ultima via è saltare gli strumenti di pulizia e chiedere a Claude Code o un agent simile
di pulire il disco direttamente, opzionalmente tramite una delle skill di pulizia
pubblicate. Il suo vantaggio è reale e nient'altro qui ce l'ha: un agent può ragionare su
una struttura che nessuno ha catalogato, che sia un framework uscito il mese scorso, una
toolchain privata, o una home directory organizzata come solo tu la organizzi.
La valutazione deve essere altrettanto chiara. I comandi shell vengono generati al momento
dell'inferenza contro il tuo filesystem reale, quindi ciò che gira non è mai stato
revisionato da nessuno prima che girasse. Non c'è una simulazione a secco a meno che tu non
la richieda. Il raggio d'azione è la tua home directory, e un `rm -rf` composto da una
variabile che risulta vuota è una modalità di fallimento con una lunga storia. La parte uno
si applica con la rete di sicurezza rimossa: la decisione è probabilistica e collegata
direttamente all'ultimo cancello.
Quattro protezioni non costano quasi nulla:
- **Fallo guidare uno strumento con un flag di anteprima invece di comporre le rimozioni da
solo.** Una skill pubblica per Claude Code avvolge la CLI `mo` e rende `mo clean --dry-run`
obbligatorio prima di `mo clean`, stampa l'output completo della simulazione, e richiede
una conferma digitata. L'agent sceglie il target, uno strumento deterministico esegue la
cancellazione.
- **Non pre-approvare mai `rm` nelle tue impostazioni dei permessi.** Approva ogni comando di
rimozione individualmente, e leggi il percorso invece del riassunto.
- **Rendi il Cestino il default.** `trash` da Homebrew, o `mv` dentro `~/.Trash`, trasforma
ogni errore in uno recuperabile.
- **Delimita l'insieme di lavoro.** Puntalo a una sola directory, e chiedi `du -sh` prima e
`df -h` dopo così il recupero dichiarato è misurato invece che stimato.
### Gli store di modelli appartengono allo strumento che li ha scaricati
Nessun cleaner generico dovrebbe essere il tuo strumento qui, inclusi quelli sopra. Ollama e
Hugging Face mantengono entrambi store con indirizzamento per contenuto dove i modelli
condividono blob, quindi solo lo strumento proprietario sa quale blob è ancora
referenziato. Usa `ollama ls` e `ollama rm `, e `hf cache ls` con
`hf cache rm model/ --dry-run`. Perché cancellare i file blob a mano orfanizza un
modello è coperto in
[rimuovere i residui degli strumenti AI](https://mole.fit/it/blog/how-to-remove-ai-tool-leftovers-mac).
## Come si confrontano
| Strumento | Decide in modo deterministico | Mostra anteprime dei percorsi | Recuperabile | Protegge store di modelli e cronologia chat | Costo |
|---|---|---|---|---|---|
| Mole per Mac | Lista fissa di prefissi bloccati più whitelist utente | Sì, percorso, proprietario e dimensione per riga | Sì, Cestino di default, più un log delle operazioni | Sì, mai candidati | 19 dollari una tantum, due Mac, aggiornamenti a vita |
| Mole CLI | La stessa lista di protezione condivisa | Sì, `--dry-run` su ogni comando distruttivo | Disinstallazione nel Cestino, pulizia cache permanente | Sì, stessa lista | Gratuito, GPL-3.0 |
| cc-cleaner | Insieme di percorsi vietati congelato, vincolato alla home directory | Sì, simulazione `-n` e un selettore interattivo | No, `shutil.rmtree` e `unlink` | Raggiungibile dietro `--force`, non rifiutato | Gratuito, MIT |
| DevCleaner | Tre livelli di rischio più una deny-list per credenziali | Dimensioni per scanner, Danger mai preselezionato | Non documentato, chiedi prima di eseguire | Pesi dei modelli indicati come classe separata | Base gratuita, Pro una tantum o annuale |
| CleanMyMac CLI | Non pubblicato, il repository è un issue tracker | Sì, conferma prima della rimozione | Non documentato | Non documentato | Beta pubblica, verifica i termini del fornitore |
| Agent con accesso shell | Niente, deciso al momento dell'inferenza | Solo se lo richiedi | Solo se forzi il Cestino | Solo se lo dici nel prompt | Il tuo abbonamento all'agent |
| `ollama rm`, `hf cache rm` | Conteggio dei riferimenti dentro lo store | `hf cache rm --dry-run` | No, ma riscaricabile | Questa è la protezione | Gratuito |
## Il confine, detto chiaramente
Mole non è una risposta al malware, non è un backup, e non è un sostituto di un
uninstaller del fornitore per software che installa driver, componenti VPN o estensioni di
sistema. Non cancella pesi di modelli né cronologia delle chat AI, quindi se il tuo
problema da 200 GB è interamente una libreria di modelli, ti mostra la forma di quella
libreria in Analyze e passa il lavoro a Ollama o LM Studio. È un confine deliberato, non un
vuoto da colmare in seguito.
## Sceglierne uno
**200 GB di output di build e una dozzina di toolchain.** Il volume sta nelle cache, nei
vecchi `node_modules`, in DerivedData e Docker, non in nulla di specifico per AI. Comincia
con una scansione revisionata o `mo clean --dry-run`, poi lavora attraverso
[svuotare le cache di sviluppo](https://mole.fit/it/blog/how-to-clear-dev-caches-mac) per gli store che
necessitano del proprio comando di pulizia dedicato. cc-cleaner è un buon secondo passaggio
se leggi prima i suoi livelli di rischio.
**Una grande libreria di modelli locali.** Salta del tutto i cleaner generici per i pesi.
`ollama ls`, `hf cache ls` e la vista My Models di LM Studio sono gli unici strumenti che
possono liberare un blob condiviso in sicurezza. Usa una mappa del disco per trovare lo
store e lo strumento proprietario per modificarlo.
**Hai appena notato Cursor o Claude Code che divorano disco.** Il caso più gestibile: cache
e log si rigenerano, le vecchie versioni CLI sono puro spreco, e le trascrizioni sono
l'unica cosa da non toccare. Qualsiasi strumento revisionato qui lo gestisce, e la versione
passo passo è in
[fare pulizia dopo gli strumenti AI per programmare](https://mole.fit/it/blog/how-to-clean-up-ai-coding-tools-mac).
## Domande frequenti
### Un Mac cleaner potenziato dall'AI cancella in modo più sicuro di uno normale?
Non sulla base delle prove disponibili. Un modello può battere una regola nel decidere
quale app possiede una cartella orfana e nel classificare cosa merita attenzione, perché
sono problemi sfumati con molti segnali deboli. Decidere se un percorso è sicuro da
cancellare richiede determinismo e una lista verificabile, nessuno dei quali un modello
fornisce. Chiedi a un fornitore quale passo della pipeline esegue il suo modello, e tratta
"decide cosa è sicuro cancellare" come uno spunto per chiedere di vedere la lista.
### È sicuro lasciare che Claude Code pulisca il mio Mac?
È l'opzione più flessibile e la meno delimitata. I comandi vengono generati al momento
dell'inferenza e girano contro la tua home directory, senza anteprima a meno che tu non la
richieda. Se lo fai, fai in modo che l'agent guidi uno strumento che ha un flag di
simulazione a secco invece di comporre `rm -rf` da solo, non pre-approvare mai `rm` nelle
tue impostazioni dei permessi, manda le rimozioni nel Cestino, e confinalo a una directory
alla volta.
### Un Mac cleaner cancellerà i miei modelli Ollama o la mia cronologia di Claude Code?
Dipende interamente dallo strumento, ed è per questo che è la domanda da fare prima. Mole
blocca `~/.ollama/models`, `~/.lmstudio/models`, `~/.cache/huggingface`,
`~/.claude/projects`, `~/.codex/sessions` e `~/.grok/sessions` al cancello di cancellazione
a qualsiasi età, quindi non diventano mai candidati. cc-cleaner classifica le directory dei
modelli e le trascrizioni di Claude Code come rischio Moderate e le rimuove se passi
`--force`. Leggi i livelli di rischio di uno strumento prima del primo avvio piuttosto che
dopo.
### Cosa sta davvero occupando lo spazio dopo un anno di strumenti AI per programmare?
Di solito vecchie versioni CLI e trascrizioni piuttosto che le cache che la gente si
aspetta. Una CLI di agent che si autoaggiorna può lasciare indietro diverse centinaia di
megabyte per release, e su Codex cinque release accumulate raggiungono circa 1,2 GB con
una sola attiva. Le trascrizioni sotto `~/.claude/projects` si accumulano silenziosamente e
sono l'elemento più probabile a sorprenderti in una scansione, ed è anche per questo che
dovrebbero essere escluse da una scansione invece che incluse.
## Approfondimenti correlati
- [Fare pulizia dei modelli Ollama e LM Studio su Mac](https://mole.fit/it/blog/how-to-remove-ai-tool-leftovers-mac)
per i meccanismi degli store di modelli con indirizzamento per contenuto.
- [Svuotare le cache di sviluppo senza rompere le build](https://mole.fit/it/blog/how-to-clear-dev-caches-mac)
per gli store dei package manager e i `node_modules` sparsi.
- [Fare pulizia dopo gli strumenti AI per programmare](https://mole.fit/it/blog/how-to-clean-up-ai-coding-tools-mac)
per la versione passo passo, percorso per percorso.
---
Canonical HTML page: https://mole.fit/it/blog/ai-mac-cleaner-tools
Blog index for agents: https://mole.fit/it/blog/llms.txt
Site index for agents: https://mole.fit/llms.txt
