# Claude Code: guida completa 2026 (installazione e prezzi) > Fonte: https://francescogruner.it/claude-code-guida-completa/ Ogni volta che qualcuno mi chiede cos’è Claude Code parte lo stesso equivoco: pensa a una chat che scrive codice. Non è quello. Claude Code è un agente che gira nel tuo terminale, legge i file del progetto, esegue comandi, modifica il codice e verifica il risultato. La differenza pratica è enorme: nella chat copi e incolli, qui il lavoro lo fa dentro il repository. Questa è la guida che avrei voluto trovare in italiano. Cosa è, come si installa, quanto costa davvero, come si configura per lavorare bene, e dove smette di convenire. Ogni comando che trovi qui sotto l’ho eseguito davvero, su una macchina Linux con Claude Code 2.1.215: dove non ho potuto verificare qualcosa lo dico esplicitamente. Indice dei contenuti [Toggle](#) - [Cos’è Claude Code (e cosa non è)](#Cose_Claude_Code_e_cosa_non_e) - [Claude Code install: requisiti, installazione e verifica](#Claude_Code_install_requisiti_installazione_e_verifica) - [Claude Code pricing: quanto costa davvero](#Claude_Code_pricing_quanto_costa_davvero) - [Come si lavora davvero: CLAUDE.md, skill, comandi e memoria](#Come_si_lavora_davvero_CLAUDEmd_skill_comandi_e_memoria) - [Il file di identità: CLAUDE.md](#Il_file_di_identita_CLAUDEmd) - [Le skill: caricamento progressivo](#Le_skill_caricamento_progressivo) - [I comandi personalizzati](#I_comandi_personalizzati) - [La memoria, detta come sta](#La_memoria_detta_come_sta) - [Casi d’uso reali, con script che ho eseguito](#Casi_duso_reali_con_script_che_ho_eseguito) - [1. Modalità headless: l’agente dentro uno script](#1_Modalita_headless_lagente_dentro_uno_script) - [2. Output JSON per le pipeline](#2_Output_JSON_per_le_pipeline) - [3. Un hook che blocca i comandi distruttivi](#3_Un_hook_che_blocca_i_comandi_distruttivi) - [4. Un server MCP fatto in casa, senza dipendenze](#4_Un_server_MCP_fatto_in_casa_senza_dipendenze) - [Claude Code docs e download: dove guardare davvero](#Claude_Code_docs_e_download_dove_guardare_davvero) - [Errori comuni e come si risolvono](#Errori_comuni_e_come_si_risolvono) - [Limiti onesti: quando Claude Code non conviene](#Limiti_onesti_quando_Claude_Code_non_conviene) - [In pratica](#In_pratica) - [Claude Code, setup avanzato](#Claude_Code_setup_avanzato) - [Manage costs effectively](#Manage_costs_effectively) - [Piani e prezzi Claude](#Piani_e_prezzi_Claude) - [Cos’è il piano Max](#Cose_il_piano_Max) - [MCP con Claude Code](#MCP_con_Claude_Code) - [Hook di Claude Code](#Hook_di_Claude_Code) ## Cos’è Claude Code (e cosa non è) Claude Code è l’agente di programmazione di Anthropic che si installa come applicazione da riga di comando. Apri il terminale nella cartella del progetto, scrivi `claude`, e da quel momento il modello può leggere i file, cercare nel codice, eseguire comandi di shell, modificare i file e rileggere il risultato per verificare cosa ha combinato. Le tre cose che la gente confonde: - **Claude chat** (il sito claude.ai) è una conversazione. Vede solo quello che incolli tu, non tocca il disco. - **L’app desktop** è un’interfaccia grafica: contiene anche Claude Code, quindi ti eviti il terminale, ma il motore sotto è lo stesso. - **Claude Code** è il ciclo agentico completo nel terminale: legge, scrive, esegue, controlla. Ed è l’unico dei tre che si automatizza davvero, perché è un comando. La cosa interessante non è che scriva codice. È che chiude il ciclo da solo: fa una modifica, lancia i test, legge l’errore, corregge. Nella chat quel giro lo fai tu a mano, cinque volte. ## Claude Code install: requisiti, installazione e verifica I requisiti ufficiali sono bassi: macOS 13.0 o superiore, Windows 10 1809 o superiore (o Windows Server 2019+), Ubuntu 20.04+, Debian 10+, Alpine Linux 3.19+. Servono 4 GB di RAM, un processore x64 o ARM64 e una connessione a internet. Nient’altro: il pacchetto porta con sé il proprio binario nativo e di solito anche ripgrep per la ricerca nei file. Il metodo consigliato oggi non è più npm, è l’installer nativo. ``` # macOS, Linux, WSL curl -fsSL https://claude.ai/install.sh | bash ``` ``` # Windows PowerShell irm https://claude.ai/install.ps1 | iex ``` In alternativa ci sono Homebrew (`brew install --cask claude-code`), WinGet (`winget install Anthropic.ClaudeCode`) e i repository apt, dnf e apk firmati. Resta anche la strada npm, che però dalla versione 2.1.198 vuole Node.js 22 o superiore: ``` npm install -g @anthropic-ai/claude-code ``` Attenzione però: su Node più vecchio npm stampa un avviso `EBADENGINE` ma l’installazione va comunque a buon fine, perché il pacchetto scarica lo stesso binario nativo dell’installer e non usa Node a runtime. Se non hai un motivo preciso per passare da npm, usa l’installer nativo: si aggiorna da solo in background, quello via Homebrew e WinGet no. **Verifica in due comandi.** Questi li ho eseguiti davvero: ``` claude --version # 2.1.215 (Claude Code) claude doctor # Running: native (2.1.215) # Platform: linux-x64 # Search: OK (bundled) # Auto-updates: enabled # No installation issues found. ``` `claude doctor` è la diagnostica di sola lettura: dice come sei installato, se gli aggiornamenti automatici funzionano e se ci sono errori nei file di configurazione, senza aprire una sessione. È la prima cosa da lanciare quando qualcosa non torna. Poi entri nel progetto e avvii: ``` cd ~/progetti/mio-progetto claude ``` Al primo avvio ti manda sul browser per il login. Se hai la variabile `ANTHROPIC_API_KEY` impostata, ti chiede invece una volta sola se vuoi usare quella chiave. ## Claude Code pricing: quanto costa davvero Prima cosa, quella che fa perdere tempo a metà delle persone: **il piano gratuito di Claude non include Claude Code**. Serve un piano Pro, Max, Team, Enterprise, oppure un account Console con fatturazione a consumo. Può girare anche su Amazon Bedrock, Google Cloud Agent Platform e Microsoft Foundry, con la spesa a carico del tuo account cloud. Questi sono i prezzi ufficiali al momento in cui scrivo (luglio 2026, listino in dollari sul sito Anthropic): PianoPrezzoNoteFree0Claude Code **non** inclusoPro17 $/mese con abbonamento annuale (200 $ anticipati), 20 $/mese se mensileil punto di ingressoMax 5x100 $/mese5 volte l’uso del Pro per sessioneMax 20x200 $/mese20 volte l’uso del Pro per sessioneTeam, posto Standard20 $/posto/mese annuale, 25 $ mensileinclude Claude Code e CoworkTeam, posto Premium100 $/posto/mese annuale, 125 $ mensileper chi usa Claude Code tutto il giornoEnterpriseprezzo del posto più consumo a tariffe APIcontrolli e analytics per amministratoriConsole (API)solo consumo a tokenspesa per workspace, nessun canone Sui piani in abbonamento non paghi i token: hai un tetto d’uso che si azzera su una finestra mobile di cinque ore e su una finestra settimanale, condiviso con la chat e con Cowork. Sui piani API paghi i token, punto. Quanto si spende davvero a token? La documentazione di Anthropic è inusualmente onesta su questo: nelle installazioni enterprise la media è **circa 13 dollari per sviluppatore per giorno attivo** e **150-250 dollari al mese per sviluppatore**, con il 90% degli utenti sotto i 30 dollari al giorno attivo. Sono numeri che spaventano finché non li confronti con il costo orario di uno sviluppatore, ma vanno tenuti d’occhio. Il comando che serve è `/usage` dentro la sessione: sui piani in abbonamento mostra le barre di consumo e la ripartizione per skill, subagent, plugin e singoli server MCP, con il tasto `d` o `w` per passare fra le ultime 24 ore e gli ultimi 7 giorni. Se lavori a consumo, ho scritto un pezzo a parte su [come si comporta davvero il piano Pro all’atto pratico](https://francescogruner.it/claude-code-piano-pro-anthropic-test/), con il test sul campo. C’è anche la strada opposta, cioè tenere l’interfaccia di Claude Code e cambiare motore: si può puntare a modelli più economici o locali, e l’ho documentato nella [guida a Claude Code con Ollama e GLM](https://francescogruner.it/claude-code-ollama-glm-guida-2026/). Non è per tutti, ma abbassa parecchio la bolletta. ## Come si lavora davvero: CLAUDE.md, skill, comandi e memoria Qui sta la differenza fra chi ci si trova bene e chi lo molla dopo tre giorni. Appena installato l’agente è generico: sa programmare, non sa niente di te. Diventa davvero utile quando gli dai un’identità e delle regole. ### Il file di identità: CLAUDE.md `CLAUDE.md` sta nella radice del progetto e viene caricato in contesto all’avvio di ogni sessione. È il posto delle regole non negoziabili: convenzioni di codice, comandi di build, cose da non toccare mai. ``` # Progetto contabilita ## Regole non negoziabili - Gli importi si scrivono SEMPRE con la virgola decimale e il suffisso ` EUR`. - Non usare mai il punto come separatore decimale. - Rispondi in italiano. ``` Con quel file in cartella ho chiesto quanto fa 1200 diviso 7. Risposta: `171,43 EUR`. Senza il file avrei ottenuto `171.43`. Sembra banale, ed è esattamente il tipo di dettaglio che ti costa venti correzioni al giorno. La regola operativa, che è anche nella documentazione ufficiale: **tieni CLAUDE.md sotto le 200 righe**. Tutto quello che sta lì dentro occupa contesto a ogni singolo messaggio, anche quando stai facendo altro. Le istruzioni lunghe e specialistiche vanno nelle skill. ### Le skill: caricamento progressivo Una skill è una cartella con dentro un `SKILL.md`. In contesto ci finisce solo la descrizione; il corpo viene letto solo quando serve davvero. È il meccanismo che in gergo si chiama progressive disclosure, e nella pratica significa che puoi averne venti senza pagarne il costo in token. Struttura minima, `.claude/skills/nota-spese/SKILL.md`: ``` --- name: nota-spese description: Usa questa skill quando ti chiedono di calcolare o formattare una nota spese, un rimborso chilometrico o una trasferta. Contiene le regole e i coefficienti aziendali. --- # Nota spese ## Regole 1. Il rimborso chilometrico e' 0,45 euro/km. 2. Il pasto e' rimborsato fino a un massimo di 25 euro. 3. Il totale va arrotondato a 2 decimali. ## Formato di output Una sola riga: `TOTALE: X,XX EUR` ``` Il campo `description` è la parte che conta: è l’unica cosa che il modello vede sempre, quindi deve dire **quando** usare la skill, non cosa contiene. Test reale, con la skill installata: ``` claude -p "Trasferta: 120 km e un pranzo da 32 euro. Calcola la nota spese." # TOTALE: 79,00 EUR # (120 km x 0,45 = 54,00 + pranzo rimborsato al massimale di 25,00 invece di 32) ``` Il tetto dei 25 euro non poteva inventarselo. L’ha letto dalla skill. ### I comandi personalizzati Un file markdown in `.claude/commands/` diventa uno slash command. `.claude/commands/riepilogo.md`: ``` --- description: Riepiloga in 3 punti lo stato del repository --- Guarda i file presenti in questa cartella e riassumi in ESATTAMENTE 3 punti elenco cosa contiene il progetto. Niente preamboli. ``` Da quel momento `/riepilogo` funziona sia in sessione interattiva sia in modalità headless. L’ho provato: risponde con tre punti, senza preamboli. ### La memoria, detta come sta Non c’è magia. La memoria persistente di Claude Code sono i file: `CLAUDE.md` per le regole stabili, le skill per le competenze, la cronologia della sessione per il resto. Dentro la sessione: - `/clear` chiude la conversazione e ne apre una nuova: costa zero e libera tutto il contesto. - `/compact` riassume la conversazione mantenendo il filo, ma per farlo la deve rileggere tutta, quindi su un contesto grosso è una richiesta costosa. - `/rename` prima di pulire e poi `/resume` per tornare indietro. In pratica: se cambi argomento, `/clear`. Se continui lo stesso lavoro, `/compact`. Chi tiene aperta la stessa sessione per sei ore e poi si stupisce del consumo sta rimandando l’intera conversazione a ogni messaggio. ## Casi d’uso reali, con script che ho eseguito Da qui in poi è tutta roba testata sul serio. Comandi, output e file sono quelli veri. ### 1. Modalità headless: l’agente dentro uno script Il flag `-p` esegue una richiesta e basta, senza interfaccia interattiva. È la porta d’ingresso a qualsiasi automazione. ``` # calc.py contiene: def somma(a, b): return a - b (bug) claude -p "Nel file calc.py c'e' un bug: la funzione somma() sottrae invece di sommare. Correggilo e rispondi solo con OK." \ --allowedTools "Read Edit" ``` Output: `OK`. E il file dopo: ``` def somma(a, b): return a + b ``` `--allowedTools` è la parte che conta per la sicurezza: in quella esecuzione l’agente poteva solo leggere e modificare file. Niente shell, niente rete. Su una pipeline non presidiata quel flag non è opzionale. ### 2. Output JSON per le pipeline ``` claude -p "Rispondi solo con la parola: pronto" --output-format json | jq -r '.result' # pronto ``` L’oggetto JSON completo contiene anche `duration_ms`, `num_turns`, `stop_reason`, `total_cost_usd` e il dettaglio dei token per modello. Se stai costruendo un job schedulato, quello è il tuo punto di misura: leggi `total_cost_usd` e ti accorgi subito quando qualcosa è andato in loop. ### 3. Un hook che blocca i comandi distruttivi Gli hook sono script che si agganciano agli eventi del ciclo agentico. `PreToolUse` gira **prima** che uno strumento venga eseguito, e può negare l’esecuzione. È il modo pulito per mettere un guardrail che non dipende dalla buona volontà del modello. `.claude/hooks/blocca-rm.sh`: ``` #!/bin/bash # PreToolUse: blocca i comandi distruttivi prima che vengano eseguiti. input=$(cat) cmd=$(echo "$input" | jq -r '.tool_input.command // ""') if echo "$cmd" | grep -qE '(rm[[:space:]]+-[a-zA-Z]*[rf]|mkfs|dd[[:space:]]+if=)'; then jq -n '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:"Comando distruttivo bloccato dalla policy del progetto."}}' else echo '{}' fi ``` Registrato in `.claude/settings.json`: ``` { "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [ { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/blocca-rm.sh" } ] } ] } } ``` Ricordati `chmod +x` sullo script. Poi ho chiesto esplicitamente a Claude Code di cancellare una cartella con `rm -rf`. Risposta: “il comando è stato bloccato da una policy del progetto”. La cartella era ancora lì. Non ha nemmeno provato ad aggirare il blocco, e questo è il punto: il controllo sta nel tuo script, non nel prompt. ### 4. Un server MCP fatto in casa, senza dipendenze MCP (Model Context Protocol) è il modo standard per dare a Claude Code strumenti che non ha: un gestionale, un database, un servizio interno. Un server MCP è molto meno complicato di quanto sembri: è un processo che parla JSON-RPC su stdin e stdout e risponde a tre metodi. Questo è un server completo in Python puro, senza librerie esterne. Espone un solo strumento, che conta i giorni lavorativi fra due date. ``` #!/usr/bin/env python3 """Server MCP minimo (stdio, JSON-RPC 2.0), senza dipendenze esterne.""" import json import sys from datetime import date, timedelta TOOLS = [{ "name": "giorni_lavorativi", "description": "Conta i giorni lavorativi (lun-ven) fra due date incluse. Formato YYYY-MM-DD.", "inputSchema": { "type": "object", "properties": { "da": {"type": "string", "description": "Data iniziale YYYY-MM-DD"}, "a": {"type": "string", "description": "Data finale YYYY-MM-DD"}, }, "required": ["da", "a"], }, }] def conta(da, a): d0, d1 = date.fromisoformat(da), date.fromisoformat(a) if d1 < d0: d0, d1 = d1, d0 n, cur = 0, d0 while cur <= d1: if cur.weekday() < 5: n += 1 cur += timedelta(days=1) return n def reply(req_id, result=None, error=None): msg = {"jsonrpc": "2.0", "id": req_id} msg["error" if error else "result"] = error or result sys.stdout.write(json.dumps(msg) + "\n") sys.stdout.flush() for line in sys.stdin: line = line.strip() if not line: continue try: req = json.loads(line) except json.JSONDecodeError: continue method, req_id = req.get("method"), req.get("id") if method == "initialize": reply(req_id, {"protocolVersion": "2024-11-05", "capabilities": {"tools": {}}, "serverInfo": {"name": "giorni-lavorativi", "version": "1.0.0"}}) elif method == "tools/list": reply(req_id, {"tools": TOOLS}) elif method == "tools/call": args = (req.get("params") or {}).get("arguments") or {} try: out = {"content": [{"type": "text", "text": str(conta(args["da"], args["a"]))}]} except Exception as e: out = {"content": [{"type": "text", "text": f"Errore: {e}"}], "isError": True} reply(req_id, out) elif req_id is not None: reply(req_id, error={"code": -32601, "message": f"Metodo non gestito: {method}"}) ``` Si prova prima a mano, senza tirare in mezzo l’agente: ``` printf '%s\n' \ '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' \ '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \ '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"giorni_lavorativi","arguments":{"da":"2026-08-03","a":"2026-08-14"}}}' \ | python3 mcp_giorni.py ``` L’ultima riga risponde `{"content": [{"type": "text", "text": "10"}]}`. Corretto: due settimane piene, dieci giorni lavorativi. Poi lo si registra nel progetto: ``` claude mcp add giorni --scope project -- python3 "$PWD/mcp_giorni.py" claude mcp list ``` Il flag `--scope project` scrive un file `.mcp.json` versionabile insieme al codice, così tutto il team ha lo stesso strumento. E l’ultimo passo, quello vero: ``` claude -p "Usa il tool MCP giorni_lavorativi per contare i giorni lavorativi dal 2026-08-03 al 2026-08-14. Rispondi SOLO con il numero." \ --mcp-config .mcp.json --strict-mcp-config \ --allowedTools "mcp__giorni__giorni_lavorativi" # 10 ``` Nota la convenzione dei nomi: uno strumento MCP si chiama `mcp____`. Serve saperla per scrivere le allowlist. Se il progetto vive su una macchina remota e vuoi che la sessione sopravviva alla chiusura del portatile, ne ho scritto qui: [Claude Code persistente su VPS](https://francescogruner.it/claude-code-persistente-vps/). ## Claude Code docs e download: dove guardare davvero La documentazione ufficiale sta su `code.claude.com/docs`. Due dettagli che fanno risparmiare tempo: - Esiste `code.claude.com/docs/llms.txt`, l’indice pensato per essere letto da un modello. Se stai facendo ricerche con un agente, dagli quello invece della homepage. - Dalla riga di comando: `claude --help` per i flag, `/help` dentro la sessione, `claude doctor` per la diagnostica. Sul “download”: non c’è un archivio da scaricare a mano. O usi l’installer, o il gestore di pacchetti, oppure scarichi l’app Desktop per macOS, Windows e Linux se preferisci l’interfaccia grafica. Per gli ambienti regolamentati, ogni release pubblica un `manifest.json` con i checksum SHA256 firmato con la chiave GPG di Anthropic, quindi la verifica di integrità è possibile e documentata. ## Errori comuni e come si risolvono Questi li ho incontrati o riprodotti io. **`claude: command not found` dopo l’installazione via npm.** Il pacchetto npm scarica il binario nativo tramite una dipendenza opzionale per piattaforma. Se il tuo gestore di pacchetti blocca le dipendenze opzionali, il binario non arriva. Soluzione pratica: passa all’installer nativo. **`EBADENGINE` durante `npm install -g`.** Sei sotto Node 22. L’installazione riesce comunque e `claude` funziona, perché a runtime Node non serve. Ma è il segnale che dovresti usare l’installer nativo. **Un server MCP aggiunto con `--scope project` resta in `Pending approval`.** Mi è successo. I server definiti in `.mcp.json` vanno approvati la prima volta: lancia `claude` in interattivo e conferma. In una pipeline non interattiva la scorciatoia è passare `--mcp-config .mcp.json --strict-mcp-config`, che carica solo quei server e ignora la configurazione globale. **Su Alpine Linux l’installer si ferma con `not found`.** Alpine non ha né bash né curl di default. Servono `bash`, `curl`, `libgcc`, `libstdc++` e `ripgrep`, e poi va impostato `USE_BUILTIN_RIPGREP` a `0` nel settings.json. **“You’ve hit your session limit” o “weekly limit”.** È il tetto d’uso del piano, non un problema tecnico. Le finestre sono condivise fra tutti i modelli: cambiare modello con `/model` non te lo restituisce, anche se ti fa ripartire dopo il messaggio specifico sul limite di Opus. **L’avviso di contesto o di auto-compattazione non è un limite d’uso.** Vuol dire solo che la conversazione si sta avvicinando alla dimensione massima di input e Claude Code sta riassumendo la parte vecchia. Se capita spesso, il problema è che non usi `/clear`. **Un hook non scatta.** Controlla con `/hooks` che compaia sotto l’evento giusto, verifica il permesso di esecuzione sullo script, e nel dubbio lancia `claude --debug`. ## Limiti onesti: quando Claude Code non conviene Lo uso tutti i giorni, quindi mi sono fatto anche un’idea di dove non regge. **Il costo esplode sulle sessioni lunghe, e non per colpa tua.** La conversazione intera viene rimandata a ogni messaggio. Un “sì, vai” scritto dopo sei ore di lavoro costa quanto tutta la conversazione. A questo si aggiungono i cache miss: la prima richiesta dopo una pausa lunga riprocessa tutto il contesto da zero. **Gli agent team costano molto.** La documentazione ufficiale parla di circa 7 volte i token di una sessione normale quando i compagni di squadra lavorano in plan mode, perché ognuno ha la sua finestra di contesto. Non a caso sono disattivati di default. **Non fa immagini.** È un agente da codice e file: per la parte visiva servono altri strumenti, e non sempre reggono l’italiano, come ho misurato [testando Nano Banana sul testo in italiano](https://francescogruner.it/nano-banana-testo-italiano/). **Su compiti banali è un lusso.** Rinominare tre variabili si fa prima a mano. Rende quando il compito è esplorativo, ripetitivo su molti file, o richiede leggere prima di scrivere. **Il guardrail è compito tuo.** Il modello è un agente che esegue comandi. Permessi, allowlist e hook non sono opzionali su un progetto che conta, e non vanno affidati al prompt: vanno messi nella configurazione, dove il modello non può ignorarli. **Va comunque riletto.** Nei test qui sopra ha fatto tutto giusto, ma su codice reale capita che sistemi il sintomo e non la causa. La differenza fra chi ci guadagna tempo e chi ne perde è quasi sempre la revisione. ## In pratica L’equivoco iniziale, quello della chat che scrive codice, si scioglie appena lo installi: Claude Code non ti suggerisce il codice, lo esegue e lo verifica dentro il tuo progetto. Il valore però non sta nel modello, sta nella configurazione. Un `CLAUDE.md` corto e serio, due o tre skill, un hook che blocca le cose irreversibili e, se ti serve, un server MCP da cinquanta righe che gli apre i tuoi sistemi. Se parti oggi: installer nativo, piano Pro per capire se ti serve, `CLAUDE.md` nel progetto, `/clear` fra un lavoro e l’altro. Il resto arriva dopo. Claude Code funziona con il piano gratuito di Claude? No. La documentazione ufficiale è esplicita: serve un piano **Pro, Max, Team, Enterprise o un account Console** con fatturazione a consumo. Il piano gratuito di claude.ai non include Claude Code. In alternativa si può usare tramite Amazon Bedrock, Google Cloud Agent Platform o Microsoft Foundry, con la spesa a carico del proprio account cloud. Claude Code pricing: quanto costa al mese? Il piano Pro costa **17 dollari al mese con abbonamento annuale** (200 dollari anticipati) oppure 20 dollari se pagato mensilmente. Max 5x costa 100 dollari al mese, Max 20x 200 dollari. I posti Team partono da 20 dollari al mese con fatturazione annuale. Sui piani API si paga solo il consumo: Anthropic indica una media enterprise di circa 13 dollari per sviluppatore per giorno attivo. Claude code install: come si installa su Windows? Da PowerShell con `irm https://claude.ai/install.ps1 | iex`, oppure con `winget install Anthropic.ClaudeCode`. Non serve eseguire come amministratore. Git for Windows è opzionale ma consigliato, perché abilita lo strumento Bash: senza, Claude Code usa PowerShell. In alternativa si può lavorare dentro WSL 2, che è l’unica opzione con il sandboxing. Claude code download: dove si scarica il pacchetto? Non esiste un archivio da scaricare a mano nel senso classico. Si usa l’installer (`curl -fsSL https://claude.ai/install.sh | bash`), un gestore di pacchetti come Homebrew, WinGet, apt, dnf o apk, oppure l’app Desktop per macOS, Windows e Linux. Ogni release pubblica anche un `manifest.json` firmato con i checksum SHA256 per la verifica di integrità. Claude code docs: dov’è la documentazione ufficiale? Su **code.claude.com/docs**. Esiste anche `code.claude.com/docs/llms.txt`, l’indice completo pensato per essere letto da un modello: è la versione da dare a un agente che deve fare ricerca. Dal terminale bastano `claude --help` per i flag e `/help` dentro la sessione. Serve Node.js per usare Claude Code? No, non più. L’installer nativo scarica un binario che non usa Node a runtime. Node serve solo se scegli l’installazione via npm, e dalla versione 2.1.198 il pacchetto richiede **Node.js 22 o superiore**. Su versioni più vecchie npm stampa un avviso EBADENGINE ma l’installazione riesce comunque. Come si collega un server MCP a Claude Code? Con `claude mcp add nome --scope project -- comando` per un server stdio, oppure `claude mcp add --transport http nome URL` per uno remoto. Lo scope `project` scrive un file `.mcp.json` versionabile con il codice. La prima volta va approvato in sessione interattiva; in una pipeline si usa `--mcp-config .mcp.json --strict-mcp-config`. Prezzi, requisiti e comandi di questa guida sono stati verificati sulla documentazione ufficiale Anthropic il 25 luglio 2026, e i comandi sono stati eseguiti su Claude Code 2.1.215. [code.claude.com ### Claude Code, setup avanzato Requisiti di sistema, tutti i metodi di installazione, verifica del binario e piani necessari per l’autenticazione. Apri fonte](https://code.claude.com/docs/en/setup) [code.claude.com ### Manage costs effectively Medie di spesa per sviluppatore, comando /usage, costo degli agent team e strategie per ridurre i token. Apri fonte](https://code.claude.com/docs/en/costs) [claude.com ### Piani e prezzi Claude Listino ufficiale dei piani Free, Pro, Max, Team ed Enterprise e quali includono Claude Code. Apri fonte](https://claude.com/pricing) [support.claude.com ### Cos’è il piano Max Prezzi dei due livelli Max, 100 e 200 dollari al mese, e moltiplicatori d’uso rispetto al piano Pro. Apri fonte](https://support.claude.com/en/articles/11049741-what-is-the-max-plan) [code.claude.com ### MCP con Claude Code Comandi claude mcp add, scope local, project e user, trasporti stdio e HTTP, e file .mcp.json. Apri fonte](https://code.claude.com/docs/en/mcp) [code.claude.com ### Hook di Claude Code Eventi disponibili, formato JSON di input e output e come negare l’esecuzione di uno strumento. Apri fonte](https://code.claude.com/docs/en/hooks) Aggiorno questa guida quando cambiano prezzi o comandi. Se vuoi i prossimi test su Claude Code prima degli altri, iscriviti alla newsletter dal sito.