Claude Code: guida completa 2026 (installazione e prezzi)

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.

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):

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, 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. 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.

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.

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

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

claude.com

Piani e prezzi Claude

Listino ufficiale dei piani Free, Pro, Max, Team ed Enterprise e quali includono Claude Code.

Apri fonte

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

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

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

Aggiorno questa guida quando cambiano prezzi o comandi. Se vuoi i prossimi test su Claude Code prima degli altri, iscriviti alla newsletter dal sito.

Nuovo su Google

Aggiungi francescogruner.it come fonte preferita

Se leggi spesso i miei articoli su AI, automazione e tecnologia, ora puoi dire a Google che vuoi vedere più spesso i contenuti di francescogruner.it tra le notizie.