SpyBara
Go Premium

Documentation 2026-10-29 23:57 UTC to 2026-10-30 23:01 UTC

90 files changed +4,598 −4,545. View all changes and history on the product overview
2026
Fri 30 23:01 Thu 29 23:57 Wed 28 23:57 Tue 27 22:59 Mon 26 22:57 Sun 25 23:58 Sat 24 22:59 Fri 23 22:59 Thu 22 22:58 Wed 21 23:02 Tue 20 23:00 Mon 19 23:58 Sat 17 23:57 Fri 16 22:59 Thu 15 23:58 Wed 14 22:58 Tue 13 23:57 Sun 11 23:57 Sat 10 23:01 Fri 9 23:02 Thu 8 22:58 Wed 7 23:59 Tue 6 23:59 Mon 5 23:58 Sun 4 23:58 Sat 3 23:57 Fri 2 22:59 Thu 1 23:59
Details

77* **Python:** controllate i tipi di messaggi con `isinstance()` rispetto alle classi importate da `claude_agent_sdk` (ad esempio, `isinstance(message, ResultMessage)`).77* **Python:** controllate i tipi di messaggi con `isinstance()` rispetto alle classi importate da `claude_agent_sdk` (ad esempio, `isinstance(message, ResultMessage)`).

78* **TypeScript:** controllate il campo stringa `type` (ad esempio, `message.type === "result"`). `AssistantMessage` e `UserMessage` avvolgono il messaggio API grezzo in un campo `.message`, quindi i blocchi di contenuto si trovano in `message.message.content`, non in `message.content`.78* **TypeScript:** controllate il campo stringa `type` (ad esempio, `message.type === "result"`). `AssistantMessage` e `UserMessage` avvolgono il messaggio API grezzo in un campo `.message`, quindi i blocchi di contenuto si trovano in `message.message.content`, non in `message.content`.

79 79 

80> **Esempio: Controllare i tipi di messaggi e gestire i risultati**80> [accordion] Esempio: Controllare i tipi di messaggi e gestire i risultati

81>81>

82> ```python Python theme={null}82> ```python Python theme={null}

83> import asyncio83> import asyncio

273* **Hook `PreCompact`:** Eseguire logica personalizzata prima che si verifichi la compattazione, ad esempio per archiviare la trascrizione completa. L'hook riceve un campo `trigger` (`manual` o `auto`). Vedere [hooks](https://code.claude.com/docs/it/agent-sdk/hooks.md).273* **Hook `PreCompact`:** Eseguire logica personalizzata prima che si verifichi la compattazione, ad esempio per archiviare la trascrizione completa. L'hook riceve un campo `trigger` (`manual` o `auto`). Vedere [hooks](https://code.claude.com/docs/it/agent-sdk/hooks.md).

274* **Compattazione manuale:** Inviare `/compact` come stringa di prompt per attivare la compattazione su richiesta. I comandi inviati in questo modo sono input SDK ordinari. Vedere [dispatch commands by name](https://code.claude.com/docs/it/agent-sdk/skills.md#dispatch-commands-by-name).274* **Compattazione manuale:** Inviare `/compact` come stringa di prompt per attivare la compattazione su richiesta. I comandi inviati in questo modo sono input SDK ordinari. Vedere [dispatch commands by name](https://code.claude.com/docs/it/agent-sdk/skills.md#dispatch-commands-by-name).

275 275 

276> **Esempio: Istruzioni di riassunto in CLAUDE.md**276> [accordion] Esempio: Istruzioni di riassunto in CLAUDE.md

277>277>

278> Aggiungete una sezione al vostro CLAUDE.md del progetto dicendo al compattatore cosa preservare. Il nome dell'intestazione non è speciale; utilizzate qualsiasi etichetta chiara.278> Aggiungete una sezione al vostro CLAUDE.md del progetto dicendo al compattatore cosa preservare. Il nome dell'intestazione non è speciale; utilizzate qualsiasi etichetta chiara.

279>279>

Details

42 42 

43Gli esempi Python in questa pagina che effettuano richieste HTTP utilizzano [httpx](https://www.python-httpx.org/). Aggiungilo con il gestore di pacchetti utilizzato dal tuo progetto:43Gli esempi Python in questa pagina che effettuano richieste HTTP utilizzano [httpx](https://www.python-httpx.org/). Aggiungilo con il gestore di pacchetti utilizzato dal tuo progetto:

44 44 

45**Python (uv)**45> [tab] Python (uv)

46 46>

47```bash theme={null}47> ```bash theme={null}

48uv add httpx48> uv add httpx

49```49> ```

50 

51**Python (pip)**

52 50 

53```bash theme={null}51> [tab] Python (pip)

54pip install httpx52>

55```53> ```bash theme={null}

54> pip install httpx

55> ```

56 56 

57### Esempio di strumento meteo57### Esempio di strumento meteo

58 58 

198 198 

199Combina questo snippet con le definizioni di strumento e server dall'[esempio di strumento meteo](#weather-tool-example) in un unico file, `weather.py` o `weather.ts`, quindi eseguilo dal tuo terminale:199Combina questo snippet con le definizioni di strumento e server dall'[esempio di strumento meteo](#weather-tool-example) in un unico file, `weather.py` o `weather.ts`, quindi eseguilo dal tuo terminale:

200 200 

201**TypeScript**201> [tab] TypeScript

202 202>

203```bash theme={null}203> ```bash theme={null}

204npx tsx weather.ts204> npx tsx weather.ts

205```205> ```

206 

207**Python (uv)**

208 

209```bash theme={null}

210uv run weather.py

211```

212 

213**Python (pip)**

214 206 

215Attiva l'ambiente virtuale in cui hai installato l'SDK, quindi esegui:207> [tab] Python (uv)

208>

209> ```bash theme={null}

210> uv run weather.py

211> ```

216 212 

217```bash theme={null}213> [tab] Python (pip)

218python weather.py214>

219```215> Attiva l'ambiente virtuale in cui hai installato l'SDK, quindi esegui:

216>

217> ```bash theme={null}

218> python weather.py

219> ```

220 220 

221Claude chiama `get_temperature` e lo script stampa una risposta su una riga con la temperatura attuale a San Francisco.221Claude chiama `get_temperature` e lo script stampa una risposta su una riga con la temperatura attuale a San Francisco.

222 222 

Details

585>585>

586> Apri il tuo file di utilità (`utils.py` o `utils.ts`) nel tuo IDE o editor prima di eseguire lo script. Vedrai il file aggiornarsi in tempo reale mentre l'agente aggiunge commenti doc, quindi tornare all'originale quando scegli di ripristinare.586> Apri il tuo file di utilità (`utils.py` o `utils.ts`) nel tuo IDE o editor prima di eseguire lo script. Vedrai il file aggiornarsi in tempo reale mentre l'agente aggiunge commenti doc, quindi tornare all'originale quando scegli di ripristinare.

587 587 

588**Python**588> [tab] Python

589 589>

590```bash theme={null}590> ```bash theme={null}

591python try_checkpointing.py591> python try_checkpointing.py

592```592> ```

593 

594**TypeScript**

595 593 

596```bash theme={null}594> [tab] TypeScript

597npx tsx try_checkpointing.ts595>

598```596> ```bash theme={null}

597> npx tsx try_checkpointing.ts

598> ```

599 599 

600Vedrai l'agente aggiungere commenti doc, quindi un prompt che ti chiede se vuoi ripristinare. Se scegli sì, il file viene ripristinato al suo stato originale.600Vedrai l'agente aggiungere commenti doc, quindi un prompt che ti chiede se vuoi ripristinare. Se scegli sì, il file viene ripristinato al suo stato originale.

601 601 

agent-sdk/mcp.md +98 −98

Details

386 386 

387Utilizzare il campo `env` per passare chiavi API, token e altre credenziali al server MCP:387Utilizzare il campo `env` per passare chiavi API, token e altre credenziali al server MCP:

388 388 

389**Nel codice**389> [tab] Nel codice

390 390>

391```typescript TypeScript hidelines={1,-1} theme={null}391> ```typescript TypeScript hidelines={1,-1} theme={null}

392const _ = {392> const _ = {

393 options: {393> options: {

394 mcpServers: {394> mcpServers: {

395 "api-server": {395> "api-server": {

396 command: "npx",396> command: "npx",

397 args: ["-y", "@your-org/api-mcp-server"],397> args: ["-y", "@your-org/api-mcp-server"],

398 env: {398> env: {

399 API_KEY: process.env.API_KEY399> API_KEY: process.env.API_KEY

400 }400> }

401 }401> }

402 },402> },

403 allowedTools: ["mcp__api-server__*"]403> allowedTools: ["mcp__api-server__*"]

404 }404> }

405};405> };

406```406> ```

407 407>

408```python Python theme={null}408> ```python Python theme={null}

409options = ClaudeAgentOptions(409> options = ClaudeAgentOptions(

410 mcp_servers={410> mcp_servers={

411 "api-server": {411> "api-server": {

412 "command": "npx",412> "command": "npx",

413 "args": ["-y", "@your-org/api-mcp-server"],413> "args": ["-y", "@your-org/api-mcp-server"],

414 "env": {"API_KEY": os.environ["API_KEY"]},414> "env": {"API_KEY": os.environ["API_KEY"]},

415 }415> }

416 },416> },

417 allowed_tools=["mcp__api-server__*"],417> allowed_tools=["mcp__api-server__*"],

418)418> )

419```419> ```

420 420 

421**.mcp.json**421> [tab] .mcp.json

422 422>

423```json theme={null}423> ```json theme={null}

424{424> {

425 "mcpServers": {425> "mcpServers": {

426 "api-server": {426> "api-server": {

427 "command": "npx",427> "command": "npx",

428 "args": ["-y", "@your-org/api-mcp-server"],428> "args": ["-y", "@your-org/api-mcp-server"],

429 "env": {429> "env": {

430 "API_KEY": "${API_KEY}"430> "API_KEY": "${API_KEY}"

431 }431> }

432 }432> }

433 }433> }

434}434> }

435```435> ```

436 436>

437La sintassi `${API_KEY}` espande le variabili di ambiente in fase di esecuzione.437> La sintassi `${API_KEY}` espande le variabili di ambiente in fase di esecuzione.

438 438 

439### Intestazioni HTTP per server remoti439### Intestazioni HTTP per server remoti

440 440 

441Per i server HTTP e SSE, passare le intestazioni di autenticazione direttamente nella configurazione del server:441Per i server HTTP e SSE, passare le intestazioni di autenticazione direttamente nella configurazione del server:

442 442 

443**Nel codice**443> [tab] Nel codice

444 444>

445```typescript TypeScript hidelines={1,-1} theme={null}445> ```typescript TypeScript hidelines={1,-1} theme={null}

446const _ = {446> const _ = {

447 options: {447> options: {

448 mcpServers: {448> mcpServers: {

449 "secure-api": {449> "secure-api": {

450 type: "http",450> type: "http",

451 url: "https://api.example.com/mcp",451> url: "https://api.example.com/mcp",

452 headers: {452> headers: {

453 Authorization: `Bearer ${process.env.API_TOKEN}`453> Authorization: `Bearer ${process.env.API_TOKEN}`

454 }454> }

455 }455> }

456 },456> },

457 allowedTools: ["mcp__secure-api__*"]457> allowedTools: ["mcp__secure-api__*"]

458 }458> }

459};459> };

460```460> ```

461 461>

462```python Python theme={null}462> ```python Python theme={null}

463options = ClaudeAgentOptions(463> options = ClaudeAgentOptions(

464 mcp_servers={464> mcp_servers={

465 "secure-api": {465> "secure-api": {

466 "type": "http",466> "type": "http",

467 "url": "https://api.example.com/mcp",467> "url": "https://api.example.com/mcp",

468 "headers": {"Authorization": f"Bearer {os.environ['API_TOKEN']}"},468> "headers": {"Authorization": f"Bearer {os.environ['API_TOKEN']}"},

469 }469> }

470 },470> },

471 allowed_tools=["mcp__secure-api__*"],471> allowed_tools=["mcp__secure-api__*"],

472)472> )

473```473> ```

474 474 

475**.mcp.json**475> [tab] .mcp.json

476 476>

477```json theme={null}477> ```json theme={null}

478{478> {

479 "mcpServers": {479> "mcpServers": {

480 "secure-api": {480> "secure-api": {

481 "type": "http",481> "type": "http",

482 "url": "https://api.example.com/mcp",482> "url": "https://api.example.com/mcp",

483 "headers": {483> "headers": {

484 "Authorization": "Bearer ${API_TOKEN}"484> "Authorization": "Bearer ${API_TOKEN}"

485 }485> }

486 }486> }

487 }487> }

488}488> }

489```489> ```

490 490>

491La sintassi `${API_TOKEN}` espande le variabili di ambiente in fase di esecuzione.491> La sintassi `${API_TOKEN}` espande le variabili di ambiente in fase di esecuzione.

492 492 

493Per un esempio completo e funzionante di un server remoto autenticato con intestazioni, vedere [Elencare i problemi da un repository](#list-issues-from-a-repository).493Per un esempio completo e funzionante di un server remoto autenticato con intestazioni, vedere [Elencare i problemi da un repository](#list-issues-from-a-repository).

494 494 

Details

163 163 

164È possibile impostare la modalità di autorizzazione una volta all'avvio di una query, oppure modificarla dinamicamente mentre la sessione è attiva.164È possibile impostare la modalità di autorizzazione una volta all'avvio di una query, oppure modificarla dinamicamente mentre la sessione è attiva.

165 165 

166**Al momento della query**166> [tab] Al momento della query

167 167>

168Passa `permission_mode` (Python) o `permissionMode` (TypeScript) quando crei una query.168> Passa `permission_mode` (Python) o `permissionMode` (TypeScript) quando crei una query.

169 169>

170```python Python theme={null}170> ```python Python theme={null}

171import asyncio171> import asyncio

172from claude_agent_sdk import query, ClaudeAgentOptions172> from claude_agent_sdk import query, ClaudeAgentOptions

173 173>

174 174>

175async def main():175> async def main():

176 async for message in query(176> async for message in query(

177 prompt="Help me refactor this code",177> prompt="Help me refactor this code",

178 options=ClaudeAgentOptions(178> options=ClaudeAgentOptions(

179 permission_mode="default", # Set the mode here179> permission_mode="default", # Set the mode here

180 ),180> ),

181 ):181> ):

182 if hasattr(message, "result"):182> if hasattr(message, "result"):

183 print(message.result)183> print(message.result)

184 184>

185 185>

186asyncio.run(main())186> asyncio.run(main())

187```187> ```

188 188>

189```typescript TypeScript theme={null}189> ```typescript TypeScript theme={null}

190import { query } from "@anthropic-ai/claude-agent-sdk";190> import { query } from "@anthropic-ai/claude-agent-sdk";

191 191>

192async function main() {192> async function main() {

193 for await (const message of query({193> for await (const message of query({

194 prompt: "Help me refactor this code",194> prompt: "Help me refactor this code",

195 options: {195> options: {

196 permissionMode: "default" // Set the mode here196> permissionMode: "default" // Set the mode here

197 }197> }

198 })) {198> })) {

199 if ("result" in message) {199> if ("result" in message) {

200 console.log(message.result);200> console.log(message.result);

201 }201> }

202 }202> }

203}203> }

204 204>

205main();205> main();

206```206> ```

207 

208**Durante lo streaming**

209 

210Chiamare `set_permission_mode()` (Python) o `setPermissionMode()` (TypeScript) per modificare la modalità durante la sessione. La nuova modalità ha effetto immediatamente per tutte le successive richieste di strumenti. Questo consente di iniziare in modo restrittivo e allentare le autorizzazioni man mano che la fiducia aumenta, ad esempio passando a `acceptEdits` dopo aver esaminato l'approccio iniziale di Claude.

211 

212```python Python theme={null}

213import asyncio

214from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

215 

216 

217async def main():

218 async with ClaudeSDKClient(

219 options=ClaudeAgentOptions(

220 permission_mode="default", # Start in default mode

221 )

222 ) as client:

223 await client.query("Help me refactor this code")

224 

225 # Change mode dynamically mid-session

226 await client.set_permission_mode("acceptEdits")

227 

228 # Process messages with the new permission mode

229 async for message in client.receive_response():

230 if hasattr(message, "result"):

231 print(message.result)

232 

233 

234asyncio.run(main())

235```

236 207 

237```typescript TypeScript theme={null}208> [tab] Durante lo streaming

238import { query } from "@anthropic-ai/claude-agent-sdk";209>

239 210> Chiamare `set_permission_mode()` (Python) o `setPermissionMode()` (TypeScript) per modificare la modalità durante la sessione. La nuova modalità ha effetto immediatamente per tutte le successive richieste di strumenti. Questo consente di iniziare in modo restrittivo e allentare le autorizzazioni man mano che la fiducia aumenta, ad esempio passando a `acceptEdits` dopo aver esaminato l'approccio iniziale di Claude.

240async function main() {211>

241 const q = query({212> ```python Python theme={null}

242 prompt: "Help me refactor this code",213> import asyncio

243 options: {214> from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

244 permissionMode: "default" // Start in default mode215>

245 }216>

246 });217> async def main():

247 218> async with ClaudeSDKClient(

248 // Change mode dynamically mid-session219> options=ClaudeAgentOptions(

249 await q.setPermissionMode("acceptEdits");220> permission_mode="default", # Start in default mode

250 221> )

251 // Process messages with the new permission mode222> ) as client:

252 for await (const message of q) {223> await client.query("Help me refactor this code")

253 if ("result" in message) {224>

254 console.log(message.result);225> # Change mode dynamically mid-session

255 }226> await client.set_permission_mode("acceptEdits")

256 }227>

257}228> # Process messages with the new permission mode

258 229> async for message in client.receive_response():

259main();230> if hasattr(message, "result"):

260```231> print(message.result)

232>

233>

234> asyncio.run(main())

235> ```

236>

237> ```typescript TypeScript theme={null}

238> import { query } from "@anthropic-ai/claude-agent-sdk";

239>

240> async function main() {

241> const q = query({

242> prompt: "Help me refactor this code",

243> options: {

244> permissionMode: "default" // Start in default mode

245> }

246> });

247>

248> // Change mode dynamically mid-session

249> await q.setPermissionMode("acceptEdits");

250>

251> // Process messages with the new permission mode

252> for await (const message of q) {

253> if ("result" in message) {

254> console.log(message.result);

255> }

256> }

257> }

258>

259> main();

260> ```

261 261 

262### Dettagli della modalità262### Dettagli della modalità

263 263 

Details

36 36 

37Installa il pacchetto Agent SDK per il tuo linguaggio:37Installa il pacchetto Agent SDK per il tuo linguaggio:

38 38 

39**TypeScript (nuovo progetto)**39> [tab] TypeScript (nuovo progetto)

40 40>

41```bash theme={null}41> ```bash theme={null}

42npm init -y42> npm init -y

43npm pkg set type=module43> npm pkg set type=module

44npm install @anthropic-ai/claude-agent-sdk44> npm install @anthropic-ai/claude-agent-sdk

45npm install --save-dev tsx45> npm install --save-dev tsx

46```46> ```

47 47>

48Impostare `"type": "module"` in `package.json` consente al tuo script agente di utilizzare `await` di livello superiore, e [tsx](https://tsx.hirok.io) esegue i file TypeScript direttamente. npm stampa `added N packages` quando l'installazione ha successo.48> Impostare `"type": "module"` in `package.json` consente al tuo script agente di utilizzare `await` di livello superiore, e [tsx](https://tsx.hirok.io) esegue i file TypeScript direttamente. npm stampa `added N packages` quando l'installazione ha successo.

49 

50**TypeScript (progetto esistente)**

51 

52```bash theme={null}

53npm install @anthropic-ai/claude-agent-sdk

54npm install --save-dev tsx

55```

56 

57[tsx](https://tsx.hirok.io) esegue i file TypeScript direttamente. Se il tuo progetto utilizza CommonJS, nomina il tuo script agente `agent.mts` invece di `agent.ts`. L'estensione `.mts` fa sì che tsx tratti il file come un modulo ES, quindi `await` di livello superiore funziona senza convertire l'intero progetto a moduli ES. Utilizza `agent.mts` al posto di `agent.ts` nei passaggi di creazione ed esecuzione successivi in questa guida rapida.

58 

59**Python (uv)**

60 

61[Installa uv](https://docs.astral.sh/uv/), un gestore di pacchetti Python veloce che gestisce automaticamente gli ambienti virtuali. Quindi inizializza un progetto e aggiungi l'SDK:

62 

63```bash theme={null}

64uv init

65uv add claude-agent-sdk

66```

67 

68**Python (pip)**

69 

70Crea e attiva un ambiente virtuale, quindi installa il pacchetto.

71 

72Su macOS o Linux:

73 

74```bash theme={null}

75python3 -m venv .venv

76source .venv/bin/activate

77pip install claude-agent-sdk

78```

79 49 

80Su Windows:50> [tab] TypeScript (progetto esistente)

51>

52> ```bash theme={null}

53> npm install @anthropic-ai/claude-agent-sdk

54> npm install --save-dev tsx

55> ```

56>

57> [tsx](https://tsx.hirok.io) esegue i file TypeScript direttamente. Se il tuo progetto utilizza CommonJS, nomina il tuo script agente `agent.mts` invece di `agent.ts`. L'estensione `.mts` fa sì che tsx tratti il file come un modulo ES, quindi `await` di livello superiore funziona senza convertire l'intero progetto a moduli ES. Utilizza `agent.mts` al posto di `agent.ts` nei passaggi di creazione ed esecuzione successivi in questa guida rapida.

81 58 

82```powershell theme={null}59> [tab] Python (uv)

83py -m venv .venv60>

84.venv\Scripts\Activate.ps161> [Installa uv](https://docs.astral.sh/uv/), un gestore di pacchetti Python veloce che gestisce automaticamente gli ambienti virtuali. Quindi inizializza un progetto e aggiungi l'SDK:

85pip install claude-agent-sdk62>

86```63> ```bash theme={null}

64> uv init

65> uv add claude-agent-sdk

66> ```

87 67 

88Se PowerShell blocca `Activate.ps1` con un errore di criterio di esecuzione, esegui prima `Set-ExecutionPolicy -Scope Process RemoteSigned`.68> [tab] Python (pip)

69>

70> Crea e attiva un ambiente virtuale, quindi installa il pacchetto.

71>

72> Su macOS o Linux:

73>

74> ```bash theme={null}

75> python3 -m venv .venv

76> source .venv/bin/activate

77> pip install claude-agent-sdk

78> ```

79>

80> Su Windows:

81>

82> ```powershell theme={null}

83> py -m venv .venv

84> .venv\Scripts\Activate.ps1

85> pip install claude-agent-sdk

86> ```

87>

88> Se PowerShell blocca `Activate.ps1` con un errore di criterio di esecuzione, esegui prima `Set-ExecutionPolicy -Scope Process RemoteSigned`.

89 89 

90> [!NOTE]90> [!NOTE]

91>91>

98 98 

99Ottieni una chiave API dalla [Claude Console](https://platform.claude.com/), quindi impostala come variabile di ambiente nella shell in cui eseguirai il tuo agente:99Ottieni una chiave API dalla [Claude Console](https://platform.claude.com/), quindi impostala come variabile di ambiente nella shell in cui eseguirai il tuo agente:

100 100 

101**macOS / Linux**101> [tab] macOS / Linux

102 102>

103```bash theme={null}103> ```bash theme={null}

104export ANTHROPIC_API_KEY=your-api-key104> export ANTHROPIC_API_KEY=your-api-key

105```105> ```

106 

107**Windows (PowerShell)**

108 106 

109```powershell theme={null}107> [tab] Windows (PowerShell)

110$env:ANTHROPIC_API_KEY = "your-api-key"108>

111```109> ```powershell theme={null}

110> $env:ANTHROPIC_API_KEY = "your-api-key"

111> ```

112 112 

113L'SDK legge la chiave dall'ambiente del processo che esegue il tuo agente; non carica automaticamente i file `.env`. Se mantieni la chiave in un file `.env`, caricala tu stesso, ad esempio con il pacchetto `dotenv`, prima di chiamare l'SDK.113L'SDK legge la chiave dall'ambiente del processo che esegue il tuo agente; non carica automaticamente i file `.env`. Se mantieni la chiave in un file `.env`, caricala tu stesso, ad esempio con il pacchetto `dotenv`, prima di chiamare l'SDK.

114 114 

224 224 

225Il tuo agente è pronto. Eseguilo con il seguente comando:225Il tuo agente è pronto. Eseguilo con il seguente comando:

226 226 

227**TypeScript**227> [tab] TypeScript

228 228>

229```bash theme={null}229> ```bash theme={null}

230npx tsx agent.ts230> npx tsx agent.ts

231```231> ```

232 232>

233Se hai nominato il tuo script `agent.mts`, esegui `npx tsx agent.mts` invece.233> Se hai nominato il tuo script `agent.mts`, esegui `npx tsx agent.mts` invece.

234 

235**Python (uv)**

236 

237```bash theme={null}

238uv run agent.py

239```

240 

241**Python (pip)**

242 234 

243Con il tuo ambiente virtuale ancora attivato:235> [tab] Python (uv)

236>

237> ```bash theme={null}

238> uv run agent.py

239> ```

244 240 

245```bash theme={null}241> [tab] Python (pip)

246python agent.py242>

247```243> Con il tuo ambiente virtuale ancora attivato:

244>

245> ```bash theme={null}

246> python agent.py

247> ```

248 248 

249Mentre lavora, l'agente stampa il suo ragionamento e ogni strumento che chiama, terminando con `Done: success`. Dopo l'esecuzione, controlla `utils.py`. Vedrai codice difensivo che gestisce elenchi vuoti e utenti nulli. Il tuo agente autonomamente:249Mentre lavora, l'agente stampa il suo ragionamento e ogni strumento che chiama, terminando con `Done: success`. Dopo l'esecuzione, controlla `utils.py`. Vedrai codice difensivo che gestisce elenchi vuoti e utenti nulli. Il tuo agente autonomamente:

250 250 

Details

470 470 

471Ogni SDK presenta il rifiuto diversamente:471Ogni SDK presenta il rifiuto diversamente:

472 472 

473**TypeScript**473> [tab] TypeScript

474 474>

475L'SDK TypeScript genera un `Error` che indica la regola che la voce ha violato. Ad esempio, `skills: ["docs:*"]` genera:475> L'SDK TypeScript genera un `Error` che indica la regola che la voce ha violato. Ad esempio, `skills: ["docs:*"]` genera:

476 476>

477```text theme={null}477> ```text theme={null}

478Invalid skill name "docs:*": wildcard-suffix names are not allowed; list each skill by its exact name.478> Invalid skill name "docs:*": wildcard-suffix names are not allowed; list each skill by its exact name.

479```479> ```

480 480>

481Un nome vuoto riporta `Skill names must be non-empty strings.`481> Un nome vuoto riporta `Skill names must be non-empty strings.`

482 482>

483Prima dell'Agent SDK TypeScript 0.3.221, l'SDK non eseguiva questo controllo.483> Prima dell'Agent SDK TypeScript 0.3.221, l'SDK non eseguiva questo controllo.

484 

485**Python**

486 

487L'SDK Python genera `ValueError` che indica la regola che la voce ha violato. Ad esempio, `skills=["docs:*"]` genera:

488 

489```text theme={null}

490ValueError: Invalid skill name 'docs:*': wildcard-suffix names are not allowed; list each skill by its exact name.

491```

492 

493Un nome vuoto riporta `Skill names must be non-empty strings`.

494 484 

495Prima dell'Agent SDK Python 0.2.129, l'SDK non eseguiva questo controllo.485> [tab] Python

486>

487> L'SDK Python genera `ValueError` che indica la regola che la voce ha violato. Ad esempio, `skills=["docs:*"]` genera:

488>

489> ```text theme={null}

490> ValueError: Invalid skill name 'docs:*': wildcard-suffix names are not allowed; list each skill by its exact name.

491> ```

492>

493> Un nome vuoto riporta `Skill names must be non-empty strings`.

494>

495> Prima dell'Agent SDK Python 0.2.129, l'SDK non eseguiva questo controllo.

496 496 

497### Risoluzione dei problemi aggiuntiva497### Risoluzione dei problemi aggiuntiva

498 498 

Details

16 16 

17Consideriamo un'app di ricette in cui un agente cerca sul web e recupera ricette. Senza output strutturati, si ottiene testo libero che sarebbe necessario analizzare manualmente. Con output strutturati, si definisce la forma desiderata e si ottengono dati tipizzati che è possibile utilizzare direttamente nell'app.17Consideriamo un'app di ricette in cui un agente cerca sul web e recupera ricette. Senza output strutturati, si ottiene testo libero che sarebbe necessario analizzare manualmente. Con output strutturati, si definisce la forma desiderata e si ottengono dati tipizzati che è possibile utilizzare direttamente nell'app.

18 18 

19> **Senza output strutturati**19> [accordion] Senza output strutturati

20>20>

21> ```text theme={null}21> ```text theme={null}

22> Ecco una ricetta classica di biscotti al cioccolato!22> Ecco una ricetta classica di biscotti al cioccolato!

32>32>

33> Per utilizzare questo nell'app, sarebbe necessario analizzare il titolo, convertire "15 minuti" in un numero, separare gli ingredienti dalle istruzioni e gestire la formattazione incoerente tra le risposte.33> Per utilizzare questo nell'app, sarebbe necessario analizzare il titolo, convertire "15 minuti" in un numero, separare gli ingredienti dalle istruzioni e gestire la formattazione incoerente tra le risposte.

34 34 

35> **Con output strutturati**35> [accordion] Con output strutturati

36>36>

37> ```jsonc theme={null}37> ```jsonc theme={null}

38> {38> {

Details

225 225 

226Gli helper `ask_user` e `askUser` nei seguenti snippet stanno al posto della tua applicazione stessa per l'interfaccia utente di prompt.226Gli helper `ask_user` e `askUser` nei seguenti snippet stanno al posto della tua applicazione stessa per l'interfaccia utente di prompt.

227 227 

228**Approva**228> [tab] Approva

229 229>

230L'utente approva l'azione così com'è. Passa l'`input` dal tuo callback invariato e lo strumento viene eseguito esattamente come richiesto da Claude.230> L'utente approva l'azione così com'è. Passa l'`input` dal tuo callback invariato e lo strumento viene eseguito esattamente come richiesto da Claude.

231 231>

232```python Python theme={null}232> ```python Python theme={null}

233async def can_use_tool(tool_name, input_data, context):233> async def can_use_tool(tool_name, input_data, context):

234 print(f"Claude wants to use {tool_name}")234> print(f"Claude wants to use {tool_name}")

235 approved = await ask_user("Allow this action?")235> approved = await ask_user("Allow this action?")

236 236>

237 if approved:237> if approved:

238 return PermissionResultAllow(updated_input=input_data)238> return PermissionResultAllow(updated_input=input_data)

239 return PermissionResultDeny(message="User declined")239> return PermissionResultDeny(message="User declined")

240```240> ```

241 241>

242```typescript TypeScript theme={null}242> ```typescript TypeScript theme={null}

243canUseTool: async (toolName, input) => {243> canUseTool: async (toolName, input) => {

244 console.log(`Claude wants to use ${toolName}`);244> console.log(`Claude wants to use ${toolName}`);

245 const approved = await askUser("Allow this action?");245> const approved = await askUser("Allow this action?");

246 246>

247 if (approved) {247> if (approved) {

248 return { behavior: "allow", updatedInput: input };248> return { behavior: "allow", updatedInput: input };

249 }249> }

250 return { behavior: "deny", message: "User declined" };250> return { behavior: "deny", message: "User declined" };

251};251> };

252```252> ```

253 253 

254**Approva con modifiche**254> [tab] Approva con modifiche

255 255>

256L'utente approva ma vuole modificare la richiesta prima. Puoi cambiare l'input prima che lo strumento venga eseguito. Claude vede il risultato ma non gli viene detto che hai cambiato qualcosa. Utile per sanitizzare i parametri, aggiungere vincoli o limitare l'accesso.256> L'utente approva ma vuole modificare la richiesta prima. Puoi cambiare l'input prima che lo strumento venga eseguito. Claude vede il risultato ma non gli viene detto che hai cambiato qualcosa. Utile per sanitizzare i parametri, aggiungere vincoli o limitare l'accesso.

257 257>

258```python Python theme={null}258> ```python Python theme={null}

259async def can_use_tool(tool_name, input_data, context):259> async def can_use_tool(tool_name, input_data, context):

260 if tool_name == "Bash":260> if tool_name == "Bash":

261 # L'utente ha approvato, ma limita tutti i comandi alla sandbox261> # L'utente ha approvato, ma limita tutti i comandi alla sandbox

262 sandboxed_input = {**input_data}262> sandboxed_input = {**input_data}

263 sandboxed_input["command"] = input_data["command"].replace(263> sandboxed_input["command"] = input_data["command"].replace(

264 "/tmp", "/tmp/sandbox"264> "/tmp", "/tmp/sandbox"

265 )265> )

266 return PermissionResultAllow(updated_input=sandboxed_input)266> return PermissionResultAllow(updated_input=sandboxed_input)

267 return PermissionResultAllow(updated_input=input_data)267> return PermissionResultAllow(updated_input=input_data)

268```268> ```

269 269>

270```typescript TypeScript theme={null}270> ```typescript TypeScript theme={null}

271canUseTool: async (toolName, input) => {271> canUseTool: async (toolName, input) => {

272 if (toolName === "Bash") {272> if (toolName === "Bash") {

273 // L'utente ha approvato, ma limita tutti i comandi alla sandbox273> // L'utente ha approvato, ma limita tutti i comandi alla sandbox

274 const sandboxedInput = {274> const sandboxedInput = {

275 ...input,275> ...input,

276 command: input.command.replace("/tmp", "/tmp/sandbox")276> command: input.command.replace("/tmp", "/tmp/sandbox")

277 };277> };

278 return { behavior: "allow", updatedInput: sandboxedInput };278> return { behavior: "allow", updatedInput: sandboxedInput };

279 }279> }

280 return { behavior: "allow", updatedInput: input };280> return { behavior: "allow", updatedInput: input };

281};281> };

282```282> ```

283 283 

284**Approva e ricorda**284> [tab] Approva e ricorda

285 285>

286L'utente approva e non vuole essere chiesto di nuovo per questo tipo di chiamata. Il terzo argomento del callback contiene `suggestions`, un array di voci [`PermissionUpdate`](https://code.claude.com/docs/it/agent-sdk/typescript#permissionupdate) già pronte. Ripeti una di queste in `updatedPermissions` per applicarla. Un suggerimento con la destinazione `localSettings` scrive la regola in `.claude/settings.local.json` in modo che le sessioni future saltino il prompt per le chiamate corrispondenti.286> L'utente approva e non vuole essere chiesto di nuovo per questo tipo di chiamata. Il terzo argomento del callback contiene `suggestions`, un array di voci [`PermissionUpdate`](https://code.claude.com/docs/it/agent-sdk/typescript#permissionupdate) già pronte. Ripeti una di queste in `updatedPermissions` per applicarla. Un suggerimento con la destinazione `localSettings` scrive la regola in `.claude/settings.local.json` in modo che le sessioni future saltino il prompt per le chiamate corrispondenti.

287 287>

288In TypeScript, salta la scelta di sempre consentire per una richiesta le cui opzioni portano [`suppressAlwaysAllowRule: true`](https://code.claude.com/docs/it/agent-sdk/typescript#canusetool). L'hint richiede Agent SDK v0.3.268 o successivo, e il `context` Python non lo contiene.288> In TypeScript, salta la scelta di sempre consentire per una richiesta le cui opzioni portano [`suppressAlwaysAllowRule: true`](https://code.claude.com/docs/it/agent-sdk/typescript#canusetool). L'hint richiede Agent SDK v0.3.268 o successivo, e il `context` Python non lo contiene.

289 289>

290L'esempio Python richiede `claude-agent-sdk` 0.1.80 o successivo.290> L'esempio Python richiede `claude-agent-sdk` 0.1.80 o successivo.

291 291>

292```python Python theme={null}292> ```python Python theme={null}

293async def can_use_tool(tool_name, input_data, context):293> async def can_use_tool(tool_name, input_data, context):

294 choice = await ask_user(f"Allow {tool_name}?", ["once", "always", "no"])294> choice = await ask_user(f"Allow {tool_name}?", ["once", "always", "no"])

295 295>

296 if choice == "always":296> if choice == "always":

297 persist = [297> persist = [

298 s for s in context.suggestions if s.destination == "localSettings"298> s for s in context.suggestions if s.destination == "localSettings"

299 ]299> ]

300 return PermissionResultAllow(300> return PermissionResultAllow(

301 updated_input=input_data, updated_permissions=persist301> updated_input=input_data, updated_permissions=persist

302 )302> )

303 if choice == "once":303> if choice == "once":

304 return PermissionResultAllow(updated_input=input_data)304> return PermissionResultAllow(updated_input=input_data)

305 return PermissionResultDeny(message="User declined")305> return PermissionResultDeny(message="User declined")

306```306> ```

307 307>

308```typescript TypeScript theme={null}308> ```typescript TypeScript theme={null}

309canUseTool: async (toolName, input, { suggestions = [] }) => {309> canUseTool: async (toolName, input, { suggestions = [] }) => {

310 const choice = await askUser(`Allow ${toolName}?`, ["once", "always", "no"]);310> const choice = await askUser(`Allow ${toolName}?`, ["once", "always", "no"]);

311 311>

312 if (choice === "always") {312> if (choice === "always") {

313 const persist = suggestions.filter(313> const persist = suggestions.filter(

314 (s) => s.destination === "localSettings"314> (s) => s.destination === "localSettings"

315 );315> );

316 return {316> return {

317 behavior: "allow",317> behavior: "allow",

318 updatedInput: input,318> updatedInput: input,

319 updatedPermissions: persist319> updatedPermissions: persist

320 };320> };

321 }321> }

322 if (choice === "once") {322> if (choice === "once") {

323 return { behavior: "allow", updatedInput: input };323> return { behavior: "allow", updatedInput: input };

324 }324> }

325 return { behavior: "deny", message: "User declined" };325> return { behavior: "deny", message: "User declined" };

326};326> };

327```327> ```

328 328 

329**Rifiuta**329> [tab] Rifiuta

330 330>

331L'utente non vuole che questa azione accada. Blocca lo strumento e fornisci un messaggio che spiega il motivo. Claude vede questo messaggio e potrebbe provare un approccio diverso.331> L'utente non vuole che questa azione accada. Blocca lo strumento e fornisci un messaggio che spiega il motivo. Claude vede questo messaggio e potrebbe provare un approccio diverso.

332 332>

333```python Python theme={null}333> ```python Python theme={null}

334async def can_use_tool(tool_name, input_data, context):334> async def can_use_tool(tool_name, input_data, context):

335 approved = await ask_user(f"Allow {tool_name}?")335> approved = await ask_user(f"Allow {tool_name}?")

336 336>

337 if not approved:337> if not approved:

338 return PermissionResultDeny(message="User rejected this action")338> return PermissionResultDeny(message="User rejected this action")

339 return PermissionResultAllow(updated_input=input_data)339> return PermissionResultAllow(updated_input=input_data)

340```340> ```

341 341>

342```typescript TypeScript theme={null}342> ```typescript TypeScript theme={null}

343canUseTool: async (toolName, input) => {343> canUseTool: async (toolName, input) => {

344 const approved = await askUser(`Allow ${toolName}?`);344> const approved = await askUser(`Allow ${toolName}?`);

345 345>

346 if (!approved) {346> if (!approved) {

347 return {347> return {

348 behavior: "deny",348> behavior: "deny",

349 message: "User rejected this action"349> message: "User rejected this action"

350 };350> };

351 }351> }

352 return { behavior: "allow", updatedInput: input };352> return { behavior: "allow", updatedInput: input };

353};353> };

354```354> ```

355 355 

356**Suggerisci alternativa**356> [tab] Suggerisci alternativa

357 357>

358L'utente non vuole questa azione specifica, ma ha un'idea diversa. Blocca lo strumento e includi una guida nel tuo messaggio. Claude leggerà questo e deciderà come procedere in base al tuo feedback.358> L'utente non vuole questa azione specifica, ma ha un'idea diversa. Blocca lo strumento e includi una guida nel tuo messaggio. Claude leggerà questo e deciderà come procedere in base al tuo feedback.

359 359>

360```python Python theme={null}360> ```python Python theme={null}

361async def can_use_tool(tool_name, input_data, context):361> async def can_use_tool(tool_name, input_data, context):

362 if tool_name == "Bash" and "rm" in input_data.get("command", ""):362> if tool_name == "Bash" and "rm" in input_data.get("command", ""):

363 # L'utente non vuole eliminare, suggerisci di comprimere invece363> # L'utente non vuole eliminare, suggerisci di comprimere invece

364 return PermissionResultDeny(364> return PermissionResultDeny(

365 message="User doesn't want to delete files. They asked if you could compress them into an archive instead."365> message="User doesn't want to delete files. They asked if you could compress them into an archive instead."

366 )366> )

367 return PermissionResultAllow(updated_input=input_data)367> return PermissionResultAllow(updated_input=input_data)

368```368> ```

369 369>

370```typescript TypeScript theme={null}370> ```typescript TypeScript theme={null}

371canUseTool: async (toolName, input) => {371> canUseTool: async (toolName, input) => {

372 if (toolName === "Bash" && input.command.includes("rm")) {372> if (toolName === "Bash" && input.command.includes("rm")) {

373 // L'utente non vuole eliminare, suggerisci di comprimere invece373> // L'utente non vuole eliminare, suggerisci di comprimere invece

374 return {374> return {

375 behavior: "deny",375> behavior: "deny",

376 message:376> message:

377 "User doesn't want to delete files. They asked if you could compress them into an archive instead."377> "User doesn't want to delete files. They asked if you could compress them into an archive instead."

378 };378> };

379 }379> }

380 return { behavior: "allow", updatedInput: input };380> return { behavior: "allow", updatedInput: input };

381};381> };

382```382> ```

383 383 

384**Reindirizza completamente**384> [tab] Reindirizza completamente

385 385>

386Per un cambio di direzione completo (non solo una spinta), utilizza [input streaming](https://code.claude.com/docs/it/agent-sdk/streaming-vs-single-mode.md) per inviare a Claude una nuova istruzione direttamente. Questo bypassa la richiesta dello strumento corrente e dà a Claude istruzioni completamente nuove da seguire.386> Per un cambio di direzione completo (non solo una spinta), utilizza [input streaming](https://code.claude.com/docs/it/agent-sdk/streaming-vs-single-mode.md) per inviare a Claude una nuova istruzione direttamente. Questo bypassa la richiesta dello strumento corrente e dà a Claude istruzioni completamente nuove da seguire.

387 387 

388## Gestire domande di chiarimento388## Gestire domande di chiarimento

389 389 

agents.md +1 −1

Details

13| [Subagenti](https://code.claude.com/docs/it/sub-agents.md) | Lavoratori delegati all'interno di una sessione che svolgono un compito secondario nel loro contesto e restituiscono un riepilogo | Un compito secondario allagherebbe la Vostra conversazione principale con risultati di ricerca, log o contenuti di file che non consulterete di nuovo |13| [Subagenti](https://code.claude.com/docs/it/sub-agents.md) | Lavoratori delegati all'interno di una sessione che svolgono un compito secondario nel loro contesto e restituiscono un riepilogo | Un compito secondario allagherebbe la Vostra conversazione principale con risultati di ricerca, log o contenuti di file che non consulterete di nuovo |

14| [Visualizzazione agenti](https://code.claude.com/docs/it/agent-view.md) | Una schermata per inviare e monitorare sessioni in esecuzione in background, aperta con `claude agents`. Anteprima di ricerca | Avete diversi compiti indipendenti e volete delegarli, controllare lo stato a colpo d'occhio e intervenire solo quando uno ha bisogno di voi |14| [Visualizzazione agenti](https://code.claude.com/docs/it/agent-view.md) | Una schermata per inviare e monitorare sessioni in esecuzione in background, aperta con `claude agents`. Anteprima di ricerca | Avete diversi compiti indipendenti e volete delegarli, controllare lo stato a colpo d'occhio e intervenire solo quando uno ha bisogno di voi |

15| [Team di agenti](https://code.claude.com/docs/it/agent-teams.md) | Più sessioni coordinate con un elenco di attività condiviso e messaggistica tra agenti, gestite da un leader. Sperimentale e disabilitato per impostazione predefinita | Volete che Claude divida un progetto in parti, le assegni e mantenga i lavoratori sincronizzati |15| [Team di agenti](https://code.claude.com/docs/it/agent-teams.md) | Più sessioni coordinate con un elenco di attività condiviso e messaggistica tra agenti, gestite da un leader. Sperimentale e disabilitato per impostazione predefinita | Volete che Claude divida un progetto in parti, le assegni e mantenga i lavoratori sincronizzati |

16| [Progetti](https://code.claude.com/docs/it/claude-projects.md) | Una conversazione in corso su claude.ai/code o nell'app desktop. Claude avvia sessioni parallele chiamate thread, nel cloud o, quando lo chiedete, sul vostro computer tramite Remote Control, fornisce a ciascuna le istruzioni del progetto e vi mostra quali hanno bisogno di voi. Beta pubblica su Pro e Max | Il lavoro si estende su molti compiti nel corso di giorni o settimane, dovrebbe continuare a funzionare quando la Vostra macchina è spenta, e preferite descriverlo una volta piuttosto che inviare e tracciare ogni sessione |16| [Progetti](https://code.claude.com/docs/it/claude-projects.md) | Una conversazione in corso su claude.ai/code o nell'app desktop. Claude avvia sessioni parallele chiamate thread, nel cloud o, quando lo chiedi, sul tuo computer tramite Remote Control. Fornisce a ciascuna le istruzioni del progetto e ti mostra quali hanno bisogno di te. Beta pubblica su Pro, Max e Ultra | Il lavoro si estende su molti compiti nel corso di giorni o settimane, dovrebbe continuare a funzionare quando la tua macchina è spenta, e preferisci descriverlo una volta piuttosto che inviare e tracciare ogni sessione |

17| [Flussi di lavoro dinamici](https://code.claude.com/docs/it/workflows.md) | Uno script che esegue molti subagenti e controlla i loro risultati, per un lavoro troppo grande per coordinare in un solo turno o che necessita di più di un singolo passaggio | Un compito è troppo grande per una manciata di subagenti, oppure volete che i risultati siano verificati l'uno contro l'altro: un audit a livello di codebase, una migrazione di 500 file, ricerca verificata in modo incrociato, o un piano elaborato da diversi angoli |17| [Flussi di lavoro dinamici](https://code.claude.com/docs/it/workflows.md) | Uno script che esegue molti subagenti e controlla i loro risultati, per un lavoro troppo grande per coordinare in un solo turno o che necessita di più di un singolo passaggio | Un compito è troppo grande per una manciata di subagenti, oppure volete che i risultati siano verificati l'uno contro l'altro: un audit a livello di codebase, una migrazione di 500 file, ricerca verificata in modo incrociato, o un piano elaborato da diversi angoli |

18 18 

19In ogni approccio i lavoratori sono sessioni Claude. Per coinvolgere uno strumento diverso, esponilo a Claude come [server MCP](https://code.claude.com/docs/it/mcp.md).19In ogni approccio i lavoratori sono sessioni Claude. Per coinvolgere uno strumento diverso, esponilo a Claude come [server MCP](https://code.claude.com/docs/it/mcp.md).

artifacts.md +4 −4

Details

8 8 

9> [!NOTE]9> [!NOTE]

10>10>

11> Gli artifact sono disponibili sui piani Pro, Max, Team ed Enterprise e richiedono una sessione autenticata con [`/login`](https://code.claude.com/docs/it/setup#authenticate). Consulta [Disponibilità](#availability) per l'insieme completo dei requisiti.11> Gli artefatti sono disponibili sui piani Pro, Max, Ultra, Team ed Enterprise e richiedono una sessione autenticata con [`/login`](https://code.claude.com/docs/it/setup#authenticate). Consulta [Disponibilità](#availability) per l'insieme completo dei requisiti.

12 12 

13Un [artifact](https://claude.com/features/artifacts) è una pagina web live e interattiva che Claude Code pubblica dalla tua sessione a un URL privato su claude.ai. La apri in un browser e si aggiorna sul posto mentre la sessione continua. Condividila dall'intestazione della pagina quando vuoi che qualcun altro la veda.13Un [artifact](https://claude.com/features/artifacts) è una pagina web live e interattiva che Claude Code pubblica dalla tua sessione a un URL privato su claude.ai. La apri in un browser e si aggiorna sul posto mentre la sessione continua. Condividila dall'intestazione della pagina quando vuoi che qualcun altro la veda.

14 14 

197 197 

198## Estrarre dati live con i connettori MCP198## Estrarre dati live con i connettori MCP

199 199 

200Un artifact può chiamare i [connettori MCP](https://code.claude.com/docs/it/mcp.md#use-mcp-servers-from-claude-ai) ogni volta che qualcuno lo visualizza, in modo che la pagina mostri dati attuali anziché uno snapshot dalla sessione che l'ha creato. Le chiamate ai connettori dagli artifact sono disponibili nei piani Pro, Max, Team ed Enterprise e richiedono Claude Code v2.1.209 o versioni successive. Nelle versioni precedenti, Claude pubblica la pagina con i dati che la sessione ha raccolto durante la creazione.200Un artefatto può chiamare i [connettori MCP](https://code.claude.com/docs/it/mcp.md#use-mcp-servers-from-claude-ai) ogni volta che qualcuno lo visualizza, in modo che la pagina mostri dati attuali anziché uno snapshot dalla sessione che l'ha creato. Le chiamate ai connettori dagli artefatti sono disponibili nei piani Pro, Max, Ultra, Team ed Enterprise e richiedono Claude Code v2.1.209 o versioni successive. Nelle versioni precedenti, Claude pubblica la pagina con i dati che la sessione ha raccolto durante la creazione.

201 201 

202Per creare una pagina supportata da un connettore, nomina il connettore e i dati che desideri nel tuo prompt:202Per creare una pagina supportata da un connettore, nomina il connettore e i dati che desideri nel tuo prompt:

203 203 

314 314 

315> [!NOTE]315> [!NOTE]

316>316>

317> I modelli sono in beta. Sono attivati per impostazione predefinita sui piani Pro, Max e Team. Sui piani Enterprise, un Owner [attiva ogni modello](https://support.claude.com/en/articles/16994751-artifacts-admin-guide-for-team-and-enterprise-plans) in **Organization settings > Artifacts**. Se la tua organizzazione ha il modello Slides disattivato, `/slides` non appare; se ha il modello Design disattivato, `/design` non bozza progetti. Entrambi i comandi richiedono Claude Code v2.1.265 o versioni successive e una sessione in cui [gli artefatti sono disponibili](#availability).317> I modelli sono in beta. Sono attivati per impostazione predefinita sui piani Pro, Max, Ultra e Team. Sui piani Enterprise, un Owner [attiva ogni modello](https://support.claude.com/en/articles/16994751-artifacts-admin-guide-for-team-and-enterprise-plans) in **Organization settings > Artifacts**. Se la tua organizzazione ha il modello Slides disattivato, `/slides` non appare; se ha il modello Design disattivato, `/design` non crea bozze di progetti. Entrambi i comandi richiedono Claude Code v2.1.265 o versioni successive e una sessione in cui [gli artefatti sono disponibili](#availability).

318 318 

319### Crea una presentazione319### Crea una presentazione

320 320 

368 368 

369| Requirement | Available when |369| Requirement | Available when |

370| :- | :- |370| :- | :- |

371| Plan | Pro, Max, Team o Enterprise. Sui piani Pro e Max, gli artifact sono privati per te fino a quando non li condividi, e non si applica alcuna gestione amministrativa. Sui piani Team ed Enterprise, gli artifact sono abilitati per impostazione predefinita, e un Owner può [disattivarli per l'organizzazione](#manage-artifacts-for-your-organization) nelle impostazioni admin di claude.ai. |371| Piano | Pro, Max, Ultra, Team o Enterprise. Sui piani Pro, Max e Ultra, gli artefatti sono privati per te fino a quando non li condividi, e non si applica alcuna gestione amministrativa. Sui piani Team ed Enterprise, gli artefatti sono abilitati per impostazione predefinita, e un Owner può [disattivarli per l'organizzazione](#manage-artifacts-for-your-organization) nelle impostazioni di amministrazione di claude.ai. |

372| Autenticazione | La sessione è supportata da un account claude.ai: accedi con `/login` nella CLI o nell'app desktop. Le sessioni Claude Tag non richiedono alcun passaggio di accesso. Le sessioni che utilizzano una chiave API, un [token del gateway](https://code.claude.com/docs/it/llm-gateway) o una credenziale del provider cloud non possono pubblicare. |372| Autenticazione | La sessione è supportata da un account claude.ai: accedi con `/login` nella CLI o nell'app desktop. Le sessioni Claude Tag non richiedono alcun passaggio di accesso. Le sessioni che utilizzano una chiave API, un [token del gateway](https://code.claude.com/docs/it/llm-gateway) o una credenziale del provider cloud non possono pubblicare. |

373| Model provider | Anthropic API. Non disponibile su [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md) o [Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md). |373| Model provider | Anthropic API. Non disponibile su [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md) o [Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md). |

374| Organization policy | Le chiavi di crittografia gestite dal cliente (CMEK), HIPAA e [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md) non sono abilitate per l'organizzazione. |374| Organization policy | Le chiavi di crittografia gestite dal cliente (CMEK), HIPAA e [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md) non sono abilitate per l'organizzazione. |

authentication.md +21 −21

Details

23 23 

24Potete autenticarvi con uno di questi tipi di account:24Potete autenticarvi con uno di questi tipi di account:

25 25 

26* **Sottoscrizione Claude Pro o Max**: accedete con il vostro account claude.ai. Sottoscrivete su [claude.com/pricing](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=authentication_pro_max).26* **Abbonamento Claude Pro, Max o Ultra**: accedi con il tuo account claude.ai. Abbonati su [claude.com/pricing](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=authentication_pro_max).

27* **Claude for Teams o Enterprise**: accedete con l'account claude.ai che l'amministratore del vostro team vi ha invitato a utilizzare.27* **Claude for Teams o Enterprise**: accedete con l'account claude.ai che l'amministratore del vostro team vi ha invitato a utilizzare.

28* **Claude Console**: accedete con le vostre credenziali Console. L'amministratore deve avervi [invitato](#claude-console-authentication) prima. Potete accedere con o senza [creare una chiave API](#sign-in-without-an-api-key).28* **Claude Console**: accedete con le vostre credenziali Console. L'amministratore deve avervi [invitato](#claude-console-authentication) prima. Potete accedere con o senza [creare una chiave API](#sign-in-without-an-api-key).

29* **Provider cloud**: se la vostra organizzazione utilizza [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md), o [Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md), impostate le variabili di ambiente richieste prima di eseguire `claude`, oppure selezionate **3rd-party platform** al prompt di accesso, che avvia una procedura guidata di configurazione interattiva per Bedrock e Vertex AI. Non è necessario alcun accesso tramite browser.29* **Provider cloud**: se la vostra organizzazione utilizza [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md), o [Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md), impostate le variabili di ambiente richieste prima di eseguire `claude`, oppure selezionate **3rd-party platform** al prompt di accesso, che avvia una procedura guidata di configurazione interattiva per Bedrock e Vertex AI. Non è necessario alcun accesso tramite browser.

2534. Output dello script [`apiKeyHelper`](https://code.claude.com/docs/it/settings-reference#apikeyhelper). Utilizzatelo per credenziali dinamiche o rotanti, come token di breve durata recuperati da un vault.2534. Output dello script [`apiKeyHelper`](https://code.claude.com/docs/it/settings-reference#apikeyhelper). Utilizzatelo per credenziali dinamiche o rotanti, come token di breve durata recuperati da un vault.

2545. Variabile di ambiente `CLAUDE_CODE_OAUTH_TOKEN`. Un token OAuth di lunga durata generato da [`claude setup-token`](#generate-a-long-lived-token). Utilizzatelo per pipeline CI e script dove l'accesso tramite browser non è disponibile. Se eseguite `/login` mentre la variabile è impostata, Claude Code passa la sessione corrente al nuovo accesso, ma legge di nuovo la variabile in ogni nuova sessione fino a quando non la rimuovete dal Vostro profilo shell o dal blocco `env` di un [file di impostazioni](https://code.claude.com/docs/it/settings.md).2545. Variabile di ambiente `CLAUDE_CODE_OAUTH_TOKEN`. Un token OAuth di lunga durata generato da [`claude setup-token`](#generate-a-long-lived-token). Utilizzatelo per pipeline CI e script dove l'accesso tramite browser non è disponibile. Se eseguite `/login` mentre la variabile è impostata, Claude Code passa la sessione corrente al nuovo accesso, ma legge di nuovo la variabile in ogni nuova sessione fino a quando non la rimuovete dal Vostro profilo shell o dal blocco `env` di un [file di impostazioni](https://code.claude.com/docs/it/settings.md).

2556. Credenziali del profilo Anthropic e di federazione, le credenziali che la CLI `ant` e Workload Identity Federation utilizzano. Un profilo che `ant auth login` ha scritto si classifica qui solo quando lo nominate in `ANTHROPIC_PROFILE`; altrimenti si classifica al di sotto di `/login`. Consultate [Profili Anthropic e credenziali di federazione](#anthropic-profiles-and-federation-credentials).2556. Credenziali del profilo Anthropic e di federazione, le credenziali che la CLI `ant` e Workload Identity Federation utilizzano. Un profilo che `ant auth login` ha scritto si classifica qui solo quando lo nominate in `ANTHROPIC_PROFILE`; altrimenti si classifica al di sotto di `/login`. Consultate [Profili Anthropic e credenziali di federazione](#anthropic-profiles-and-federation-credentials).

2567. Credenziali OAuth di sottoscrizione da `/login`. Questo è il valore predefinito per gli utenti Claude Pro, Max, Team, ed Enterprise.2567. Credenziali OAuth dell'abbonamento da `/login`. Questo è il valore predefinito per gli utenti Claude Pro, Max, Ultra, Team ed Enterprise.

257 257 

258Una sessione del [gateway delle app Claude](https://code.claude.com/docs/it/claude-apps-gateway) autenticata si trova al di fuori di questo elenco: è una selezione di provider come Amazon Bedrock o Google Cloud's Agent Platform, e ha la precedenza su di essi. Quando esiste una sessione gateway, la CLI si autentica con il token gateway anche se `CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_USE_VERTEX`, o `CLAUDE_CODE_USE_FOUNDRY` è impostato, e le fonti di credenziali sopra come il bearer token, la chiave API, `apiKeyHelper`, e i profili non vengono utilizzati.258Una sessione del [gateway delle app Claude](https://code.claude.com/docs/it/claude-apps-gateway) autenticata si trova al di fuori di questo elenco: è una selezione di provider come Amazon Bedrock o Google Cloud's Agent Platform, e ha la precedenza su di essi. Quando esiste una sessione gateway, la CLI si autentica con il token gateway anche se `CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_USE_VERTEX`, o `CLAUDE_CODE_USE_FOUNDRY` è impostato, e le fonti di credenziali sopra come il bearer token, la chiave API, `apiKeyHelper`, e i profili non vengono utilizzati.

259 259 

300 300 

301Il comando apre lo stesso flusso di autorizzazione del browser di `/login`, e il token viene stampato nel terminale dopo che approvate l'accesso nel browser. Non salva il token da nessuna parte; copiatelo e impostatelo come variabile di ambiente `CLAUDE_CODE_OAUTH_TOKEN` ovunque vogliate autenticarvi:301Il comando apre lo stesso flusso di autorizzazione del browser di `/login`, e il token viene stampato nel terminale dopo che approvate l'accesso nel browser. Non salva il token da nessuna parte; copiatelo e impostatelo come variabile di ambiente `CLAUDE_CODE_OAUTH_TOKEN` ovunque vogliate autenticarvi:

302 302 

303**macOS, Linux, WSL**303> [tab] macOS, Linux, WSL

304 304>

305```bash theme={null}305> ```bash theme={null}

306export CLAUDE_CODE_OAUTH_TOKEN=your-token306> export CLAUDE_CODE_OAUTH_TOKEN=your-token

307```307> ```

308 308 

309**Windows PowerShell**309> [tab] Windows PowerShell

310 310>

311```powershell theme={null}311> ```powershell theme={null}

312$env:CLAUDE_CODE_OAUTH_TOKEN = "your-token"312> $env:CLAUDE_CODE_OAUTH_TOKEN = "your-token"

313```313> ```

314 314 

315**Windows CMD**315> [tab] Windows CMD

316 316>

317```batch theme={null}317> ```batch theme={null}

318set CLAUDE_CODE_OAUTH_TOKEN=your-token318> set CLAUDE_CODE_OAUTH_TOKEN=your-token

319```319> ```

320 320 

321Questo token si autentica con la Vostra sottoscrizione Claude e richiede un piano Pro, Max, Team, o Enterprise. Può solo fare richieste di modello, quindi non può stabilire sessioni di [Remote Control](https://code.claude.com/docs/it/remote-control.md) o recuperare [connettori claude.ai](https://code.claude.com/docs/it/mcp.md#use-mcp-servers-from-claude-ai). I server MCP che configurate localmente funzionano ancora.321Questo token si autentica con il tuo abbonamento Claude e richiede un piano Pro, Max, Ultra, Team o Enterprise. Può solo effettuare richieste al modello, quindi non può stabilire sessioni di [Remote Control](https://code.claude.com/docs/it/remote-control.md) né recuperare i [connettori claude.ai](https://code.claude.com/docs/it/mcp.md#use-mcp-servers-from-claude-ai). I server MCP che configuri localmente continuano a funzionare.

322 322 

323[Bare mode](https://code.claude.com/docs/it/headless.md#start-faster-with-bare-mode) non legge `CLAUDE_CODE_OAUTH_TOKEN`. Se il Vostro script passa `--bare`, autenticatevi con `ANTHROPIC_API_KEY` o un `apiKeyHelper` invece.323[Bare mode](https://code.claude.com/docs/it/headless.md#start-faster-with-bare-mode) non legge `CLAUDE_CODE_OAUTH_TOKEN`. Se il Vostro script passa `--bare`, autenticatevi con `ANTHROPIC_API_KEY` o un `apiKeyHelper` invece.

Details

43 43 

44## Perché appare la notifica44## Perché appare la notifica

45 45 

46[La revisione del classificatore lato server](https://code.claude.com/docs/it/permission-modes.md#server-side-classifier-review) elenca quali sessioni richiedono al server i controlli del classificatore. I piani Pro, Max e Team non mostrano mai la notifica. Quando appare, le cause più comuni sono:46Con un piano Pro, Max, Ultra o Team, non vedi mai la notifica. Per sapere quali sessioni richiedono al server i controlli del classificatore, consulta [La revisione del classificatore lato server](https://code.claude.com/docs/it/permission-modes.md#server-side-classifier-review). Se vedi la notifica, verifica queste cause comuni:

47 47 

48* **Un gateway LLM o proxy è nel percorso**: uno che elimina o riscrive le intestazioni delle richieste, scarta i campi della richiesta che non riconosce o modifica le risposte. Il server quindi non riceve mai la richiesta di controlli, oppure Claude Code non riceve i risultati. Quando la configurazione o le risposte identificano il gateway, la notifica lo nomina.48* **Un gateway LLM o proxy è nel percorso**: uno che elimina o riscrive le intestazioni delle richieste, scarta i campi della richiesta che non riconosce o modifica le risposte. Il server quindi non riceve mai la richiesta di controlli, oppure Claude Code non riceve i risultati. Quando la configurazione o le risposte identificano il gateway, la notifica lo nomina.

49* **I controlli lato server non hanno ancora raggiunto la tua piattaforma, regione o credenziale**: se una piattaforma o una regione li esegue dipende dal rollout di quella piattaforma. Se vedi la notifica senza gateway o proxy nel percorso e continua ad apparire, questa è la causa probabile. Per confermare, contatta il supporto o l'amministratore della tua azienda, oppure segnalalo con `/feedback`.49* **I controlli lato server non hanno ancora raggiunto la tua piattaforma, regione o credenziale**: se una piattaforma o una regione li esegue dipende dal rollout di quella piattaforma. Se vedi la notifica senza gateway o proxy nel percorso e continua ad apparire, questa è la causa probabile. Per confermare, contatta il supporto o l'amministratore della tua azienda, oppure segnalalo con `/feedback`.

Details

161 161 

162> [!NOTE]162> [!NOTE]

163>163>

164> `/auto-mode-setup` è disponibile con i piani Pro, Max, Team ed Enterprise e con una chiave API di Claude Console. Con un piano Pro, Max o Team, ti serve v2.1.228 o successiva, oppure v2.1.233 o successiva su Windows nativo. Con un piano Enterprise o con una chiave API di Claude Console, ti serve v2.1.283 o successiva. Se il comando non è presente nella tua sessione, consulta [`/auto-mode-setup` restituisce "Unknown command"](#auto-mode-setup-returns-unknown-command).164> `/auto-mode-setup` è disponibile con i piani Pro, Max, Ultra, Team ed Enterprise e con una chiave API di Claude Console. Con un piano Pro, Max, Ultra o Team, ti serve v2.1.228 o successiva, oppure v2.1.233 o successiva su Windows nativo. Con un piano Enterprise o con una chiave API di Claude Console, ti serve v2.1.283 o successiva. Se il comando non è presente nella tua sessione, consulta [`/auto-mode-setup` restituisce "Unknown command"](#auto-mode-setup-returns-unknown-command).

165 165 

166### Cosa legge `/auto-mode-setup`166### Cosa legge `/auto-mode-setup`

167 167 

Details

489 489 

490Con una finestra da 1M di token sulla maggior parte dei modelli attuali e la compattazione vicino al limite, raramente esaurirai il contesto. Puoi comunque *pagare* per un contesto che non ti serve. Ogni richiesta invia l'intera conversazione, quindi una sessione che ha accumulato tre attività non correlate le rilegge tutte e tre a ogni turno della quarta. Questo è [scontato finché la cache è calda](https://code.claude.com/docs/it/costs.md#why-usage-climbs-in-a-long-session) e a prezzo pieno una volta scaduta.490Con una finestra da 1M di token sulla maggior parte dei modelli attuali e la compattazione vicino al limite, raramente esaurirai il contesto. Puoi comunque *pagare* per un contesto che non ti serve. Ogni richiesta invia l'intera conversazione, quindi una sessione che ha accumulato tre attività non correlate le rilegge tutte e tre a ogni turno della quarta. Questo è [scontato finché la cache è calda](https://code.claude.com/docs/it/costs.md#why-usage-climbs-in-a-long-session) e a prezzo pieno una volta scaduta.

491 491 

492[`/usage`](https://code.claude.com/docs/it/costs) è il primo posto in cui guardare. Su Pro, Max, Team ed Enterprise suddivide il tuo utilizzo per skill, subagent, plugin e server MCP. Segnala anche pattern come contesto lungo o frequenti cache miss quando uno di essi supera il 10% del tuo utilizzo. Da lì, le soluzioni abituali:492[`/usage`](https://code.claude.com/docs/it/costs) è il primo posto in cui guardare. Su Pro, Max, Ultra, Team ed Enterprise suddivide il tuo utilizzo per skill, subagent, plugin e server MCP. Segnala anche pattern come contesto lungo o frequenti cache miss quando uno di essi supera il 10% del tuo utilizzo. Da lì, le soluzioni abituali:

493 493 

494* `/clear` tra attività non correlate. Non costa nulla, e fa sì che l'attività successiva non continui a pagare per la cronologia della precedente. `/clear oauth-migration` assegna un nome alla sessione che stai lasciando, così puoi tornarci in seguito.494* `/clear` tra attività non correlate. Non costa nulla, e fa sì che l'attività successiva non continui a pagare per la cronologia della precedente. `/clear oauth-migration` assegna un nome alla sessione che stai lasciando, così puoi tornarci in seguito.

495* `/compact` con un focus, come `/compact keep the API changes and the test commands`. In una sessione lunga `/compact` è a sua volta una richiesta grande, dato che legge l'intera conversazione per riassumerla, e ancora di più una volta scaduta la cache.495* `/compact` con un focus, come `/compact keep the API changes and the test commands`. In una sessione lunga `/compact` è a sua volta una richiesta grande, dato che legge l'intera conversazione per riassumerla, e ancora di più una volta scaduta la cache.

channels.md +189 −189

Details

24 24 

25Ogni canale supportato è un plugin che richiede [Bun](https://bun.sh). Per una demo pratica del flusso del plugin prima di connettere una piattaforma reale, prova la [guida rapida fakechat](#quickstart).25Ogni canale supportato è un plugin che richiede [Bun](https://bun.sh). Per una demo pratica del flusso del plugin prima di connettere una piattaforma reale, prova la [guida rapida fakechat](#quickstart).

26 26 

27**Telegram**27> [tab] Telegram

28 

29Visualizza il [codice sorgente del plugin Telegram](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram) completo.

30 

31**1. Crea un bot Telegram**

32 

33Apri [BotFather](https://t.me/BotFather) in Telegram e invia `/newbot`. Dagli un nome visualizzato e un nome utente univoco che termina con `bot`. Copia il token che BotFather restituisce.

34 

35**2. Installa il plugin**

36 

37Avvia Claude Code eseguendo `claude` nel tuo terminale, quindi inserisci questo nel suo prompt:

38 

39```

40/plugin install telegram@claude-plugins-official

41```

42 

43Se l'installazione non riesce, abbina il messaggio che Claude Code segnala:

44 

45* `Marketplace "claude-plugins-official" not found`: aggiungi il marketplace con `/plugin marketplace add anthropics/claude-plugins-official`, quindi riprova l'installazione.

46* `Plugin "<name>" not found in marketplace "claude-plugins-official"`: la tua copia locale del catalogo del marketplace potrebbe non essere aggiornata. Aggiornala con `/plugin marketplace update claude-plugins-official`, quindi riprova l'installazione. Se il nuovo tentativo mostra lo stesso messaggio, vedi [Plugin non trovato nel marketplace](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

47 

48Quando l'installazione chiede un ambito di installazione, scegli l'opzione di ambito utente in modo che il plugin sia disponibile in tutti i tuoi progetti. Controlla il riepilogo dell'installazione: se segnala `Run /reload-plugins to apply.`, vedi [Applica le modifiche del plugin senza riavviare](https://code.claude.com/docs/it/plugins/cli-reference.md#reload-plugins) per rendere disponibile il comando di configurazione del plugin.

49 

50**3. Configura il tuo token**

51 

52Esegui il comando di configurazione con il token da BotFather:

53 

54```

55/telegram:configure <token>

56```

57 

58Questo lo salva in `~/.claude/channels/telegram/.env`. Puoi anche impostare `TELEGRAM_BOT_TOKEN` nel tuo ambiente shell prima di avviare Claude Code.

59 

60**4. Riavvia con i canali abilitati**

61 

62Esci da Claude Code e riavvia con il flag del canale. Questo avvia il plugin Telegram, che inizia a eseguire il polling dei messaggi dal tuo bot:

63 

64```bash theme={null}

65claude --channels plugin:telegram@claude-plugins-official

66```

67 

68**5. Accoppia il tuo account**

69 

70Apri Telegram e invia qualsiasi messaggio al tuo bot. Il bot risponde con un codice di accoppiamento.

71 

72> [!NOTE]

73>28>

74> Se il tuo bot non risponde, assicurati che Claude Code sia in esecuzione con `--channels` dal passaggio precedente. Il bot può rispondere solo mentre il canale è attivo.29> Visualizza il [codice sorgente del plugin Telegram](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram) completo.

75 

76Torna in Claude Code ed esegui:

77 

78```

79/telegram:access pair <code>

80```

81 

82Quindi blocca l'accesso in modo che solo il tuo account possa inviare messaggi:

83 

84```

85/telegram:access policy allowlist

86```

87 

88**Discord**

89 

90Visualizza il [codice sorgente del plugin Discord](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/discord) completo.

91 

92**1. Crea un bot Discord**

93 

94Vai al [Discord Developer Portal](https://discord.com/developers/applications), fai clic su **New Application** e assegnagli un nome. Nella sezione **Bot**, crea un nome utente, quindi fai clic su **Reset Token** e copia il token.

95 

96**2. Abilita Message Content Intent**

97 

98Nelle impostazioni del tuo bot, scorri fino a **Privileged Gateway Intents** e abilita **Message Content Intent**.

99 

100**3. Invita il bot al tuo server**

101 

102Vai a **OAuth2 > URL Generator**. Seleziona l'ambito `bot` e abilita questi permessi:

103 

104* View Channels

105* Send Messages

106* Send Messages in Threads

107* Read Message History

108* Attach Files

109* Add Reactions

110 

111Apri l'URL generato per aggiungere il bot al tuo server.

112 

113**4. Installa il plugin**

114 

115Avvia Claude Code eseguendo `claude` nel tuo terminale, quindi inserisci questo nel suo prompt:

116 

117```

118/plugin install discord@claude-plugins-official

119```

120 

121Se l'installazione non riesce, abbina il messaggio che Claude Code segnala:

122 

123* `Marketplace "claude-plugins-official" not found`: aggiungi il marketplace con `/plugin marketplace add anthropics/claude-plugins-official`, quindi riprova l'installazione.

124* `Plugin "<name>" not found in marketplace "claude-plugins-official"`: la tua copia locale del catalogo del marketplace potrebbe non essere aggiornata. Aggiornala con `/plugin marketplace update claude-plugins-official`, quindi riprova l'installazione. Se il nuovo tentativo mostra lo stesso messaggio, vedi [Plugin non trovato nel marketplace](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

125 

126Quando l'installazione chiede un ambito di installazione, scegli l'opzione di ambito utente in modo che il plugin sia disponibile in tutti i tuoi progetti. Controlla il riepilogo dell'installazione: se segnala `Run /reload-plugins to apply.`, vedi [Applica le modifiche del plugin senza riavviare](https://code.claude.com/docs/it/plugins/cli-reference.md#reload-plugins) per rendere disponibile il comando di configurazione del plugin.

127 

128**5. Configura il tuo token**

129 

130Esegui il comando di configurazione con il token del bot che hai copiato:

131 

132```

133/discord:configure <token>

134```

135 

136Questo lo salva in `~/.claude/channels/discord/.env`. Puoi anche impostare `DISCORD_BOT_TOKEN` nel tuo ambiente shell prima di avviare Claude Code.

137 

138**6. Riavvia con i canali abilitati**

139 

140Esci da Claude Code e riavvia con il flag del canale. Questo connette il plugin Discord in modo che il tuo bot possa ricevere e rispondere ai messaggi:

141 

142```bash theme={null}

143claude --channels plugin:discord@claude-plugins-official

144```

145 

146**7. Accoppia il tuo account**

147 

148Invia un messaggio privato al tuo bot su Discord. Il bot risponde con un codice di accoppiamento.

149 

150> [!NOTE]

151>30>

152> Se il tuo bot non risponde, assicurati che Claude Code sia in esecuzione con `--channels` dal passaggio precedente. Il bot può rispondere solo mentre il canale è attivo.31> **1. Crea un bot Telegram**

153 

154Torna in Claude Code ed esegui:

155 

156```

157/discord:access pair <code>

158```

159 

160Quindi blocca l'accesso in modo che solo il tuo account possa inviare messaggi:

161 

162```

163/discord:access policy allowlist

164```

165 

166**iMessage**

167 

168Visualizza il [codice sorgente del plugin iMessage](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/imessage) completo.

169 

170Il canale iMessage legge il tuo database Messaggi direttamente e invia risposte tramite AppleScript. Richiede macOS e non ha bisogno di token bot o servizio esterno.

171 

172**1. Concedi accesso completo al disco**

173 

174Il database Messaggi in `~/Library/Messages/chat.db` è protetto da macOS. La prima volta che il server lo legge, macOS richiede l'accesso: fai clic su **Allow**. Il prompt nomina qualsiasi app abbia avviato Bun, come Terminal, iTerm o il tuo IDE.

175 

176Se il prompt non appare o hai fatto clic su Don't Allow, concedi l'accesso manualmente in **System Settings > Privacy & Security > Full Disk Access** e aggiungi il tuo terminale. Senza questo, il server esce immediatamente con `authorization denied`.

177 

178**2. Installa il plugin**

179 

180Avvia Claude Code eseguendo `claude` nel tuo terminale, quindi inserisci questo nel suo prompt:

181 

182```

183/plugin install imessage@claude-plugins-official

184```

185 

186Se l'installazione non riesce, abbina il messaggio che Claude Code segnala:

187 

188* `Marketplace "claude-plugins-official" not found`: aggiungi il marketplace con `/plugin marketplace add anthropics/claude-plugins-official`, quindi riprova l'installazione.

189* `Plugin "<name>" not found in marketplace "claude-plugins-official"`: la tua copia locale del catalogo del marketplace potrebbe non essere aggiornata. Aggiornala con `/plugin marketplace update claude-plugins-official`, quindi riprova l'installazione. Se il nuovo tentativo mostra lo stesso messaggio, vedi [Plugin non trovato nel marketplace](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

190 

191Quando l'installazione chiede un ambito di installazione, scegli l'opzione di ambito utente in modo che il plugin sia disponibile in tutti i tuoi progetti.

192 

193Se il riepilogo dell'installazione segnala `Run /reload-plugins to apply.`, non è necessario agire qui, perché il riavvio nel passaggio successivo raccoglie il plugin.

194 

195**3. Riavvia con i canali abilitati**

196 

197Esci da Claude Code e riavvia con il flag del canale:

198 

199```bash theme={null}

200claude --channels plugin:imessage@claude-plugins-official

201```

202 

203**4. Invia un messaggio a te stesso**

204 

205Apri Messaggi su qualsiasi dispositivo connesso al tuo Apple ID e invia un messaggio a te stesso. Raggiunge Claude immediatamente: l'auto-chat bypassa il controllo di accesso senza configurazione.

206 

207> [!NOTE]

208>32>

209> La prima risposta che Claude invia attiva un prompt di automazione macOS che chiede se il tuo terminale può controllare Messaggi. Fai clic su **OK**.33> Apri [BotFather](https://t.me/BotFather) in Telegram e invia `/newbot`. Dagli un nome visualizzato e un nome utente univoco che termina con `bot`. Copia il token che BotFather restituisce.

210 34>

211**5. Consenti altri mittenti**35> **2. Installa il plugin**

212 36>

213Per impostazione predefinita, solo i tuoi messaggi passano. Per consentire a un altro contatto di raggiungere Claude, aggiungi il suo handle:37> Avvia Claude Code eseguendo `claude` nel tuo terminale, quindi inserisci questo nel suo prompt:

38>

39> ```

40> /plugin install telegram@claude-plugins-official

41> ```

42>

43> Se l'installazione non riesce, abbina il messaggio che Claude Code segnala:

44>

45> * `Marketplace "claude-plugins-official" not found`: aggiungi il marketplace con `/plugin marketplace add anthropics/claude-plugins-official`, quindi riprova l'installazione.

46> * `Plugin "<name>" not found in marketplace "claude-plugins-official"`: la tua copia locale del catalogo del marketplace potrebbe non essere aggiornata. Aggiornala con `/plugin marketplace update claude-plugins-official`, quindi riprova l'installazione. Se il nuovo tentativo mostra lo stesso messaggio, vedi [Plugin non trovato nel marketplace](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

47>

48> Quando l'installazione chiede un ambito di installazione, scegli l'opzione di ambito utente in modo che il plugin sia disponibile in tutti i tuoi progetti. Controlla il riepilogo dell'installazione: se segnala `Run /reload-plugins to apply.`, vedi [Applica le modifiche del plugin senza riavviare](https://code.claude.com/docs/it/plugins/cli-reference.md#reload-plugins) per rendere disponibile il comando di configurazione del plugin.

49>

50> **3. Configura il tuo token**

51>

52> Esegui il comando di configurazione con il token da BotFather:

53>

54> ```

55> /telegram:configure <token>

56> ```

57>

58> Questo lo salva in `~/.claude/channels/telegram/.env`. Puoi anche impostare `TELEGRAM_BOT_TOKEN` nel tuo ambiente shell prima di avviare Claude Code.

59>

60> **4. Riavvia con i canali abilitati**

61>

62> Esci da Claude Code e riavvia con il flag del canale. Questo avvia il plugin Telegram, che inizia a eseguire il polling dei messaggi dal tuo bot:

63>

64> ```bash theme={null}

65> claude --channels plugin:telegram@claude-plugins-official

66> ```

67>

68> **5. Accoppia il tuo account**

69>

70> Apri Telegram e invia qualsiasi messaggio al tuo bot. Il bot risponde con un codice di accoppiamento.

71>

72> > [!NOTE]

73> >

74> > Se il tuo bot non risponde, assicurati che Claude Code sia in esecuzione con `--channels` dal passaggio precedente. Il bot può rispondere solo mentre il canale è attivo.

75>

76> Torna in Claude Code ed esegui:

77>

78> ```

79> /telegram:access pair <code>

80> ```

81>

82> Quindi blocca l'accesso in modo che solo il tuo account possa inviare messaggi:

83>

84> ```

85> /telegram:access policy allowlist

86> ```

214 87 

215```88> [tab] Discord

216/imessage:access allow +1555123456789>

217```90> Visualizza il [codice sorgente del plugin Discord](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/discord) completo.

91>

92> **1. Crea un bot Discord**

93>

94> Vai al [Discord Developer Portal](https://discord.com/developers/applications), fai clic su **New Application** e assegnagli un nome. Nella sezione **Bot**, crea un nome utente, quindi fai clic su **Reset Token** e copia il token.

95>

96> **2. Abilita Message Content Intent**

97>

98> Nelle impostazioni del tuo bot, scorri fino a **Privileged Gateway Intents** e abilita **Message Content Intent**.

99>

100> **3. Invita il bot al tuo server**

101>

102> Vai a **OAuth2 > URL Generator**. Seleziona l'ambito `bot` e abilita questi permessi:

103>

104> * View Channels

105> * Send Messages

106> * Send Messages in Threads

107> * Read Message History

108> * Attach Files

109> * Add Reactions

110>

111> Apri l'URL generato per aggiungere il bot al tuo server.

112>

113> **4. Installa il plugin**

114>

115> Avvia Claude Code eseguendo `claude` nel tuo terminale, quindi inserisci questo nel suo prompt:

116>

117> ```

118> /plugin install discord@claude-plugins-official

119> ```

120>

121> Se l'installazione non riesce, abbina il messaggio che Claude Code segnala:

122>

123> * `Marketplace "claude-plugins-official" not found`: aggiungi il marketplace con `/plugin marketplace add anthropics/claude-plugins-official`, quindi riprova l'installazione.

124> * `Plugin "<name>" not found in marketplace "claude-plugins-official"`: la tua copia locale del catalogo del marketplace potrebbe non essere aggiornata. Aggiornala con `/plugin marketplace update claude-plugins-official`, quindi riprova l'installazione. Se il nuovo tentativo mostra lo stesso messaggio, vedi [Plugin non trovato nel marketplace](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

125>

126> Quando l'installazione chiede un ambito di installazione, scegli l'opzione di ambito utente in modo che il plugin sia disponibile in tutti i tuoi progetti. Controlla il riepilogo dell'installazione: se segnala `Run /reload-plugins to apply.`, vedi [Applica le modifiche del plugin senza riavviare](https://code.claude.com/docs/it/plugins/cli-reference.md#reload-plugins) per rendere disponibile il comando di configurazione del plugin.

127>

128> **5. Configura il tuo token**

129>

130> Esegui il comando di configurazione con il token del bot che hai copiato:

131>

132> ```

133> /discord:configure <token>

134> ```

135>

136> Questo lo salva in `~/.claude/channels/discord/.env`. Puoi anche impostare `DISCORD_BOT_TOKEN` nel tuo ambiente shell prima di avviare Claude Code.

137>

138> **6. Riavvia con i canali abilitati**

139>

140> Esci da Claude Code e riavvia con il flag del canale. Questo connette il plugin Discord in modo che il tuo bot possa ricevere e rispondere ai messaggi:

141>

142> ```bash theme={null}

143> claude --channels plugin:discord@claude-plugins-official

144> ```

145>

146> **7. Accoppia il tuo account**

147>

148> Invia un messaggio privato al tuo bot su Discord. Il bot risponde con un codice di accoppiamento.

149>

150> > [!NOTE]

151> >

152> > Se il tuo bot non risponde, assicurati che Claude Code sia in esecuzione con `--channels` dal passaggio precedente. Il bot può rispondere solo mentre il canale è attivo.

153>

154> Torna in Claude Code ed esegui:

155>

156> ```

157> /discord:access pair <code>

158> ```

159>

160> Quindi blocca l'accesso in modo che solo il tuo account possa inviare messaggi:

161>

162> ```

163> /discord:access policy allowlist

164> ```

218 165 

219Gli handle sono numeri di telefono nel formato `+country` o email Apple ID come `user@example.com`.166> [tab] iMessage

167>

168> Visualizza il [codice sorgente del plugin iMessage](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/imessage) completo.

169>

170> Il canale iMessage legge il tuo database Messaggi direttamente e invia risposte tramite AppleScript. Richiede macOS e non ha bisogno di token bot o servizio esterno.

171>

172> **1. Concedi accesso completo al disco**

173>

174> Il database Messaggi in `~/Library/Messages/chat.db` è protetto da macOS. La prima volta che il server lo legge, macOS richiede l'accesso: fai clic su **Allow**. Il prompt nomina qualsiasi app abbia avviato Bun, come Terminal, iTerm o il tuo IDE.

175>

176> Se il prompt non appare o hai fatto clic su Don't Allow, concedi l'accesso manualmente in **System Settings > Privacy & Security > Full Disk Access** e aggiungi il tuo terminale. Senza questo, il server esce immediatamente con `authorization denied`.

177>

178> **2. Installa il plugin**

179>

180> Avvia Claude Code eseguendo `claude` nel tuo terminale, quindi inserisci questo nel suo prompt:

181>

182> ```

183> /plugin install imessage@claude-plugins-official

184> ```

185>

186> Se l'installazione non riesce, abbina il messaggio che Claude Code segnala:

187>

188> * `Marketplace "claude-plugins-official" not found`: aggiungi il marketplace con `/plugin marketplace add anthropics/claude-plugins-official`, quindi riprova l'installazione.

189> * `Plugin "<name>" not found in marketplace "claude-plugins-official"`: la tua copia locale del catalogo del marketplace potrebbe non essere aggiornata. Aggiornala con `/plugin marketplace update claude-plugins-official`, quindi riprova l'installazione. Se il nuovo tentativo mostra lo stesso messaggio, vedi [Plugin non trovato nel marketplace](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-not-found-in-marketplace).

190>

191> Quando l'installazione chiede un ambito di installazione, scegli l'opzione di ambito utente in modo che il plugin sia disponibile in tutti i tuoi progetti.

192>

193> Se il riepilogo dell'installazione segnala `Run /reload-plugins to apply.`, non è necessario agire qui, perché il riavvio nel passaggio successivo raccoglie il plugin.

194>

195> **3. Riavvia con i canali abilitati**

196>

197> Esci da Claude Code e riavvia con il flag del canale:

198>

199> ```bash theme={null}

200> claude --channels plugin:imessage@claude-plugins-official

201> ```

202>

203> **4. Invia un messaggio a te stesso**

204>

205> Apri Messaggi su qualsiasi dispositivo connesso al tuo Apple ID e invia un messaggio a te stesso. Raggiunge Claude immediatamente: l'auto-chat bypassa il controllo di accesso senza configurazione.

206>

207> > [!NOTE]

208> >

209> > La prima risposta che Claude invia attiva un prompt di automazione macOS che chiede se il tuo terminale può controllare Messaggi. Fai clic su **OK**.

210>

211> **5. Consenti altri mittenti**

212>

213> Per impostazione predefinita, solo i tuoi messaggi passano. Per consentire a un altro contatto di raggiungere Claude, aggiungi il suo handle:

214>

215> ```

216> /imessage:access allow +15551234567

217> ```

218>

219> Gli handle sono numeri di telefono nel formato `+country` o email Apple ID come `user@example.com`.

220 220 

221## Guida rapida221## Guida rapida

222 222 

308| `channelsEnabled` | Interruttore principale. Deve essere `true` affinché qualsiasi canale consegni messaggi. Blocca tutti i canali incluso il flag di sviluppo quando disattivato. Vedi [Abilita i canali per la tua organizzazione](#enable-channels-for-your-organization). | claude.ai Team ed Enterprise: canali bloccati. Console: canali consentiti a meno che la tua organizzazione non distribuisca impostazioni gestite, nel qual caso i canali sono bloccati fino a quando questa chiave non è impostata |308| `channelsEnabled` | Interruttore principale. Deve essere `true` affinché qualsiasi canale consegni messaggi. Blocca tutti i canali incluso il flag di sviluppo quando disattivato. Vedi [Abilita i canali per la tua organizzazione](#enable-channels-for-your-organization). | claude.ai Team ed Enterprise: canali bloccati. Console: canali consentiti a meno che la tua organizzazione non distribuisca impostazioni gestite, nel qual caso i canali sono bloccati fino a quando questa chiave non è impostata |

309| `allowedChannelPlugins` | Quali plugin possono registrarsi una volta abilitati i canali. Sostituisce l'elenco mantenuto da Anthropic quando impostato. | Si applica l'elenco predefinito di Anthropic |309| `allowedChannelPlugins` | Quali plugin possono registrarsi una volta abilitati i canali. Sostituisce l'elenco mantenuto da Anthropic quando impostato. | Si applica l'elenco predefinito di Anthropic |

310 310 

311Gli utenti Pro e Max senza un'organizzazione saltano completamente questi controlli: i canali sono disponibili e gli utenti optano per sessione con `--channels`.311Gli utenti Pro, Max e Ultra senza un'organizzazione saltano completamente questi controlli: i canali sono disponibili e gli utenti optano per sessione con `--channels`.

312 312 

313### Abilita i canali per la tua organizzazione313### Abilita i canali per la tua organizzazione

314 314 

chrome.md +1 −1

Details

39* [Google Chrome](https://www.google.com/chrome/), [Microsoft Edge](https://www.microsoft.com/edge), o un altro browser basato su Chromium come Brave, Arc, Vivaldi, oppure Opera39* [Google Chrome](https://www.google.com/chrome/), [Microsoft Edge](https://www.microsoft.com/edge), o un altro browser basato su Chromium come Brave, Arc, Vivaldi, oppure Opera

40* Estensione [Claude in Chrome](https://chromewebstore.google.com/detail/claude/fcoeoabgfenejglbffodgkkbkcdhcgfn) versione 1.0.36 o superiore, disponibile nel Chrome Web Store40* Estensione [Claude in Chrome](https://chromewebstore.google.com/detail/claude/fcoeoabgfenejglbffodgkkbkcdhcgfn) versione 1.0.36 o superiore, disponibile nel Chrome Web Store

41* [Claude Code](https://code.claude.com/docs/it/quickstart.md#step-1-install-claude-code)41* [Claude Code](https://code.claude.com/docs/it/quickstart.md#step-1-install-claude-code)

42* Un piano Anthropic diretto (Pro, Max, Team, o Enterprise)42* Un piano Anthropic diretto (Pro, Max, Ultra, Team, o Enterprise)

43 43 

44Nelle organizzazioni Enterprise in cui è abilitato HIPAA, Claude in Chrome è disattivato per impostazione predefinita e un [Owner](https://code.claude.com/docs/it/server-managed-settings.md#access-control) può attivarlo in [**Organization settings > Claude in Chrome**](https://claude.ai/admin-settings/browser-extension). Il tuo Business Associate Agreement (BAA) con Anthropic non copre i dati inviati a siti di terze parti tramite Claude in Chrome. Consulta la [Implementation Guide](https://trust.anthropic.com/resources?s=l1wrssd9hsbi4gak0tp5a6\&name=%5Banthropic%5D-hipaa-ready-offering-implementation-guide) per un elenco degli Eligible Services.44Nelle organizzazioni Enterprise in cui è abilitato HIPAA, Claude in Chrome è disattivato per impostazione predefinita e un [Owner](https://code.claude.com/docs/it/server-managed-settings.md#access-control) può attivarlo in [**Organization settings > Claude in Chrome**](https://claude.ai/admin-settings/browser-extension). Il tuo Business Associate Agreement (BAA) con Anthropic non copre i dati inviati a siti di terze parti tramite Claude in Chrome. Consulta la [Implementation Guide](https://trust.anthropic.com/resources?s=l1wrssd9hsbi4gak0tp5a6\&name=%5Banthropic%5D-hipaa-ready-offering-implementation-guide) per un elenco degli Eligible Services.

45 45 

Details

325 325 

326**7. Eseguire il deploy**326**7. Eseguire il deploy**

327 327 

328**ECS Fargate**328> [tab] ECS Fargate

329 329>

330Crea il cluster e un gruppo di log per lo stderr del gateway, che contiene sia gli eventi di audit sia i log operativi. La conservazione richiede una chiamata separata, e senza di essa CloudWatch conserva i log per sempre; allinea i 90 giorni alla tua policy di conservazione dell'audit:330> Crea il cluster e un gruppo di log per lo stderr del gateway, che contiene sia gli eventi di audit sia i log operativi. La conservazione richiede una chiamata separata, e senza di essa CloudWatch conserva i log per sempre; allinea i 90 giorni alla tua policy di conservazione dell'audit:

331 331>

332```bash theme={null}332> ```bash theme={null}

333aws ecs create-cluster --cluster-name claude-gateway333> aws ecs create-cluster --cluster-name claude-gateway

334aws logs create-log-group --log-group-name /ecs/claude-gateway334> aws logs create-log-group --log-group-name /ecs/claude-gateway

335aws logs put-retention-policy --log-group-name /ecs/claude-gateway \335> aws logs put-retention-policy --log-group-name /ecs/claude-gateway \

336 --retention-in-days 90336> --retention-in-days 90

337```337> ```

338 338>

339Scrivi la definizione di attività. Il ruolo di attività ha il permesso per Bedrock e il ruolo di esecuzione inietta i segreti; usa gli ARN dei segreti del passaggio Secrets Manager:339> Scrivi la definizione di attività. Il ruolo di attività ha il permesso per Bedrock e il ruolo di esecuzione inietta i segreti; usa gli ARN dei segreti del passaggio Secrets Manager:

340 340>

341```json claude-gateway-task.json theme={null}341> ```json claude-gateway-task.json theme={null}

342{342> {

343 "family": "claude-gateway",343> "family": "claude-gateway",

344 "networkMode": "awsvpc",344> "networkMode": "awsvpc",

345 "requiresCompatibilities": ["FARGATE"],345> "requiresCompatibilities": ["FARGATE"],

346 "cpu": "1024",346> "cpu": "1024",

347 "memory": "2048",347> "memory": "2048",

348 "runtimePlatform": { "cpuArchitecture": "X86_64", "operatingSystemFamily": "LINUX" },348> "runtimePlatform": { "cpuArchitecture": "X86_64", "operatingSystemFamily": "LINUX" },

349 "executionRoleArn": "arn:aws:iam::<account-id>:role/claude-gateway-execution",349> "executionRoleArn": "arn:aws:iam::<account-id>:role/claude-gateway-execution",

350 "taskRoleArn": "arn:aws:iam::<account-id>:role/claude-gateway-task",350> "taskRoleArn": "arn:aws:iam::<account-id>:role/claude-gateway-task",

351 "containerDefinitions": [351> "containerDefinitions": [

352 {352> {

353 "name": "gateway",353> "name": "gateway",

354 "image": "<account-id>.dkr.ecr.<region>.amazonaws.com/claude-gateway:<version>",354> "image": "<account-id>.dkr.ecr.<region>.amazonaws.com/claude-gateway:<version>",

355 "portMappings": [{ "containerPort": 8080 }],355> "portMappings": [{ "containerPort": 8080 }],

356 "secrets": [356> "secrets": [

357 { "name": "GATEWAY_JWT_SECRET", "valueFrom": "<gateway-jwt-secret ARN>" },357> { "name": "GATEWAY_JWT_SECRET", "valueFrom": "<gateway-jwt-secret ARN>" },

358 { "name": "OIDC_CLIENT_SECRET", "valueFrom": "<gateway-oidc-client-secret ARN>" },358> { "name": "OIDC_CLIENT_SECRET", "valueFrom": "<gateway-oidc-client-secret ARN>" },

359 { "name": "GATEWAY_POSTGRES_URL", "valueFrom": "<gateway-postgres-url ARN>" }359> { "name": "GATEWAY_POSTGRES_URL", "valueFrom": "<gateway-postgres-url ARN>" }

360 ],360> ],

361 "logConfiguration": {361> "logConfiguration": {

362 "logDriver": "awslogs",362> "logDriver": "awslogs",

363 "options": {363> "options": {

364 "awslogs-group": "/ecs/claude-gateway",364> "awslogs-group": "/ecs/claude-gateway",

365 "awslogs-region": "<region>",365> "awslogs-region": "<region>",

366 "awslogs-stream-prefix": "gateway"366> "awslogs-stream-prefix": "gateway"

367 }367> }

368 }368> }

369 }369> }

370 ]370> ]

371}371> }

372```372> ```

373 373>

374Registrala:374> Registrala:

375 375>

376```bash theme={null}376> ```bash theme={null}

377aws ecs register-task-definition --cli-input-json file://claude-gateway-task.json377> aws ecs register-task-definition --cli-input-json file://claude-gateway-task.json

378```378> ```

379 379>

380Metti davanti un ALB interno con un gruppo di destinazione che verifica lo stato del gateway. `--ip-address-type ipv4` è importante: un ALB interno dual-stack pubblica record AAAA di intervallo pubblico, che il controllo della rete privata di `/login` rifiuta:380> Metti davanti un ALB interno con un gruppo di destinazione che verifica lo stato del gateway. `--ip-address-type ipv4` è importante: un ALB interno dual-stack pubblica record AAAA di intervallo pubblico, che il controllo della rete privata di `/login` rifiuta:

381 381>

382```bash theme={null}382> ```bash theme={null}

383ALB_ARN="$(aws elbv2 create-load-balancer --name claude-gateway \383> ALB_ARN="$(aws elbv2 create-load-balancer --name claude-gateway \

384 --scheme internal --type application --ip-address-type ipv4 \384> --scheme internal --type application --ip-address-type ipv4 \

385 --subnets $PRIVATE_SUBNETS --security-groups "$ALB_SG" \385> --subnets $PRIVATE_SUBNETS --security-groups "$ALB_SG" \

386 --query 'LoadBalancers[0].LoadBalancerArn' --output text)"386> --query 'LoadBalancers[0].LoadBalancerArn' --output text)"

387 387>

388TG_ARN="$(aws elbv2 create-target-group --name claude-gateway \388> TG_ARN="$(aws elbv2 create-target-group --name claude-gateway \

389 --protocol HTTP --port 8080 --vpc-id "$VPC_ID" --target-type ip \389> --protocol HTTP --port 8080 --vpc-id "$VPC_ID" --target-type ip \

390 --health-check-path /readyz \390> --health-check-path /readyz \

391 --query 'TargetGroups[0].TargetGroupArn' --output text)"391> --query 'TargetGroups[0].TargetGroupArn' --output text)"

392```392> ```

393 393>

394Aggiungi il listener HTTPS. `--ssl-policy` fissa un livello minimo di TLS moderno, poiché ometterlo fa ricadere sulla policy predefinita legacy `ELBSecurityPolicy-2016-08`, che accetta ancora TLS 1.0/1.1.394> Aggiungi il listener HTTPS. `--ssl-policy` fissa un livello minimo di TLS moderno, poiché ometterlo fa ricadere sulla policy predefinita legacy `ELBSecurityPolicy-2016-08`, che accetta ancora TLS 1.0/1.1.

395 395>

396Per impostazione predefinita, l'ALB chiude una connessione dopo 60 secondi senza dati. I ping di keepalive del gateway mantengono i flussi entro questo valore predefinito, quindi aumentare il timeout aggiunge margine rispetto alla cadenza dei ping; la riga di [Risoluzione dei problemi](#troubleshooting) sui flussi interrotti descrive il meccanismo e i gateway meno recenti. I comandi seguenti aggiungono il listener e aumentano il timeout:396> Per impostazione predefinita, l'ALB chiude una connessione dopo 60 secondi senza dati. I ping di keepalive del gateway mantengono i flussi entro questo valore predefinito, quindi aumentare il timeout aggiunge margine rispetto alla cadenza dei ping; la riga di [Risoluzione dei problemi](#troubleshooting) sui flussi interrotti descrive il meccanismo e i gateway meno recenti. I comandi seguenti aggiungono il listener e aumentano il timeout:

397 397>

398```bash theme={null}398> ```bash theme={null}

399aws elbv2 create-listener --load-balancer-arn "$ALB_ARN" \399> aws elbv2 create-listener --load-balancer-arn "$ALB_ARN" \

400 --protocol HTTPS --port 443 \400> --protocol HTTPS --port 443 \

401 --ssl-policy ELBSecurityPolicy-TLS13-1-2-2021-06 \401> --ssl-policy ELBSecurityPolicy-TLS13-1-2-2021-06 \

402 --certificates CertificateArn=<your-acm-certificate-arn> \402> --certificates CertificateArn=<your-acm-certificate-arn> \

403 --default-actions Type=forward,TargetGroupArn="$TG_ARN"403> --default-actions Type=forward,TargetGroupArn="$TG_ARN"

404 404>

405aws elbv2 modify-load-balancer-attributes --load-balancer-arn "$ALB_ARN" \405> aws elbv2 modify-load-balancer-attributes --load-balancer-arn "$ALB_ARN" \

406 --attributes Key=idle_timeout.timeout_seconds,Value=3600406> --attributes Key=idle_timeout.timeout_seconds,Value=3600

407```407> ```

408 408>

409Crea il servizio. Il circuit breaker del deploy riporta all'ultimo stato stabile un deploy le cui attività continuano a fallire, a causa di un'immagine difettosa o di una configurazione che non si avvia, anziché rilanciare all'infinito attività che falliscono:409> Crea il servizio. Il circuit breaker del deploy riporta all'ultimo stato stabile un deploy le cui attività continuano a fallire, a causa di un'immagine difettosa o di una configurazione che non si avvia, anziché rilanciare all'infinito attività che falliscono:

410 410>

411```bash theme={null}411> ```bash theme={null}

412aws ecs create-service --cluster claude-gateway --service-name claude-gateway \412> aws ecs create-service --cluster claude-gateway --service-name claude-gateway \

413 --task-definition claude-gateway --desired-count 1 --launch-type FARGATE \413> --task-definition claude-gateway --desired-count 1 --launch-type FARGATE \

414 --deployment-configuration "deploymentCircuitBreaker={enable=true,rollback=true}" \414> --deployment-configuration "deploymentCircuitBreaker={enable=true,rollback=true}" \

415 --health-check-grace-period-seconds 60 \415> --health-check-grace-period-seconds 60 \

416 --network-configuration "awsvpcConfiguration={subnets=[$(echo $PRIVATE_SUBNETS | tr ' ' ',')],securityGroups=[$GW_SG],assignPublicIp=DISABLED}" \416> --network-configuration "awsvpcConfiguration={subnets=[$(echo $PRIVATE_SUBNETS | tr ' ' ',')],securityGroups=[$GW_SG],assignPublicIp=DISABLED}" \

417 --load-balancers "targetGroupArn=$TG_ARN,containerName=gateway,containerPort=8080"417> --load-balancers "targetGroupArn=$TG_ARN,containerName=gateway,containerPort=8080"

418```418> ```

419 419>

420Il periodo di tolleranza di 60 secondi dà a un'attività avviata a freddo il tempo di scaricare l'immagine, connettersi allo store e rispondere al primo controllo di stato prima che ECS inizi a contare i fallimenti a carico del deploy.420> Il periodo di tolleranza di 60 secondi dà a un'attività avviata a freddo il tempo di scaricare l'immagine, connettersi allo store e rispondere al primo controllo di stato prima che ECS inizi a contare i fallimenti a carico del deploy.

421 421>

422Il controllo di stato del gruppo di destinazione su `GET /readyz` verifica che lo store sia raggiungibile, quindi un'attività che non riesce a raggiungere Postgres non entra mai in rotazione. Per far sì che le attività continuino a superare il controllo durante una breve interruzione del database, come un failover RDS, imposta `store.readiness_grace_seconds` come descritto in [Comportamento in caso di interruzione](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#outage-behavior), che tratta anche l'alternativa `/healthz`.422> Il controllo di stato del gruppo di destinazione su `GET /readyz` verifica che lo store sia raggiungibile, quindi un'attività che non riesce a raggiungere Postgres non entra mai in rotazione. Per far sì che le attività continuino a superare il controllo durante una breve interruzione del database, come un failover RDS, imposta `store.readiness_grace_seconds` come descritto in [Comportamento in caso di interruzione](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#outage-behavior), che tratta anche l'alternativa `/healthz`.

423 423>

424Le attività vengono eseguite in subnet private senza IP pubblico, quindi tutto il traffico in uscita (verso Bedrock, il tuo IdP, Secrets Manager, ECR e CloudWatch Logs) passa attraverso il gateway NAT. Per tenere il traffico Bedrock fuori dal percorso pubblico, crea un endpoint VPC di interfaccia `bedrock-runtime` e punta il `base_url` dell'upstream a esso, come mostrato nel [riferimento upstream Bedrock](https://code.claude.com/docs/it/claude-apps-gateway-config.md#amazon-bedrock); l'IdP ha comunque bisogno di uscita verso Internet.424> Le attività vengono eseguite in subnet private senza IP pubblico, quindi tutto il traffico in uscita (verso Bedrock, il tuo IdP, Secrets Manager, ECR e CloudWatch Logs) passa attraverso il gateway NAT. Per tenere il traffico Bedrock fuori dal percorso pubblico, crea un endpoint VPC di interfaccia `bedrock-runtime` e punta il `base_url` dell'upstream a esso, come mostrato nel [riferimento upstream Bedrock](https://code.claude.com/docs/it/claude-apps-gateway-config.md#amazon-bedrock); l'IdP ha comunque bisogno di uscita verso Internet.

425 425>

426Per finire, fornisci agli sviluppatori un nome host risolvibile privatamente: in una zona ospitata privata di Route 53, crea un alias dal nome DNS interno del gateway all'ALB e imposta `listen.public_url` su quel nome host. Il nome `*.elb.amazonaws.com` dell'ALB si risolve in indirizzi privati su un ALB interno, ma non può usare il tuo certificato ACM, quindi usa un nome tuo.426> Per finire, fornisci agli sviluppatori un nome host risolvibile privatamente: in una zona ospitata privata di Route 53, crea un alias dal nome DNS interno del gateway all'ALB e imposta `listen.public_url` su quel nome host. Il nome `*.elb.amazonaws.com` dell'ALB si risolve in indirizzi privati su un ALB interno, ma non può usare il tuo certificato ACM, quindi usa un nome tuo.

427 427>

428Aggiorna l'URI di reindirizzamento autorizzato del client OAuth a `<public_url>/oauth/callback` prima del primo accesso. Dopo aver modificato `public_url`, esegui di nuovo la build e il push dell'immagine con un nuovo tag, registra una nuova revisione della definizione di attività ed esegui di nuovo il deploy. Su ECS l'impostazione si trova nel `gateway.yaml` incorporato nell'immagine, e il gateway costruisce la propria origine pubblica solo da quell'impostazione, ignorando `X-Forwarded-Host` e `X-Forwarded-Proto`. `X-Forwarded-For` viene considerato per gli IP dei client solo quando `listen.trusted_proxies` è impostato.428> Aggiorna l'URI di reindirizzamento autorizzato del client OAuth a `<public_url>/oauth/callback` prima del primo accesso. Dopo aver modificato `public_url`, esegui di nuovo la build e il push dell'immagine con un nuovo tag, registra una nuova revisione della definizione di attività ed esegui di nuovo il deploy. Su ECS l'impostazione si trova nel `gateway.yaml` incorporato nell'immagine, e il gateway costruisce la propria origine pubblica solo da quell'impostazione, ignorando `X-Forwarded-Host` e `X-Forwarded-Proto`. `X-Forwarded-For` viene considerato per gli IP dei client solo quando `listen.trusted_proxies` è impostato.

429 

430**EKS**

431 

432Questo percorso richiede `kubectl` ed `eksctl` installati localmente e un cluster EKS esistente con un provider OIDC IAM e AWS Load Balancer Controller installato. Il cluster deve trovarsi su `$VPC_ID` affinché i pod possano raggiungere l'endpoint privato RDS, e il gruppo di sicurezza `claude-gateway-db` deve ammettere il gruppo di sicurezza dei pod o dei nodi del cluster al posto di `$GW_SG`.

433 

434Su EKS il gateway ottiene le credenziali Bedrock tramite IRSA anziché tramite i ruoli ECS. La policy di attendibilità `ecs-tasks.amazonaws.com` del passaggio IAM non si applica qui; IRSA ha bisogno di un ruolo la cui policy di attendibilità sia federata sul provider OIDC del cluster, limitata a `system:serviceaccount:claude-gateway:gateway`. `eksctl create iamserviceaccount` crea quel ruolo, collega le policy e annota l'account di servizio Kubernetes con l'ARN del ruolo in un unico passaggio. Trasforma i due documenti di policy del passaggio IAM in policy gestite che il comando può collegare:

435 

436```bash theme={null}

437BEDROCK_POLICY_ARN="$(aws iam create-policy --policy-name claude-gateway-bedrock-invoke \

438 --policy-document file://bedrock-invoke.json --query Policy.Arn --output text)"

439SECRETS_POLICY_ARN="$(aws iam create-policy --policy-name claude-gateway-secrets-read \

440 --policy-document file://secrets-read.json --query Policy.Arn --output text)"

441 

442kubectl create namespace claude-gateway

443eksctl create iamserviceaccount --cluster <your-cluster> --region "$AWS_REGION" \

444 --namespace claude-gateway --name gateway --role-name claude-gateway \

445 --attach-policy-arn "$BEDROCK_POLICY_ARN" \

446 --attach-policy-arn "$SECRETS_POLICY_ARN" \

447 --approve

448```

449 

450La policy dei segreti è necessaria solo quando i pod leggono direttamente Secrets Manager, come fa il provider AWS del driver CSI Secrets Store usando l'account di servizio del pod che esegue il montaggio; rimuovila se crei i Kubernetes Secrets in un altro modo. Il provider ha bisogno di entrambe le azioni della policy: chiama `DescribeSecret` quando riconcilia i segreti ruotati, quindi una concessione limitata a `GetSecretValue` esegue il montaggio al primo deploy ma smette di recepire le rotazioni.

451 

452Esegui il deploy del gateway come Deployment standard più un Service e un Ingress, come descritto in [Deploy su Kubernetes](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#kubernetes), con:

453 

454* `serviceAccountName: gateway`

455* `gateway.yaml` montato da una ConfigMap e i segreti montati in `/secrets`

456* il readiness probe puntato a `GET /readyz`

457 

458Per il front end, un Ingress gestito da AWS Load Balancer Controller esegue il provisioning dell'ALB interno. Annotalo con:

459 

460* `alb.ingress.kubernetes.io/scheme: internal` e `alb.ingress.kubernetes.io/target-type: ip`

461* `alb.ingress.kubernetes.io/ip-address-type: ipv4`, in modo che non vengano pubblicati record AAAA di intervallo pubblico che il [controllo della rete privata](https://code.claude.com/docs/it/claude-apps-gateway#prerequisites) di `/login` rifiuterebbe

462* `alb.ingress.kubernetes.io/inbound-cidrs: <your-corporate-cidr>`, in modo che il gruppo di sicurezza frontend gestito dal controller ammetta solo la tua rete aziendale al posto del suo valore predefinito `0.0.0.0/0`

463* `alb.ingress.kubernetes.io/certificate-arn` con il certificato ACM

464* `alb.ingress.kubernetes.io/ssl-policy: ELBSecurityPolicy-TLS13-1-2-2021-06`, in modo che il listener non ricada sulla policy predefinita legacy che accetta TLS 1.0 e 1.1

465* `alb.ingress.kubernetes.io/load-balancer-attributes: idle_timeout.timeout_seconds=3600`, un margine rispetto al keepalive di streaming del gateway; consulta [Risoluzione dei problemi](#troubleshooting)

466 429 

467Con IRSA, l'AWS SDK legge un token proiettato dell'account di servizio e lo scambia con AWS STS, quindi il pod non ha mai bisogno del servizio di metadati dell'istanza EC2; una NetworkPolicy in uscita può bloccare `169.254.169.254` per i pod del gateway. Il problema del limite di hop dei nodi descritto in [Risoluzione dei problemi](#troubleshooting) più avanti riguarda solo i cluster che non usano IRSA e si affidano ai ruoli delle istanze dei nodi.430> [tab] EKS

431>

432> Questo percorso richiede `kubectl` ed `eksctl` installati localmente e un cluster EKS esistente con un provider OIDC IAM e AWS Load Balancer Controller installato. Il cluster deve trovarsi su `$VPC_ID` affinché i pod possano raggiungere l'endpoint privato RDS, e il gruppo di sicurezza `claude-gateway-db` deve ammettere il gruppo di sicurezza dei pod o dei nodi del cluster al posto di `$GW_SG`.

433>

434> Su EKS il gateway ottiene le credenziali Bedrock tramite IRSA anziché tramite i ruoli ECS. La policy di attendibilità `ecs-tasks.amazonaws.com` del passaggio IAM non si applica qui; IRSA ha bisogno di un ruolo la cui policy di attendibilità sia federata sul provider OIDC del cluster, limitata a `system:serviceaccount:claude-gateway:gateway`. `eksctl create iamserviceaccount` crea quel ruolo, collega le policy e annota l'account di servizio Kubernetes con l'ARN del ruolo in un unico passaggio. Trasforma i due documenti di policy del passaggio IAM in policy gestite che il comando può collegare:

435>

436> ```bash theme={null}

437> BEDROCK_POLICY_ARN="$(aws iam create-policy --policy-name claude-gateway-bedrock-invoke \

438> --policy-document file://bedrock-invoke.json --query Policy.Arn --output text)"

439> SECRETS_POLICY_ARN="$(aws iam create-policy --policy-name claude-gateway-secrets-read \

440> --policy-document file://secrets-read.json --query Policy.Arn --output text)"

441>

442> kubectl create namespace claude-gateway

443> eksctl create iamserviceaccount --cluster <your-cluster> --region "$AWS_REGION" \

444> --namespace claude-gateway --name gateway --role-name claude-gateway \

445> --attach-policy-arn "$BEDROCK_POLICY_ARN" \

446> --attach-policy-arn "$SECRETS_POLICY_ARN" \

447> --approve

448> ```

449>

450> La policy dei segreti è necessaria solo quando i pod leggono direttamente Secrets Manager, come fa il provider AWS del driver CSI Secrets Store usando l'account di servizio del pod che esegue il montaggio; rimuovila se crei i Kubernetes Secrets in un altro modo. Il provider ha bisogno di entrambe le azioni della policy: chiama `DescribeSecret` quando riconcilia i segreti ruotati, quindi una concessione limitata a `GetSecretValue` esegue il montaggio al primo deploy ma smette di recepire le rotazioni.

451>

452> Esegui il deploy del gateway come Deployment standard più un Service e un Ingress, come descritto in [Deploy su Kubernetes](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#kubernetes), con:

453>

454> * `serviceAccountName: gateway`

455> * `gateway.yaml` montato da una ConfigMap e i segreti montati in `/secrets`

456> * il readiness probe puntato a `GET /readyz`

457>

458> Per il front end, un Ingress gestito da AWS Load Balancer Controller esegue il provisioning dell'ALB interno. Annotalo con:

459>

460> * `alb.ingress.kubernetes.io/scheme: internal` e `alb.ingress.kubernetes.io/target-type: ip`

461> * `alb.ingress.kubernetes.io/ip-address-type: ipv4`, in modo che non vengano pubblicati record AAAA di intervallo pubblico che il [controllo della rete privata](https://code.claude.com/docs/it/claude-apps-gateway#prerequisites) di `/login` rifiuterebbe

462> * `alb.ingress.kubernetes.io/inbound-cidrs: <your-corporate-cidr>`, in modo che il gruppo di sicurezza frontend gestito dal controller ammetta solo la tua rete aziendale al posto del suo valore predefinito `0.0.0.0/0`

463> * `alb.ingress.kubernetes.io/certificate-arn` con il certificato ACM

464> * `alb.ingress.kubernetes.io/ssl-policy: ELBSecurityPolicy-TLS13-1-2-2021-06`, in modo che il listener non ricada sulla policy predefinita legacy che accetta TLS 1.0 e 1.1

465> * `alb.ingress.kubernetes.io/load-balancer-attributes: idle_timeout.timeout_seconds=3600`, un margine rispetto al keepalive di streaming del gateway; consulta [Risoluzione dei problemi](#troubleshooting)

466>

467> Con IRSA, l'AWS SDK legge un token proiettato dell'account di servizio e lo scambia con AWS STS, quindi il pod non ha mai bisogno del servizio di metadati dell'istanza EC2; una NetworkPolicy in uscita può bloccare `169.254.169.254` per i pod del gateway. Il problema del limite di hop dei nodi descritto in [Risoluzione dei problemi](#troubleshooting) più avanti riguarda solo i cluster che non usano IRSA e si affidano ai ruoli delle istanze dei nodi.

468 468 

469**8. Distribuire l'URL del gateway ai computer degli sviluppatori**469**8. Distribuire l'URL del gateway ai computer degli sviluppatori**

470 470 

Details

203 203 

204**7. Distribuire**204**7. Distribuire**

205 205 

206**Cloud Run**206> [tab] Cloud Run

207 

208Il comando seguente distribuisce per la produzione dietro un load balancer interno.

209 

210```bash theme={null}

211gcloud run deploy claude-gateway \

212 --image="${REGION}-docker.pkg.dev/${PROJECT_ID}/claude-gateway/gateway:<version>" \

213 --region="$REGION" \

214 --service-account="claude-gateway@${PROJECT_ID}.iam.gserviceaccount.com" \

215 --min-instances=1 \

216 --max-instances=8 \

217 --timeout=3600 \

218 --ingress=internal \

219 --network="$VPC" --subnet=cc-gateway-subnet --vpc-egress=private-ranges-only \

220 --set-secrets=/etc/claude/gateway.yaml=gateway-config:latest,GATEWAY_JWT_SECRET=gateway-jwt-secret:latest,OIDC_CLIENT_SECRET=gateway-oidc-client-secret:latest,GATEWAY_POSTGRES_URL=gateway-postgres-url:latest \

221 --no-invoker-iam-check

222```

223 

224L'uscita VPC diretta, tramite `--network`, `--subnet` e `--vpc-egress=private-ranges-only`, consente al servizio di raggiungere direttamente l'IP privato di Cloud SQL. L'uscita pubblica verso gli endpoint di Agent Platform di Google Cloud e `accounts.google.com` va direttamente a Internet anziché attraverso il VPC, quindi non è necessario Cloud NAT.

225 

226> [!NOTE]

227>207>

228> Ogni istanza mantiene fino a [`store.max_connections`](https://code.claude.com/docs/it/claude-apps-gateway-config#store) connessioni Postgres, cinque per impostazione predefinita. Usa [Dimensionare il pool di connessioni](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#size-the-connection-pool) per verificare `--max-instances=8` rispetto alle connessioni che il tuo database ha ancora disponibili per il gateway, e includi le istanze aggiuntive avviate da un aggiornamento in sequenza.208> Il comando seguente distribuisce per la produzione dietro un load balancer interno.

229 209>

230Il controllo IAM dell'invoker deve essere aperto o disabilitato. Il gateway esegue il proprio OIDC e i suoi client non portano alcun token GCP, quindi il controllo dell'invoker di Cloud Run deve ammettere richieste non autenticate. Il gateway autentica la richiesta una volta che raggiunge il contenitore con OIDC, con `allowed_email_domains` che controlla quali domini possono accedere.210> ```bash theme={null}

231 211> gcloud run deploy claude-gateway \

232Due flag ammettono richieste non autenticate:212> --image="${REGION}-docker.pkg.dev/${PROJECT_ID}/claude-gateway/gateway:<version>" \

233 213> --region="$REGION" \

234* `--no-invoker-iam-check`: disabilita il controllo senza alcun binding `allUsers` da gestire e funziona con Domain Restricted Sharing214> --service-account="claude-gateway@${PROJECT_ID}.iam.gserviceaccount.com" \

235* `--allow-unauthenticated`: concede al ruolo `run.invoker` `allUsers`; utilizzatelo se la vostra organizzazione non consente `--no-invoker-iam-check`215> --min-instances=1 \

236 216> --max-instances=8 \

237La restrizione dell'ingresso tramite `--ingress` è un livello separato e indipendente dal controllo dell'invoker; mantenetelo impostato per limitare il servizio alla vostra rete aziendale.217> --timeout=3600 \

238 218> --ingress=internal \

239Per impostazione predefinita, l'URL `*.run.app` di Cloud Run si risolve in un indirizzo pubblico, che il controllo [rete privata](https://code.claude.com/docs/it/claude-apps-gateway#prerequisites) di `/login` rifiuta. Due topologie forniscono agli sviluppatori un nome host risolvibile privatamente e Cloud Run non ne esegue il provisioning per voi:219> --network="$VPC" --subnet=cc-gateway-subnet --vpc-egress=private-ranges-only \

240 220> --set-secrets=/etc/claude/gateway.yaml=gateway-config:latest,GATEWAY_JWT_SECRET=gateway-jwt-secret:latest,OIDC_CLIENT_SECRET=gateway-oidc-client-secret:latest,GATEWAY_POSTGRES_URL=gateway-postgres-url:latest \

241* **Internal Application Load Balancer**, la topologia che il `gateway.yaml` di questa pagina presuppone: esegui il provisioning di un Internal Application Load Balancer davanti al servizio con un nome DNS interno e un certificato, e imposta `listen.public_url` su quel nome host. L'impostazione di ingresso `internal` ammette già il traffico dagli Internal Application Load Balancer; `internal-and-cloud-load-balancing` ammette inoltre gli External Application Load Balancer, i cui indirizzi pubblici vengono rifiutati dal controllo di rete privata di `/login`, quindi nessuna topologia di questa pagina ne ha bisogno.221> --no-invoker-iam-check

242* **Ingresso solo interno senza load balancer**: mantieni il comando di deploy così com'è e lascia `listen.public_url` come URL `*.run.app`, l'impostazione predefinita negli [asset di riferimento](#terraform-reference) di seguito. Affinché `*.run.app` si risolva privatamente, il tuo team di rete deve già gestire un endpoint Private Service Connect per le API di Google, una zona privata Cloud DNS che risolve `*.run.app` verso di esso e il routing on-premises verso quell'endpoint.222> ```

243 223>

244La [guida alla rete privata di Google per Cloud Run](https://cloud.google.com/run/docs/securing/private-networking) copre l'infrastruttura di cui entrambe le opzioni hanno bisogno. Verificate l'accesso una volta che il gateway è in servizio su un nome host privato; fino ad allora, confermate che il contenitore si è avviato dai suoi log in Cloud Run.224> L'uscita VPC diretta, tramite `--network`, `--subnet` e `--vpc-egress=private-ranges-only`, consente al servizio di raggiungere direttamente l'IP privato di Cloud SQL. L'uscita pubblica verso gli endpoint di Agent Platform di Google Cloud e `accounts.google.com` va direttamente a Internet anziché attraverso il VPC, quindi non è necessario Cloud NAT.

245 225>

246Aggiornate l'URI di reindirizzamento autorizzato del client OAuth a `<public_url>/oauth/callback` prima del primo accesso. Ridistribuite dopo aver modificato `public_url`, perché il gateway costruisce la sua origine pubblica solo da quell'impostazione e ignora `X-Forwarded-Host` e `X-Forwarded-Proto`. `X-Forwarded-For` viene onorato per gli IP client solo quando `listen.trusted_proxies` è impostato.226> > [!NOTE]

247 227> >

248**GKE**228> > Ogni istanza mantiene fino a [`store.max_connections`](https://code.claude.com/docs/it/claude-apps-gateway-config#store) connessioni Postgres, cinque per impostazione predefinita. Usa [Dimensionare il pool di connessioni](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#size-the-connection-pool) per verificare `--max-instances=8` rispetto alle connessioni che il tuo database ha ancora disponibili per il gateway, e includi le istanze aggiuntive avviate da un aggiornamento in sequenza.

249 229>

250Il cluster deve essere sul `$VPC` creato nel passaggio Cloud SQL in modo che i pod possano raggiungere l'IP privato del database; il peering VPC da solo non funziona, perché l'IP privato di Cloud SQL è esso stesso una rete peered e il peering non è transitivo. Per creare un nuovo cluster su quel VPC, passate `--network="$VPC" --subnetwork=cc-gateway-subnet` a `gcloud container clusters create`.230> Il controllo IAM dell'invoker deve essere aperto o disabilitato. Il gateway esegue il proprio OIDC e i suoi client non portano alcun token GCP, quindi il controllo dell'invoker di Cloud Run deve ammettere richieste non autenticate. Il gateway autentica la richiesta una volta che raggiunge il contenitore con OIDC, con `allowed_email_domains` che controlla quali domini possono accedere.

251 231>

252Abilitate Workload Identity sul cluster e sui suoi pool di nodi, quindi associate l'account di servizio Google all'account di servizio Kubernetes in modo che i pod ereditino le sue credenziali:232> Due flag ammettono richieste non autenticate:

253 233>

254```bash theme={null}234> * `--no-invoker-iam-check`: disabilita il controllo senza alcun binding `allUsers` da gestire e funziona con Domain Restricted Sharing

255gcloud container clusters update <cluster> --region="$REGION" \235> * `--allow-unauthenticated`: concede al ruolo `run.invoker` `allUsers`; utilizzatelo se la vostra organizzazione non consente `--no-invoker-iam-check`

256 --workload-pool="${PROJECT_ID}.svc.id.goog"236>

257# On a Standard cluster, existing node pools also need GKE_METADATA;237> La restrizione dell'ingresso tramite `--ingress` è un livello separato e indipendente dal controllo dell'invoker; mantenetelo impostato per limitare il servizio alla vostra rete aziendale.

258# Autopilot enables this by default.238>

259gcloud container node-pools update <pool> --cluster=<cluster> \239> Per impostazione predefinita, l'URL `*.run.app` di Cloud Run si risolve in un indirizzo pubblico, che il controllo [rete privata](https://code.claude.com/docs/it/claude-apps-gateway#prerequisites) di `/login` rifiuta. Due topologie forniscono agli sviluppatori un nome host risolvibile privatamente e Cloud Run non ne esegue il provisioning per voi:

260 --region="$REGION" --workload-metadata=GKE_METADATA240>

261 241> * **Internal Application Load Balancer**, la topologia che il `gateway.yaml` di questa pagina presuppone: esegui il provisioning di un Internal Application Load Balancer davanti al servizio con un nome DNS interno e un certificato, e imposta `listen.public_url` su quel nome host. L'impostazione di ingresso `internal` ammette già il traffico dagli Internal Application Load Balancer; `internal-and-cloud-load-balancing` ammette inoltre gli External Application Load Balancer, i cui indirizzi pubblici vengono rifiutati dal controllo di rete privata di `/login`, quindi nessuna topologia di questa pagina ne ha bisogno.

262kubectl create namespace claude-gateway242> * **Ingresso solo interno senza load balancer**: mantieni il comando di deploy così com'è e lascia `listen.public_url` come URL `*.run.app`, l'impostazione predefinita negli [asset di riferimento](#terraform-reference) di seguito. Affinché `*.run.app` si risolva privatamente, il tuo team di rete deve già gestire un endpoint Private Service Connect per le API di Google, una zona privata Cloud DNS che risolve `*.run.app` verso di esso e il routing on-premises verso quell'endpoint.

263kubectl create serviceaccount gateway -n claude-gateway243>

264 244> La [guida alla rete privata di Google per Cloud Run](https://cloud.google.com/run/docs/securing/private-networking) copre l'infrastruttura di cui entrambe le opzioni hanno bisogno. Verificate l'accesso una volta che il gateway è in servizio su un nome host privato; fino ad allora, confermate che il contenitore si è avviato dai suoi log in Cloud Run.

265gcloud iam service-accounts add-iam-policy-binding \245>

266 "claude-gateway@${PROJECT_ID}.iam.gserviceaccount.com" \246> Aggiornate l'URI di reindirizzamento autorizzato del client OAuth a `<public_url>/oauth/callback` prima del primo accesso. Ridistribuite dopo aver modificato `public_url`, perché il gateway costruisce la sua origine pubblica solo da quell'impostazione e ignora `X-Forwarded-Host` e `X-Forwarded-Proto`. `X-Forwarded-For` viene onorato per gli IP client solo quando `listen.trusted_proxies` è impostato.

267 --role roles/iam.workloadIdentityUser \

268 --member "serviceAccount:${PROJECT_ID}.svc.id.goog[claude-gateway/gateway]"

269 

270kubectl annotate serviceaccount gateway -n claude-gateway \

271 iam.gke.io/gcp-service-account="claude-gateway@${PROJECT_ID}.iam.gserviceaccount.com"

272```

273 

274Distribuite il gateway come Deployment standard più un Service e un Ingress interno, classe `gce-internal`, come descritto in [Distribuzione Kubernetes](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#kubernetes), con:

275 

276* `serviceAccountName: gateway`

277* il driver CSI di Secret Manager che monta i segreti in `/secrets`

278* il probe di prontezza puntato a `GET /readyz`

279 

280Allegate un BackendConfig con un `timeoutSec` elevato al Service del gateway: il servizio backend del load balancer dietro GKE Ingress ha un timeout predefinito di 30 secondi, che interrompe le risposte di streaming lunghe.

281 

282Non applicate una NetworkPolicy di uscita che blocca `169.254.169.254` su un cluster Workload Identity; il pod deve raggiungere il server di metadati per le credenziali. La [guardia SSRF](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#threat-model-summary) integrata del gateway è la difesa lì.

283 247 

284Il gateway registra un avviso di avvio che l'endpoint dei metadati è raggiungibile e suggerisce di applicare una NetworkPolicy di uscita. Con Workload Identity quell'avviso è previsto, perché il pod ha bisogno dell'endpoint.248> [tab] GKE

249>

250> Il cluster deve essere sul `$VPC` creato nel passaggio Cloud SQL in modo che i pod possano raggiungere l'IP privato del database; il peering VPC da solo non funziona, perché l'IP privato di Cloud SQL è esso stesso una rete peered e il peering non è transitivo. Per creare un nuovo cluster su quel VPC, passate `--network="$VPC" --subnetwork=cc-gateway-subnet` a `gcloud container clusters create`.

251>

252> Abilitate Workload Identity sul cluster e sui suoi pool di nodi, quindi associate l'account di servizio Google all'account di servizio Kubernetes in modo che i pod ereditino le sue credenziali:

253>

254> ```bash theme={null}

255> gcloud container clusters update <cluster> --region="$REGION" \

256> --workload-pool="${PROJECT_ID}.svc.id.goog"

257> # On a Standard cluster, existing node pools also need GKE_METADATA;

258> # Autopilot enables this by default.

259> gcloud container node-pools update <pool> --cluster=<cluster> \

260> --region="$REGION" --workload-metadata=GKE_METADATA

261>

262> kubectl create namespace claude-gateway

263> kubectl create serviceaccount gateway -n claude-gateway

264>

265> gcloud iam service-accounts add-iam-policy-binding \

266> "claude-gateway@${PROJECT_ID}.iam.gserviceaccount.com" \

267> --role roles/iam.workloadIdentityUser \

268> --member "serviceAccount:${PROJECT_ID}.svc.id.goog[claude-gateway/gateway]"

269>

270> kubectl annotate serviceaccount gateway -n claude-gateway \

271> iam.gke.io/gcp-service-account="claude-gateway@${PROJECT_ID}.iam.gserviceaccount.com"

272> ```

273>

274> Distribuite il gateway come Deployment standard più un Service e un Ingress interno, classe `gce-internal`, come descritto in [Distribuzione Kubernetes](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#kubernetes), con:

275>

276> * `serviceAccountName: gateway`

277> * il driver CSI di Secret Manager che monta i segreti in `/secrets`

278> * il probe di prontezza puntato a `GET /readyz`

279>

280> Allegate un BackendConfig con un `timeoutSec` elevato al Service del gateway: il servizio backend del load balancer dietro GKE Ingress ha un timeout predefinito di 30 secondi, che interrompe le risposte di streaming lunghe.

281>

282> Non applicate una NetworkPolicy di uscita che blocca `169.254.169.254` su un cluster Workload Identity; il pod deve raggiungere il server di metadati per le credenziali. La [guardia SSRF](https://code.claude.com/docs/it/claude-apps-gateway-deploy.md#threat-model-summary) integrata del gateway è la difesa lì.

283>

284> Il gateway registra un avviso di avvio che l'endpoint dei metadati è raggiungibile e suggerisce di applicare una NetworkPolicy di uscita. Con Workload Identity quell'avviso è previsto, perché il pod ha bisogno dell'endpoint.

285 285 

286**8. Inviare l'URL del gateway alle macchine degli sviluppatori**286**8. Inviare l'URL del gateway alle macchine degli sviluppatori**

287 287 

Details

8 8 

9> [!NOTE]9> [!NOTE]

10>10>

11> Le sessioni cloud sono disponibili sui piani Pro, Max e Team, e per gli utenti Enterprise con posti premium o posti Chat + Claude Code. Se il tuo accesso è regolato da [ruoli personalizzati](https://support.claude.com/en/articles/13930452), hai bisogno anche di un ruolo con il permesso per le sessioni cloud per avviare sessioni sull'infrastruttura di Anthropic dal browser, dalle app o dal terminale. Chiedi a un Owner di aggiungerlo a uno dei tuoi ruoli in [**Organization settings > Roles**](https://claude.ai/admin-settings/roles).11> Le sessioni cloud sono disponibili sui piani Pro, Max, Ultra e Team, e per gli utenti Enterprise con posti premium o posti Chat + Claude Code. Se il tuo accesso è regolato da [ruoli personalizzati](https://support.claude.com/en/articles/13930452), hai bisogno anche di un ruolo con il permesso per le sessioni cloud per avviare sessioni sull'infrastruttura di Anthropic dal browser, dalle app o dal terminale. Chiedi a un Owner di aggiungerlo a uno dei tuoi ruoli in [**Organization settings > Roles**](https://claude.ai/admin-settings/roles).

12 12 

13Una sessione cloud è una sessione Claude Code che viene eseguita su infrastruttura cloud invece che sulla tua macchina. Per impostazione predefinita viene eseguita su infrastruttura gestita da Anthropic, oppure sull'[ambiente self-hosted](https://code.claude.com/docs/it/self-hosted-environments) della tua organizzazione quando instradato lì. La sessione continua a essere eseguita dopo che chiudi il tuo laptop, e puoi controllarla o dirigerla da qualsiasi dispositivo. Viene conteggiata nei limiti di utilizzo del tuo piano insieme al resto del tuo utilizzo di Claude e Claude Code, e non c'è alcun addebito separato per la VM cloud.13Una sessione cloud è una sessione Claude Code che viene eseguita su infrastruttura cloud invece che sulla tua macchina. Per impostazione predefinita viene eseguita su infrastruttura gestita da Anthropic, oppure sull'[ambiente self-hosted](https://code.claude.com/docs/it/self-hosted-environments) della tua organizzazione quando instradato lì. La sessione continua a essere eseguita dopo che chiudi il tuo laptop, e puoi controllarla o dirigerla da qualsiasi dispositivo. Viene conteggiata nei limiti di utilizzo del tuo piano insieme al resto del tuo utilizzo di Claude e Claude Code, e non c'è alcun addebito separato per la VM cloud.

14 14 

342* **Il tuo nome**: il nome visualizzato del tuo account è visibile a tutti i destinatari con accesso342* **Il tuo nome**: il nome visualizzato del tuo account è visibile a tutti i destinatari con accesso

343* **Sessioni Slack**: le sessioni di [Claude in Slack](https://code.claude.com/docs/it/slack.md) vengono condivise automaticamente con visibilità Team343* **Sessioni Slack**: le sessioni di [Claude in Slack](https://code.claude.com/docs/it/slack.md) vengono condivise automaticamente con visibilità Team

344 344 

345#### Condividere da un account Max o Pro345#### Condividere da un account Max, Ultra o Pro

346 

347Per gli account Max e Pro, la condivisione funziona come segue:

348 346 

349* **Opzioni di visibilità**: **Private** e **Public**. La visibilità Public rende la sessione visibile a qualsiasi utente che abbia effettuato l'accesso a claude.ai347* **Opzioni di visibilità**: **Private** e **Public**. La visibilità Public rende la sessione visibile a qualsiasi utente che abbia effettuato l'accesso a claude.ai

350* **Accesso al repository**: la verifica non è abilitata per impostazione predefinita348* **Accesso al repository**: la verifica non è abilitata per impostazione predefinita

Details

8 8 

9> [!NOTE]9> [!NOTE]

10>10>

11> Projects è in beta pubblica sui piani Pro e Max e sta venendo implementato gradualmente. L'implementazione è iniziata con gli account che hanno utilizzato [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e non hanno progetti esistenti in claude.ai chat o Cowork. Projects non è ancora disponibile sui piani Team o Enterprise.11> Projects è in beta pubblica sui piani Pro, Max e Ultra e sta venendo implementato gradualmente. L'implementazione è iniziata con gli account che hanno utilizzato [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e non hanno progetti esistenti in claude.ai chat o Cowork. Projects non è ancora disponibile sui piani Team o Enterprise.

12>12>

13> Se **Projects** non appare nella barra laterale su [claude.ai/code](https://claude.ai/code) o nella scheda Code dell'[app desktop](https://code.claude.com/docs/it/desktop.md), controlla sotto **More**. Se non c'è nemmeno lì, l'implementazione non ha ancora raggiunto il tuo account. Puoi [unirti alla lista d'attesa](https://claude.com/form/projects) e consultare [Esegui agenti in parallelo](https://code.claude.com/docs/it/agents.md) per sapere cosa puoi utilizzare nel frattempo.13> Se **Projects** non appare nella barra laterale su [claude.ai/code](https://claude.ai/code) o nella scheda Code dell'[app desktop](https://code.claude.com/docs/it/desktop.md), controlla sotto **More**. Se non c'è nemmeno lì, l'implementazione non ha ancora raggiunto il tuo account. Puoi [unirti alla lista d'attesa](https://claude.com/form/projects) e consultare [Esegui agenti in parallelo](https://code.claude.com/docs/it/agents.md) per sapere cosa puoi utilizzare nel frattempo.

14 14 

78 78 

79Prima di creare un project, controlla il tuo piano, la tua configurazione GitHub e cosa il lavoro ha bisogno di raggiungere:79Prima di creare un project, controlla il tuo piano, la tua configurazione GitHub e cosa il lavoro ha bisogno di raggiungere:

80 80 

81* **Piano**: sei su Pro o Max e **Projects** appare nella tua barra laterale, direttamente o sotto **More**. Seleziona **Projects** e verifica che offra **New project** o **Get started**.81* **Piano**: sei su Pro, Max o Ultra e **Projects** appare nella tua barra laterale, direttamente o sotto **More**. Seleziona **Projects** e verifica che offra **New project** o **Get started**.

82* **GitHub, se il project lavorerà su codice**: il tuo codice è su github.com piuttosto che su GitHub Enterprise Server, GitLab o Bitbucket, il tuo account GitHub connesso ha accesso push, e l'app Claude GitHub è installata su di esso. Se hai connesso GitHub con [`/web-setup`](https://code.claude.com/docs/it/web-quickstart#connect-from-your-terminal), quel token lascia che le tue altre sessioni cloud raggiungano un repository ma non è sufficiente per i thread del project, che hanno bisogno dell'app Claude GitHub. [Configura l'accesso a GitHub](#set-up-github-access) ha i passaggi.82* **GitHub, se il project lavorerà su codice**: il tuo codice è su github.com piuttosto che su GitHub Enterprise Server, GitLab o Bitbucket, il tuo account GitHub connesso ha accesso push, e l'app Claude GitHub è installata su di esso. Se hai connesso GitHub con [`/web-setup`](https://code.claude.com/docs/it/web-quickstart#connect-from-your-terminal), quel token lascia che le tue altre sessioni cloud raggiungano un repository ma non è sufficiente per i thread del project, che hanno bisogno dell'app Claude GitHub. [Configura l'accesso a GitHub](#set-up-github-access) ha i passaggi.

83* **Accesso alla rete, segreti e strumenti**: per i thread cloud, questi provengono dal [cloud environment](#choose-an-environment-for-threads) del project. L'ambiente predefinito raggiunge già [registri di pacchetti comuni](https://code.claude.com/docs/it/cloud-environments.md#default-allowed-domains), quindi controlla questo solo se il lavoro ha bisogno di altri domini, un segreto o uno strumento che non è preinstallato. Se il lavoro ha bisogno di un server MCP, controlla che appaia come connesso nei tuoi [connettori di claude.ai](https://claude.ai/customize/connectors).83* **Accesso alla rete, segreti e strumenti**: per i thread cloud, questi provengono dal [cloud environment](#choose-an-environment-for-threads) del project. L'ambiente predefinito raggiunge già [registri di pacchetti comuni](https://code.claude.com/docs/it/cloud-environments.md#default-allowed-domains), quindi controlla questo solo se il lavoro ha bisogno di altri domini, un segreto o uno strumento che non è preinstallato. Se il lavoro ha bisogno di un server MCP, controlla che appaia come connesso nei tuoi [connettori di claude.ai](https://claude.ai/customize/connectors).

84 84 

421 421 

422Apri la scheda **Usage** in **Project settings** per vedere l'utilizzo di token per thread e per modello, e quanto è andato alla conversazione del project. Per ridurlo:422Apri la scheda **Usage** in **Project settings** per vedere l'utilizzo di token per thread e per modello, e quanto è andato alla conversazione del project. Per ridurlo:

423 423 

424* Un follow-up instradato a un thread che è stato inattivo più a lungo della [durata della cache](https://code.claude.com/docs/it/prompt-caching.md#cache-lifetime), un'ora su Pro e Max entro i limiti del tuo piano, rilegge l'intera conversazione di quel thread prima di fare qualsiasi cosa. Per il nuovo lavoro, chiedere a Claude di avviare un thread fresco può usare meno che far rivivere uno grande e vecchio.424* Su Pro, Max e Ultra entro i limiti del tuo piano, la [durata della cache](https://code.claude.com/docs/it/prompt-caching.md#cache-lifetime) è di un'ora. Un thread che è stato inattivo più a lungo di così rilegge l'intera conversazione prima di fare qualsiasi cosa quando gli arriva un follow-up. Per il nuovo lavoro, chiedi a Claude di avviare un thread nuovo, che può usare meno che far rivivere uno grande e vecchio.

425* Per il lavoro che non ha bisogno del modello più grande, [scegli un modello più piccolo o un livello di sforzo inferiore](#choose-models-and-let-claude-manage-context) per i thread, la conversazione o entrambi.425* Per il lavoro che non ha bisogno del modello più grande, [scegli un modello più piccolo o un livello di sforzo inferiore](#choose-models-and-let-claude-manage-context) per i thread, la conversazione o entrambi.

426* Chiedi a Claude nella conversazione del project di eseguire meno thread contemporaneamente, o di rispondere da solo a piccole domande invece di avviare un thread.426* Chiedi a Claude nella conversazione del project di eseguire meno thread contemporaneamente, o di rispondere da solo a piccole domande invece di avviare un thread.

427 427 

429 429 

430Diverse funzioni Claude Code permettono a più di una sessione di funzionare contemporaneamente, quindi eseguire il lavoro in parallelo non è di per sé quello per cui è un project. In un project, Claude avvia e traccia le sessioni invece di te, e ognuno inizia dalle stesse istruzioni. Ecco come ogni funzione vicina si connette a un project:430Diverse funzioni Claude Code permettono a più di una sessione di funzionare contemporaneamente, quindi eseguire il lavoro in parallelo non è di per sé quello per cui è un project. In un project, Claude avvia e traccia le sessioni invece di te, e ognuno inizia dalle stesse istruzioni. Ecco come ogni funzione vicina si connette a un project:

431 431 

432* **Claude Tag**: [Claude Tag](https://claude.com/docs/claude-tag/overview) è Claude nei canali Slack del tuo team, su piani Team e Enterprise. Chiunque in un canale può dargli lavoro, tutti nel canale lo vedono e lo guidano, e usa connessioni che un admin ha configurato per quel canale. Un project è solo tuo: sei l'unico che gli invia lavoro o vede i suoi thread, usa il tuo accesso GitHub e i tuoi connectors, ed è su Pro e Max. [Come Claude Tag differisce da Cowork e Claude Code](https://claude.com/docs/claude-tag/concepts/how-it-works#how-claude-tag-differs-from-cowork-and-claude-code) ha il confronto fianco a fianco.432* **Claude Tag**: [Claude Tag](https://claude.com/docs/claude-tag/overview) è Claude nei canali Slack del tuo team, su piani Team e Enterprise. Chiunque in un canale può dargli lavoro, tutti nel canale lo vedono e lo guidano, e usa connessioni che un amministratore ha configurato per quel canale.

433 

434 I project sono disponibili su Pro, Max e Ultra. Un project è solo tuo: sei l'unico che gli invia lavoro o vede i suoi thread, e usa il tuo accesso GitHub e i tuoi connettori. [Come Claude Tag differisce da Cowork e Claude Code](https://claude.com/docs/claude-tag/concepts/how-it-works#how-claude-tag-differs-from-cowork-and-claude-code) ha il confronto fianco a fianco.

433* **Sessioni cloud**: ogni thread è una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) a meno che non chiedi a Claude di eseguirla sulla tua macchina. In entrambi i casi, Claude la avvia e la traccia invece di te. Puoi anche portare in un project il lavoro di una sessione cloud che hai avviato da solo: scegli [**Continue in project**](#start-from-an-existing-cloud-session) nel menu della barra laterale di quella sessione.435* **Sessioni cloud**: ogni thread è una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) a meno che non chiedi a Claude di eseguirla sulla tua macchina. In entrambi i casi, Claude la avvia e la traccia invece di te. Puoi anche portare in un project il lavoro di una sessione cloud che hai avviato da solo: scegli [**Continue in project**](#start-from-an-existing-cloud-session) nel menu della barra laterale di quella sessione.

434* **Attività pianificate**: quando chiedi lavoro pianificato in un project, Claude crea un'[attività pianificata cloud](https://code.claude.com/docs/it/routines.md) che viene eseguita come thread in quel project e appare nella sua scheda **Scheduled tasks**. Le attività pianificate che crei al di fuori di un project continuano a funzionare da sole.436* **Attività pianificate**: quando chiedi lavoro pianificato in un project, Claude crea un'[attività pianificata cloud](https://code.claude.com/docs/it/routines.md) che viene eseguita come thread in quel project e appare nella sua scheda **Scheduled tasks**. Le attività pianificate che crei al di fuori di un project continuano a funzionare da sole.

435* **Remote Control**: [Remote Control](https://code.claude.com/docs/it/remote-control.md) connette claude.ai a una sessione Claude Code in esecuzione sulla tua macchina. Quando chiedi a Claude in un project di eseguire un thread sul tuo computer, il project [usa Remote Control per farlo](#run-a-thread-on-your-own-computer).437* **Remote Control**: [Remote Control](https://code.claude.com/docs/it/remote-control.md) connette claude.ai a una sessione Claude Code in esecuzione sulla tua macchina. Quando chiedi a Claude in un project di eseguire un thread sul tuo computer, il project [usa Remote Control per farlo](#run-a-thread-on-your-own-computer).

Details

8 8 

9> [!NOTE]9> [!NOTE]

10>10>

11> Gli ambienti cloud si applicano alle [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md), che sono disponibili sui piani Pro, Max e Team, e per gli utenti Enterprise con [posti premium o posti Chat + Claude Code](https://support.claude.com/en/articles/11845131-use-claude-code-with-your-team-or-enterprise-plan).11> Gli ambienti cloud si applicano alle [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md), che sono disponibili sui piani Pro, Max, Ultra e Team, e per gli utenti Enterprise con [posti premium o posti Chat + Claude Code](https://support.claude.com/en/articles/11845131-use-claude-code-with-your-team-or-enterprise-plan).

12 12 

13Ogni [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) viene eseguita in un ambiente cloud. Puoi configurare un ambiente per consentire o negare l'[accesso di rete](#access-levels), [impostare variabili d'ambiente](#set-environment-variables) per la sessione, memorizzare [segreti di rete](#add-network-secrets) che le sessioni utilizzano senza vederli ed eseguire uno [script di configurazione](#setup-scripts) prima che Claude inizi a lavorare.13Ogni [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) viene eseguita in un ambiente cloud. Puoi configurare un ambiente per consentire o negare l'[accesso di rete](#access-levels), [impostare variabili d'ambiente](#set-environment-variables) per la sessione, memorizzare [segreti di rete](#add-network-secrets) che le sessioni utilizzano senza vederli ed eseguire uno [script di configurazione](#setup-scripts) prima che Claude inizi a lavorare.

14 14 

32Se non avete ancora un ambiente, l'onboarding configura l'ambiente **Default** per voi. Come dipende da dove eseguite l'onboarding:32Se non avete ancora un ambiente, l'onboarding configura l'ambiente **Default** per voi. Come dipende da dove eseguite l'onboarding:

33 33 

34* **Flussi CLI come `/web-setup`**: creano **Default** per voi34* **Flussi CLI come `/web-setup`**: creano **Default** per voi

35* **Onboarding web su Pro e Max**: crea **Default** per voi35* **Onboarding web su Pro, Max e Ultra**: ottieni **Default** automaticamente

36* **Onboarding web su Team ed Enterprise**: mostra un modulo **Create your first cloud environment** a meno che un Owner non abbia attivato [Quick setup](https://code.claude.com/docs/it/claude-code-on-the-web.md#quick-setup-for-team-and-enterprise); mantieni i valori predefiniti del modulo e fai clic su **Create & finish** per ottenere lo stesso ambiente **Default**36* **Onboarding web su Team ed Enterprise**: mostra un modulo **Create your first cloud environment** a meno che un Owner non abbia attivato [Quick setup](https://code.claude.com/docs/it/claude-code-on-the-web.md#quick-setup-for-team-and-enterprise); mantieni i valori predefiniti del modulo e fai clic su **Create & finish** per ottenere lo stesso ambiente **Default**

37 37 

38**Default** non ha alcuna configurazione propria:38**Default** non ha alcuna configurazione propria:

93 93 

94Un segreto di rete è una chiave API o un token che memorizzi in un ambiente cloud in modo che Claude possa chiamare quell'API da qualsiasi sessione nell'ambiente senza vedere la chiave. Il proxy dell'agente di Anthropic aggiunge la chiave alle richieste per gli host che elenchi, dopo che ogni richiesta esce dalla VM della sessione, quindi la chiave stessa resta fuori dalla VM.94Un segreto di rete è una chiave API o un token che memorizzi in un ambiente cloud in modo che Claude possa chiamare quell'API da qualsiasi sessione nell'ambiente senza vedere la chiave. Il proxy dell'agente di Anthropic aggiunge la chiave alle richieste per gli host che elenchi, dopo che ogni richiesta esce dalla VM della sessione, quindi la chiave stessa resta fuori dalla VM.

95 95 

96I segreti di rete sono disponibili sui piani Pro, Max, Team ed Enterprise. Per verificare se puoi aggiungerne uno tu stesso, consulta [Requisiti](#requirements).96I segreti di rete sono disponibili sui piani Pro, Max, Ultra, Team ed Enterprise. Per verificare se puoi aggiungerne uno tu stesso, consulta [Requisiti](#requirements).

97 97 

98#### Requisiti98#### Requisiti

99 99 

552 552 

553Con accesso di rete **Trusted**, le sessioni possono raggiungere i seguenti domini per impostazione predefinita. I domini contrassegnati con `*` indicano la corrispondenza del sottodominio con carattere jolly, quindi `*.gcr.io` consente qualsiasi sottodominio di `gcr.io`.553Con accesso di rete **Trusted**, le sessioni possono raggiungere i seguenti domini per impostazione predefinita. I domini contrassegnati con `*` indicano la corrispondenza del sottodominio con carattere jolly, quindi `*.gcr.io` consente qualsiasi sottodominio di `gcr.io`.

554 554 

555> **Servizi Anthropic**555> [accordion] Servizi Anthropic

556>556>

557> * api.anthropic.com557> * api.anthropic.com

558> * docs.claude.com558> * docs.claude.com

564> * anthropic.com564> * anthropic.com

565> * [www.anthropic.com](http://www.anthropic.com)565> * [www.anthropic.com](http://www.anthropic.com)

566 566 

567> **Controllo versione**567> [accordion] Controllo versione

568>568>

569> * github.com569> * github.com

570> * [www.github.com](http://www.github.com)570> * [www.github.com](http://www.github.com)

585> * [www.bitbucket.org](http://www.bitbucket.org)585> * [www.bitbucket.org](http://www.bitbucket.org)

586> * api.bitbucket.org586> * api.bitbucket.org

587 587 

588> **Registri di contenitori**588> [accordion] Registri di contenitori

589>589>

590> * registry-1.docker.io590> * registry-1.docker.io

591> * auth.docker.io591> * auth.docker.io

602> * \*.data.mcr.microsoft.com602> * \*.data.mcr.microsoft.com

603> * public.ecr.aws603> * public.ecr.aws

604 604 

605> **Piattaforme cloud**605> [accordion] Piattaforme cloud

606>606>

607> * cloud.google.com607> * cloud.google.com

608> * accounts.google.com608> * accounts.google.com

633> * yum.oracle.com633> * yum.oracle.com

634> * \*.r2.cloudflarestorage.com634> * \*.r2.cloudflarestorage.com

635 635 

636> **Gestori di pacchetti JavaScript e Node**636> [accordion] Gestori di pacchetti JavaScript e Node

637>637>

638> * registry.npmjs.org638> * registry.npmjs.org

639> * [www.npmjs.com](http://www.npmjs.com)639> * [www.npmjs.com](http://www.npmjs.com)

645> * jsr.io645> * jsr.io

646> * npm.jsr.io646> * npm.jsr.io

647 647 

648> **Gestori di pacchetti Python**648> [accordion] Gestori di pacchetti Python

649>649>

650> * pypi.org650> * pypi.org

651> * [www.pypi.org](http://www.pypi.org)651> * [www.pypi.org](http://www.pypi.org)

656> * pypa.io656> * pypa.io

657> * [www.pypa.io](http://www.pypa.io)657> * [www.pypa.io](http://www.pypa.io)

658 658 

659> **Gestori di pacchetti Ruby**659> [accordion] Gestori di pacchetti Ruby

660>660>

661> * rubygems.org661> * rubygems.org

662> * [www.rubygems.org](http://www.rubygems.org)662> * [www.rubygems.org](http://www.rubygems.org)

671> * rvm.io671> * rvm.io

672> * get.rvm.io672> * get.rvm.io

673 673 

674> **Gestori di pacchetti Rust**674> [accordion] Gestori di pacchetti Rust

675>675>

676> * crates.io676> * crates.io

677> * [www.crates.io](http://www.crates.io)677> * [www.crates.io](http://www.crates.io)

681> * static.rust-lang.org681> * static.rust-lang.org

682> * [www.rust-lang.org](http://www.rust-lang.org)682> * [www.rust-lang.org](http://www.rust-lang.org)

683 683 

684> **Gestori di pacchetti Go**684> [accordion] Gestori di pacchetti Go

685>685>

686> * proxy.golang.org686> * proxy.golang.org

687> * sum.golang.org687> * sum.golang.org

691> * goproxy.io691> * goproxy.io

692> * pkg.go.dev692> * pkg.go.dev

693 693 

694> **Gestori di pacchetti JVM**694> [accordion] Gestori di pacchetti JVM

695>695>

696> * maven.org696> * maven.org

697> * repo.maven.org697> * repo.maven.org

710> * spring.io710> * spring.io

711> * repo.spring.io711> * repo.spring.io

712 712 

713> **Altri gestori di pacchetti**713> [accordion] Altri gestori di pacchetti

714>714>

715> * packagist.org (PHP Composer)715> * packagist.org (PHP Composer)

716> * [www.packagist.org](http://www.packagist.org)716> * [www.packagist.org](http://www.packagist.org)

736> * swift.org736> * swift.org

737> * [www.swift.org](http://www.swift.org)737> * [www.swift.org](http://www.swift.org)

738 738 

739> **Distribuzioni Linux**739> [accordion] Distribuzioni Linux

740>740>

741> * archive.ubuntu.com741> * archive.ubuntu.com

742> * security.ubuntu.com742> * security.ubuntu.com

748> * [www.launchpad.net](http://www.launchpad.net)748> * [www.launchpad.net](http://www.launchpad.net)

749> * \*.nixos.org749> * \*.nixos.org

750 750 

751> **Strumenti di sviluppo e piattaforme**751> [accordion] Strumenti di sviluppo e piattaforme

752>752>

753> * dl.k8s.io (Kubernetes)753> * dl.k8s.io (Kubernetes)

754> * pkgs.k8s.io754> * pkgs.k8s.io

780> * pkg.stainless.com780> * pkg.stainless.com

781> * binaries.prisma.sh781> * binaries.prisma.sh

782 782 

783> **Servizi cloud e monitoraggio**783> [accordion] Servizi cloud e monitoraggio

784>784>

785> * http-intake.logs.datadoghq.com785> * http-intake.logs.datadoghq.com

786> * \*.datadoghq.com786> * \*.datadoghq.com

787> * \*.datadoghq.eu787> * \*.datadoghq.eu

788> * api.honeycomb.io788> * api.honeycomb.io

789 789 

790> **Distribuzione di contenuti e mirror**790> [accordion] Distribuzione di contenuti e mirror

791>791>

792> * sourceforge.net792> * sourceforge.net

793> * \*.sourceforge.net793> * \*.sourceforge.net

796> * fonts.googleapis.com796> * fonts.googleapis.com

797> * fonts.gstatic.com797> * fonts.gstatic.com

798 798 

799> **Schema e configurazione**799> [accordion] Schema e configurazione

800>800>

801> * json-schema.org801> * json-schema.org

802> * [www.json-schema.org](http://www.json-schema.org)802> * [www.json-schema.org](http://www.json-schema.org)

803> * json.schemastore.org803> * json.schemastore.org

804> * [www.schemastore.org](http://www.schemastore.org)804> * [www.schemastore.org](http://www.schemastore.org)

805 805 

806> **Model Context Protocol**806> [accordion] Model Context Protocol

807>807>

808> * \*.modelcontextprotocol.io808> * \*.modelcontextprotocol.io

809 809 

code-review.md +5 −5

Details

32 32 

33Scegli la pagina in base a ciò che devi fare:33Scegli la pagina in base a ciò che devi fare:

34 34 

35> **[Configura Code Review](https://code.claude.com/docs/it/code-review-setup.md)**35> [card] [Configura Code Review](https://code.claude.com/docs/it/code-review-setup.md)

36>36>

37> Controlla i requisiti, installa l'app GitHub di Claude e scegli i repository, un livello di revisione e quando vengono eseguite le revisioni37> Controlla i requisiti, installa l'app GitHub di Claude e scegli i repository, un livello di revisione e quando vengono eseguite le revisioni

38 38 

39> **[Personalizza Code Review](https://code.claude.com/docs/it/code-review-customize.md)**39> [card] [Personalizza Code Review](https://code.claude.com/docs/it/code-review-customize.md)

40>40>

41> Regola cosa viene segnalato con i file `REVIEW.md` e `CLAUDE.md` nel tuo repository41> Regola cosa viene segnalato con i file `REVIEW.md` e `CLAUDE.md` nel tuo repository

42 42 

43> **[Leggi e richiedi revisioni su una pull request](https://code.claude.com/docs/it/code-review-pull-requests.md)**43> [card] [Leggi e richiedi revisioni su una pull request](https://code.claude.com/docs/it/code-review-pull-requests.md)

44>44>

45> Leggi i risultati e la loro gravità, e richiedi un'altra revisione con un commento45> Leggi i risultati e la loro gravità, e richiedi un'altra revisione con un commento

46 46 

47> **[Risoluzione dei problemi di Code Review](https://code.claude.com/docs/it/code-review-troubleshooting.md)**47> [card] [Risoluzione dei problemi di Code Review](https://code.claude.com/docs/it/code-review-troubleshooting.md)

48>48>

49> Risolvi una revisione che non è partita, non è riuscita o è stata saltata per il budget49> Risolvi una revisione che non è partita, non è riuscita o è stata saltata per il budget

50 50 

51> **[Costi e utilizzo di Code Review](https://code.claude.com/docs/it/code-review-costs.md)**51> [card] [Costi e utilizzo di Code Review](https://code.claude.com/docs/it/code-review-costs.md)

52>52>

53> Scopri come vengono fatturate le revisioni, stima la spesa, imposta il limite di spesa mensile e monitora l'attività di revisione53> Scopri come vengono fatturate le revisioni, stima la spesa, imposta il limite di spesa mensile e monitora l'attività di revisione

54 54 

commands.md +5 −5

Details

55| `/artifact-capabilities` | **[Skill](https://code.claude.com/docs/it/skills.md#bundled-skills).** Carica il riferimento per le funzionalità di runtime che un [artefatto](https://code.claude.com/docs/it/artifacts.md) pubblicato può usare, come [chiamare i tuoi connettori](https://code.claude.com/docs/it/artifacts.md#pull-live-data-with-mcp-connectors) o [offrire il download di un file](https://code.claude.com/docs/it/artifacts.md#offer-a-file-download), incluse quelle disponibili per il tuo account. Claude normalmente lo carica di propria iniziativa prima di creare una pagina che ne usa una. Disponibile dove sono disponibili gli [artefatti](https://code.claude.com/docs/it/artifacts.md#availability) |55| `/artifact-capabilities` | **[Skill](https://code.claude.com/docs/it/skills.md#bundled-skills).** Carica il riferimento per le funzionalità di runtime che un [artefatto](https://code.claude.com/docs/it/artifacts.md) pubblicato può usare, come [chiamare i tuoi connettori](https://code.claude.com/docs/it/artifacts.md#pull-live-data-with-mcp-connectors) o [offrire il download di un file](https://code.claude.com/docs/it/artifacts.md#offer-a-file-download), incluse quelle disponibili per il tuo account. Claude normalmente lo carica di propria iniziativa prima di creare una pagina che ne usa una. Disponibile dove sono disponibili gli [artefatti](https://code.claude.com/docs/it/artifacts.md#availability) |

56| `/artifact-diagramming` | **[Skill](https://code.claude.com/docs/it/skills.md#bundled-skills).** Carica le linee guida sui diagrammi che Claude deve seguire negli [artefatti](https://code.claude.com/docs/it/artifacts.md): quando un diagramma è utile, cosa disegnare e come scrivere SVG inline che resti leggibile nei temi chiaro e scuro. Richiede Claude Code v2.1.221 o successiva |56| `/artifact-diagramming` | **[Skill](https://code.claude.com/docs/it/skills.md#bundled-skills).** Carica le linee guida sui diagrammi che Claude deve seguire negli [artefatti](https://code.claude.com/docs/it/artifacts.md): quando un diagramma è utile, cosa disegnare e come scrivere SVG inline che resti leggibile nei temi chiaro e scuro. Richiede Claude Code v2.1.221 o successiva |

57| `/artifacts` | Elenca gli [artefatti](https://code.claude.com/docs/it/artifacts.md#find-an-artifact-again) di tua proprietà o condivisi con te, poi ti permette di allegarne uno alla sessione, aprirlo nel browser o copiarne il link. Disponibile dove sono disponibili gli [artefatti](https://code.claude.com/docs/it/artifacts.md#availability) |57| `/artifacts` | Elenca gli [artefatti](https://code.claude.com/docs/it/artifacts.md#find-an-artifact-again) di tua proprietà o condivisi con te, poi ti permette di allegarne uno alla sessione, aprirlo nel browser o copiarne il link. Disponibile dove sono disponibili gli [artefatti](https://code.claude.com/docs/it/artifacts.md#availability) |

58| `/auto-mode-setup` | [Genera una bozza di voci `autoMode.environment`](https://code.claude.com/docs/it/auto-mode-config#generate-environment-entries) dal tuo progetto e dalle sessioni recenti, poi ti permette di rivedere la bozza e salvarla nelle tue impostazioni utente. Su un piano Pro, Max o Team, richiede Claude Code v2.1.228 o successiva, oppure la v2.1.233 o successiva su Windows nativo. Su un piano Enterprise o con una chiave API della Claude Console, richiede la v2.1.283 o successiva. Se il comando non è presente, consulta [`/auto-mode-setup` returns "Unknown command"](https://code.claude.com/docs/it/auto-mode-config#auto-mode-setup-returns-unknown-command) |58| `/auto-mode-setup` | [Genera una bozza di voci `autoMode.environment`](https://code.claude.com/docs/it/auto-mode-config#generate-environment-entries) dal tuo progetto e dalle sessioni recenti, poi ti permette di rivedere la bozza e salvarla nelle tue impostazioni utente. Su un piano Pro, Max, Ultra o Team, richiede Claude Code v2.1.228 o successiva, oppure la v2.1.233 o successiva su Windows nativo. Su un piano Enterprise o con una chiave API della Claude Console, richiede la v2.1.283 o successiva. Se il comando non è presente, consulta [`/auto-mode-setup` returns "Unknown command"](https://code.claude.com/docs/it/auto-mode-config#auto-mode-setup-returns-unknown-command) |

59| `/autocompact [auto\|<tokens>]` | Imposta la finestra di compattazione automatica: quanto si riempie la finestra di contesto prima che Claude Code esegua la compattazione automaticamente. Passa una dimensione come `500k`, oppure `auto` per tornare alla finestra ottimizzata per il tuo modello. Claude Code salva il valore nelle impostazioni utente e lo applica alla sessione corrente. Consulta [Impostare la finestra di compattazione automatica](https://code.claude.com/docs/it/model-config.md#set-the-auto-compact-window) per i valori accettati e ciò che lo sovrascrive. Senza argomento, apre una finestra di dialogo che mostra la finestra corrente. Richiede Claude Code v2.1.221 o successiva |59| `/autocompact [auto\|<tokens>]` | Imposta la finestra di compattazione automatica: quanto si riempie la finestra di contesto prima che Claude Code esegua la compattazione automaticamente. Passa una dimensione come `500k`, oppure `auto` per tornare alla finestra ottimizzata per il tuo modello. Claude Code salva il valore nelle impostazioni utente e lo applica alla sessione corrente. Consulta [Impostare la finestra di compattazione automatica](https://code.claude.com/docs/it/model-config.md#set-the-auto-compact-window) per i valori accettati e ciò che lo sovrascrive. Senza argomento, apre una finestra di dialogo che mostra la finestra corrente. Richiede Claude Code v2.1.221 o successiva |

60| `/autofix-pr [prompt]` | Avvia una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md#auto-fix-pull-requests) che monitora la PR del branch corrente ed esegue il push delle correzioni quando la CI fallisce o i revisori lasciano commenti. Rileva la PR aperta dal branch di cui hai eseguito il checkout con `gh pr view`; per monitorare una PR diversa, esegui prima il checkout del suo branch. Per impostazione predefinita, alla sessione cloud viene indicato di correggere ogni errore della CI e ogni commento di revisione; passa un prompt per darle istruzioni diverse, ad esempio `/autofix-pr only fix lint and type errors`. Richiede la CLI `gh` e l'accesso alle [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) |60| `/autofix-pr [prompt]` | Avvia una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md#auto-fix-pull-requests) che monitora la PR del branch corrente ed esegue il push delle correzioni quando la CI fallisce o i revisori lasciano commenti. Rileva la PR aperta dal branch di cui hai eseguito il checkout con `gh pr view`; per monitorare una PR diversa, esegui prima il checkout del suo branch. Per impostazione predefinita, alla sessione cloud viene indicato di correggere ogni errore della CI e ogni commento di revisione; passa un prompt per darle istruzioni diverse, ad esempio `/autofix-pr only fix lint and type errors`. Richiede la CLI `gh` e l'accesso alle [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) |

61| `/background [prompt]` | Scollega la sessione corrente per eseguirla come [agente in background](https://code.claude.com/docs/it/agent-view.md) e liberare questo terminale. Passa un prompt per inviare un'ultima istruzione prima di scollegarla. Monitora la sessione con `claude agents`. Per copiare la conversazione in una nuova sessione in background mentre questa continua a essere eseguita, usa `/fork`. Alias: `/bg` |61| `/background [prompt]` | Scollega la sessione corrente per eseguirla come [agente in background](https://code.claude.com/docs/it/agent-view.md) e liberare questo terminale. Passa un prompt per inviare un'ultima istruzione prima di scollegarla. Monitora la sessione con `claude agents`. Per copiare la conversazione in una nuova sessione in background mentre questa continua a essere eseguita, usa `/fork`. Alias: `/bg` |

120| `/plugin-authoring` | Carica il riferimento su cui Claude si basa per [scrivere un mod](https://code.claude.com/docs/it/plugins/mods/create.md#ask-claude-for-a-mod). Claude può caricarlo di propria iniziativa quando chiedi un mod. Si tratta di una skill di un [plugin integrato](https://code.claude.com/docs/it/plugins/mods/overview.md#mods-built-into-claude-code), che puoi disattivare in `/plugin`. Richiede Claude Code v2.1.287 o successiva |120| `/plugin-authoring` | Carica il riferimento su cui Claude si basa per [scrivere un mod](https://code.claude.com/docs/it/plugins/mods/create.md#ask-claude-for-a-mod). Claude può caricarlo di propria iniziativa quando chiedi un mod. Si tratta di una skill di un [plugin integrato](https://code.claude.com/docs/it/plugins/mods/overview.md#mods-built-into-claude-code), che puoi disattivare in `/plugin`. Richiede Claude Code v2.1.287 o successiva |

121| `/powerup` | Permette di scoprire le funzionalità di Claude Code attraverso brevi lezioni interattive con demo animate |121| `/powerup` | Permette di scoprire le funzionalità di Claude Code attraverso brevi lezioni interattive con demo animate |

122| `/pr-comments [PR]` | Rimosso nella v2.1.91. Chiedi invece direttamente a Claude di visualizzare i commenti della pull request. Nelle versioni precedenti, recupera e mostra i commenti di una pull request GitHub; rileva automaticamente la PR del branch corrente, oppure passa l'URL o il numero di una PR. Richiede la CLI `gh` |122| `/pr-comments [PR]` | Rimosso nella v2.1.91. Chiedi invece direttamente a Claude di visualizzare i commenti della pull request. Nelle versioni precedenti, recupera e mostra i commenti di una pull request GitHub; rileva automaticamente la PR del branch corrente, oppure passa l'URL o il numero di una PR. Richiede la CLI `gh` |

123| `/privacy-settings` | Visualizza e aggiorna le tue impostazioni sulla privacy. Disponibile solo per gli abbonati ai piani Pro e Max |123| `/privacy-settings` | Visualizza e aggiorna le tue impostazioni sulla privacy. Disponibile solo per gli abbonati ai piani Pro, Max e Ultra |

124| `/radio` | Apre la radio lo-fi Claude FM nel browser. Stampa l'URL dello stream quando non è disponibile un browser |124| `/radio` | Apre la radio lo-fi Claude FM nel browser. Stampa l'URL dello stream quando non è disponibile un browser |

125| `/rate-limit-options` | Mostra i modi per continuare a lavorare quando un limite di utilizzo di claude.ai blocca una richiesta: attendere e [continuare automaticamente quando il limite si reimposta](https://code.claude.com/docs/it/interactive-mode.md#wait-for-a-usage-limit-to-reset), aggiungere [crediti di utilizzo](https://code.claude.com/docs/it/costs.md#add-usage-credits-to-your-subscription) o eseguire l'upgrade del piano. Claude Code può anche aprire questo menu di propria iniziativa quando raggiungi un limite nel tuo terminale. Consulta [Disattivare la continuazione automatica](https://code.claude.com/docs/it/interactive-mode.md#turn-automatic-continue-off). Richiede un abbonamento claude.ai. Le righe per attendere e continuare richiedono Claude Code v2.1.234 o successiva |125| `/rate-limit-options` | Mostra i modi per continuare a lavorare quando un limite di utilizzo di claude.ai blocca una richiesta: attendere e [continuare automaticamente quando il limite si reimposta](https://code.claude.com/docs/it/interactive-mode.md#wait-for-a-usage-limit-to-reset), aggiungere [crediti di utilizzo](https://code.claude.com/docs/it/costs.md#add-usage-credits-to-your-subscription) o eseguire l'upgrade del piano. Claude Code può anche aprire questo menu di propria iniziativa quando raggiungi un limite nel tuo terminale. Consulta [Disattivare la continuazione automatica](https://code.claude.com/docs/it/interactive-mode.md#turn-automatic-continue-off). Richiede un abbonamento claude.ai. Le righe per attendere e continuare richiedono Claude Code v2.1.234 o successiva |

126| `/recap` | Genera su richiesta un riepilogo di una riga della sessione corrente. Consulta [Riepilogo della sessione](https://code.claude.com/docs/it/interactive-mode.md#session-recap) per il riepilogo automatico che compare dopo che sei stato assente |126| `/recap` | Genera su richiesta un riepilogo di una riga della sessione corrente. Consulta [Riepilogo della sessione](https://code.claude.com/docs/it/interactive-mode.md#session-recap) per il riepilogo automatico che compare dopo che sei stato assente |

130| `/remote-control` | Rende questa sessione disponibile per [Remote Control](https://code.claude.com/docs/it/remote-control.md) da claude.ai. Se lo esegui senza aver effettuato l'accesso, stampa che Remote Control richiede un abbonamento claude.ai e ti spiega come accedere. Alias: `/rc` |130| `/remote-control` | Rende questa sessione disponibile per [Remote Control](https://code.claude.com/docs/it/remote-control.md) da claude.ai. Se lo esegui senza aver effettuato l'accesso, stampa che Remote Control richiede un abbonamento claude.ai e ti spiega come accedere. Alias: `/rc` |

131| `/remote-env` | Sceglie l'[ambiente cloud](https://code.claude.com/docs/it/cloud-environments.md#select-an-environment-from-the-cli) predefinito per le sessioni cloud che avvii dalla CLI |131| `/remote-env` | Sceglie l'[ambiente cloud](https://code.claude.com/docs/it/cloud-environments.md#select-an-environment-from-the-cli) predefinito per le sessioni cloud che avvii dalla CLI |

132| `/rename [name]` | Rinomina la sessione corrente e mostra il nome sulla barra del prompt. Senza un nome, ne genera automaticamente uno dalla cronologia della conversazione. Disponibile anche in modalità non interattiva (`-p`). Da ogni superficie in cui è possibile rinominare, inclusi claude.ai e l'app desktop, Claude Code sostituisce con spazi i caratteri di controllo e invisibili nel nuovo nome e limita il nome a 200 caratteri. Se il nome è vuoto una volta rimossi i caratteri invisibili, Claude Code lo rifiuta e mostra `That name is empty once invisible characters are removed. Usage: /rename <name>`. La sostituzione dei caratteri e il limite di lunghezza richiedono Claude Code v2.1.221 o successiva |132| `/rename [name]` | Rinomina la sessione corrente e mostra il nome sulla barra del prompt. Senza un nome, ne genera automaticamente uno dalla cronologia della conversazione. Disponibile anche in modalità non interattiva (`-p`). Da ogni superficie in cui è possibile rinominare, inclusi claude.ai e l'app desktop, Claude Code sostituisce con spazi i caratteri di controllo e invisibili nel nuovo nome e limita il nome a 200 caratteri. Se il nome è vuoto una volta rimossi i caratteri invisibili, Claude Code lo rifiuta e mostra `That name is empty once invisible characters are removed. Usage: /rename <name>`. La sostituzione dei caratteri e il limite di lunghezza richiedono Claude Code v2.1.221 o successiva |

133| `/restart` | Riavvia Claude Code e riprende questa sessione, applicando così un aggiornamento installato. Eseguilo quando il piè di pagina lo propone dopo l'installazione di un aggiornamento. Richiede un piano Pro o Max e un'installazione nativa su macOS o Linux, non WSL. Richiede Claude Code v2.1.288 o successiva. Alias: `/update` |133| `/restart` | Riavvia Claude Code e riprende questa sessione, applicando così un aggiornamento installato. Eseguilo quando il piè di pagina lo propone dopo l'installazione di un aggiornamento. Richiede un piano Pro, Max o Ultra e un'installazione nativa su macOS o Linux, non WSL. Richiede Claude Code v2.1.288 o successiva. Alias: `/update` |

134| `/resume [session]` | Riprende una conversazione per ID o nome, oppure apre il selettore delle sessioni. Le [sessioni in background](https://code.claude.com/docs/it/agent-view.md) compaiono nel selettore contrassegnate con `bg`. Riprendendone una ancora in esecuzione, dal selettore o per ID o nome, [si apre quella sessione](https://code.claude.com/docs/it/sessions.md#resume-a-running-background-session): la conversazione corrente passa in background e questo terminale si collega a quella in esecuzione. Premi `←` su un prompt vuoto per tornare alla vista agenti, che elenca anche la conversazione che hai lasciato. Prima della v2.1.285, Claude Code rifiutava e ti diceva di aprire la sessione con `claude attach` o di arrestarla prima. Alias: `/continue` |134| `/resume [session]` | Riprende una conversazione per ID o nome, oppure apre il selettore delle sessioni. Le [sessioni in background](https://code.claude.com/docs/it/agent-view.md) compaiono nel selettore contrassegnate con `bg`. Riprendendone una ancora in esecuzione, dal selettore o per ID o nome, [si apre quella sessione](https://code.claude.com/docs/it/sessions.md#resume-a-running-background-session): la conversazione corrente passa in background e questo terminale si collega a quella in esecuzione. Premi `←` su un prompt vuoto per tornare alla vista agenti, che elenca anche la conversazione che hai lasciato. Prima della v2.1.285, Claude Code rifiutava e ti diceva di aprire la sessione con `claude attach` o di arrestarla prima. Alias: `/continue` |

135| `/review [low\|medium\|high\|xhigh\|max\|ultra] [--fix] [--comment] [--max-findings n\|all\|default] [pr#\|branch\|path]` | Alias di [`/code-review`](https://code.claude.com/docs/it/code-review-local): esamina il diff corrente, oppure un numero di PR, un branch o un percorso che passi, come `/review 1234`, e accetta gli stessi livelli di sforzo e flag. Se non indichi un livello, la revisione riutilizza l'ultimo livello da `low` a `max` che hai digitato; consulta [Revisione locale con `/code-review`](https://code.claude.com/docs/it/code-review-local) per le regole esatte. Per una revisione cloud approfondita, usa [`/code-review ultra`](https://code.claude.com/docs/it/ultrareview). Prima della v2.1.223, `/review` era un comando separato che eseguiva una revisione in un solo passaggio e di sola lettura di una pull request GitHub indicata per numero, elencando le PR aperte tra cui scegliere quando eseguito senza argomento; dalla v2.1.186 alla v2.1.201, eseguiva lo stesso motore multi-agente di `/code-review medium` |135| `/review [low\|medium\|high\|xhigh\|max\|ultra] [--fix] [--comment] [--max-findings n\|all\|default] [pr#\|branch\|path]` | Alias di [`/code-review`](https://code.claude.com/docs/it/code-review-local): esamina il diff corrente, oppure un numero di PR, un branch o un percorso che passi, come `/review 1234`, e accetta gli stessi livelli di sforzo e flag. Se non indichi un livello, la revisione riutilizza l'ultimo livello da `low` a `max` che hai digitato; consulta [Revisione locale con `/code-review`](https://code.claude.com/docs/it/code-review-local) per le regole esatte. Per una revisione cloud approfondita, usa [`/code-review ultra`](https://code.claude.com/docs/it/ultrareview). Prima della v2.1.223, `/review` era un comando separato che eseguiva una revisione in un solo passaggio e di sola lettura di una pull request GitHub indicata per numero, elencando le PR aperte tra cui scegliere quando eseguito senza argomento; dalla v2.1.186 alla v2.1.201, eseguiva lo stesso motore multi-agente di `/code-review medium` |

136| `/rewind` | Riporta la conversazione e/o il codice a un punto precedente, oppure crea un riepilogo a partire da un messaggio selezionato. Consulta [checkpointing](https://code.claude.com/docs/it/checkpointing.md). Alias: `/checkpoint`, `/undo` |136| `/rewind` | Riporta la conversazione e/o il codice a un punto precedente, oppure crea un riepilogo a partire da un messaggio selezionato. Consulta [checkpointing](https://code.claude.com/docs/it/checkpointing.md). Alias: `/checkpoint`, `/undo` |

159| `/theme` | Cambia il tema dei colori. Include un'opzione `auto` che si adatta allo sfondo chiaro o scuro del terminale, varianti chiare e scure, temi accessibili ai daltonici (daltonized), temi ANSI che usano la tavolozza colori del terminale e qualsiasi [tema personalizzato](https://code.claude.com/docs/it/terminal-config.md#create-a-custom-theme) da `~/.claude/themes/` o dai plugin. Seleziona **New custom theme…** per crearne uno |159| `/theme` | Cambia il tema dei colori. Include un'opzione `auto` che si adatta allo sfondo chiaro o scuro del terminale, varianti chiare e scure, temi accessibili ai daltonici (daltonized), temi ANSI che usano la tavolozza colori del terminale e qualsiasi [tema personalizzato](https://code.claude.com/docs/it/terminal-config.md#create-a-custom-theme) da `~/.claude/themes/` o dai plugin. Seleziona **New custom theme…** per crearne uno |

160| `/tui [default\|fullscreen]` | Imposta il renderer dell'interfaccia del terminale e lo riavvia mantenendo intatta la conversazione. `fullscreen` abilita il [renderer alt-screen senza sfarfallio](https://code.claude.com/docs/it/fullscreen.md). Senza argomento, stampa il renderer attivo |160| `/tui [default\|fullscreen]` | Imposta il renderer dell'interfaccia del terminale e lo riavvia mantenendo intatta la conversazione. `fullscreen` abilita il [renderer alt-screen senza sfarfallio](https://code.claude.com/docs/it/fullscreen.md). Senza argomento, stampa il renderer attivo |

161| `/ultraplan <prompt>` | Rimosso. Usa invece il [plan mode](https://code.claude.com/docs/it/permission-modes.md#analyze-before-you-edit-with-plan-mode). In precedenza inviava un'attività di pianificazione a una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) per la revisione nel browser |161| `/ultraplan <prompt>` | Rimosso. Usa invece il [plan mode](https://code.claude.com/docs/it/permission-modes.md#analyze-before-you-edit-with-plan-mode). In precedenza inviava un'attività di pianificazione a una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) per la revisione nel browser |

162| `/ultrareview [PR or branch]` | Esegue una code review approfondita e multi-agente in una sandbox cloud con [ultrareview](https://code.claude.com/docs/it/ultrareview.md). Passa un riferimento a una PR per esaminare quella pull request, oppure un branch base o un commit per cambiare la base di confronto. L'invocazione preferita è `/code-review ultra`, e `/ultrareview` è un alias. Include 3 esecuzioni gratuite sui piani Pro e Max, poi richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) |162| `/ultrareview [PR or branch]` | Esegue una code review approfondita e multi-agente in una sandbox cloud con [ultrareview](https://code.claude.com/docs/it/ultrareview.md). Passa un riferimento a una PR per esaminare quella pull request, oppure un branch base o un commit per cambiare la base di confronto. L'invocazione preferita è `/code-review ultra`, e `/ultrareview` è un alias. Include 3 esecuzioni gratuite sui piani Pro, Max e Ultra, poi richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) |

163| `/update-config [request]` | **[Skill](https://code.claude.com/docs/it/skills.md#bundled-skills).** Descrivi una modifica alle impostazioni, come consentire un comando, impostare una variabile d'ambiente o aggiungere un [hook](https://code.claude.com/docs/it/hooks.md), e Claude modifica il file [`settings.json`](https://code.claude.com/docs/it/settings) corrispondente. Per opzioni come tema e modello, usa invece `/config` |163| `/update-config [request]` | **[Skill](https://code.claude.com/docs/it/skills.md#bundled-skills).** Descrivi una modifica alle impostazioni, come consentire un comando, impostare una variabile d'ambiente o aggiungere un [hook](https://code.claude.com/docs/it/hooks.md), e Claude modifica il file [`settings.json`](https://code.claude.com/docs/it/settings) corrispondente. Per opzioni come tema e modello, usa invece `/config` |

164| `/upgrade` | Apre la pagina di upgrade nel browser per passare a un piano di livello superiore. Quando il browser non si apre, il comando mostra una richiesta di accesso senza stampare l'URL |164| `/upgrade` | Apre la pagina di upgrade nel browser per passare a un piano di livello superiore. Quando il browser non si apre, il comando mostra una richiesta di accesso senza stampare l'URL |

165| `/usage` | Mostra il costo della sessione, i limiti di utilizzo del piano e le statistiche di attività. Su un piano Pro, Max, Team o Enterprise, include un [dettaglio di ciò che conta ai fini dei limiti del piano](https://code.claude.com/docs/it/costs.md#plan-usage-breakdown). `/cost` e `/stats` sono alias |165| `/usage` | Mostra il costo della sessione, i limiti di utilizzo del piano e le statistiche di attività. Su un piano Pro, Max, Ultra, Team o Enterprise, include un [dettaglio di ciò che conta ai fini dei limiti del piano](https://code.claude.com/docs/it/costs.md#plan-usage-breakdown). `/cost` e `/stats` sono alias |

166| `/usage-credits` | Configura i crediti di utilizzo, o li richiede al tuo amministratore, quando raggiungi un limite. Apre le [impostazioni di fatturazione dei crediti di utilizzo](https://code.claude.com/docs/it/costs.md#add-usage-credits-to-your-subscription) nel browser, tranne per i membri Team ed Enterprise senza accesso alla fatturazione, che invece inviano dalla CLI una richiesta di crediti di utilizzo al proprio amministratore, dopo aver confermato in una finestra di dialogo che la richiesta invia una notifica ai loro amministratori. Quando nessun browser può aprire la pagina di fatturazione, ad esempio tramite SSH, il comando stampa invece l'URL da visitare; questo richiede Claude Code v2.1.205 o successiva, e le versioni precedenti non mostravano nulla in quel caso. In precedenza `/extra-usage` |166| `/usage-credits` | Configura i crediti di utilizzo, o li richiede al tuo amministratore, quando raggiungi un limite. Apre le [impostazioni di fatturazione dei crediti di utilizzo](https://code.claude.com/docs/it/costs.md#add-usage-credits-to-your-subscription) nel browser, tranne per i membri Team ed Enterprise senza accesso alla fatturazione, che invece inviano dalla CLI una richiesta di crediti di utilizzo al proprio amministratore, dopo aver confermato in una finestra di dialogo che la richiesta invia una notifica ai loro amministratori. Quando nessun browser può aprire la pagina di fatturazione, ad esempio tramite SSH, il comando stampa invece l'URL da visitare; questo richiede Claude Code v2.1.205 o successiva, e le versioni precedenti non mostravano nulla in quel caso. In precedenza `/extra-usage` |

167| `/verify` | **[Skill](https://code.claude.com/docs/it/skills.md#bundled-skills).** Conferma che una modifica al codice faccia ciò che deve eseguendo la build dell'app del tuo progetto, avviandola e osservando il risultato, invece di affidarsi a test o controlli dei tipi. Consulta [Eseguire e verificare la tua app](https://code.claude.com/docs/it/skills.md#run-and-verify-your-app) |167| `/verify` | **[Skill](https://code.claude.com/docs/it/skills.md#bundled-skills).** Conferma che una modifica al codice faccia ciò che deve eseguendo la build dell'app del tuo progetto, avviandola e osservando il risultato, invece di affidarsi a test o controlli dei tipi. Consulta [Eseguire e verificare la tua app](https://code.claude.com/docs/it/skills.md#run-and-verify-your-app) |

168| `/vim` | Rimosso nella v2.1.92. Per passare dalla modalità di modifica Vim a quella Normal e viceversa, usa `/config` → Editor mode |168| `/vim` | Rimosso nella v2.1.92. Per passare dalla modalità di modifica Vim a quella Normal e viceversa, usa `/config` → Editor mode |

Details

500 500 

501## Passaggi successivi501## Passaggi successivi

502 502 

503> **[Best practices](https://code.claude.com/docs/it/best-practices.md)**503> [card] [Best practices](https://code.claude.com/docs/it/best-practices.md)

504>504>

505> Modelli per ottenere il massimo da Claude Code505> Modelli per ottenere il massimo da Claude Code

506 506 

507> **[Gestire le sessioni](https://code.claude.com/docs/it/sessions.md)**507> [card] [Gestire le sessioni](https://code.claude.com/docs/it/sessions.md)

508>508>

509> Riprendere, denominare e dirammare conversazioni509> Riprendere, denominare e dirammare conversazioni

510 510 

511> **[Worktrees](https://code.claude.com/docs/it/worktrees.md)**511> [card] [Worktrees](https://code.claude.com/docs/it/worktrees.md)

512>512>

513> Eseguire sessioni parallele isolate513> Eseguire sessioni parallele isolate

514 514 

515> **[Estendere Claude Code](https://code.claude.com/docs/it/features-overview.md)**515> [card] [Estendere Claude Code](https://code.claude.com/docs/it/features-overview.md)

516>516>

517> Aggiungere skills, hooks, MCP, subagent e plugin517> Aggiungere skills, hooks, MCP, subagent e plugin

communications-kit.md +111 −111

Details

33 33 

34Usate questo come messaggio di rollout standard a livello di organizzazione. Spiega cos'è Claude Code, fornisce un percorso di installazione di due minuti, dà ai lettori un compito concreto da provare e risponde a "dove va il mio codice?" prima che qualcuno debba chiedere.34Usate questo come messaggio di rollout standard a livello di organizzazione. Spiega cos'è Claude Code, fornisce un percorso di installazione di due minuti, dà ai lettori un compito concreto da provare e risponde a "dove va il mio codice?" prima che qualcuno debba chiedere.

35 35 

36**Email**36> [tab] Email

37 37>

38```text theme={null}38> ```text theme={null}

39Subject: Claude Code è live per [Engineering / il tuo team]39> Subject: Claude Code è live per [Engineering / il tuo team]

40 40>

41Team,41> Team,

42 42>

43A partire da oggi hai accesso a Claude Code, un agente di codifica AI che43> A partire da oggi hai accesso a Claude Code, un agente di codifica AI che

44funziona nel tuo terminale, legge il tuo codebase effettivo e porta a44> funziona nel tuo terminale, legge il tuo codebase effettivo e porta a

45termine compiti reali da capo a fondo: debug, refactor, test, PR. Non è45> termine compiti reali da capo a fondo: debug, refactor, test, PR. Non è

46autocomplete e non è una finestra di chat. Modifica file ed esegue i tuoi46> autocomplete e non è una finestra di chat. Modifica file ed esegue i tuoi

47comandi.47> comandi.

48 48>

49Inizia in due minuti:49> Inizia in due minuti:

50 50>

51 curl -fsSL https://claude.ai/install.sh | bash51> curl -fsSL https://claude.ai/install.sh | bash

52 cd <your-repo>52> cd <your-repo>

53 claude53> claude

54 54>

55Poi esegui /init una volta. Claude legge il tuo progetto e scrive un55> Poi esegui /init una volta. Claude legge il tuo progetto e scrive un

56CLAUDE.md con i tuoi comandi di build e le tue convenzioni, così smetti di56> CLAUDE.md con i tuoi comandi di build e le tue convenzioni, così smetti di

57rispiegare le basi.57> rispiegare le basi.

58 58>

59Poi prova uno di questi nel repo in cui sei già:59> Poi prova uno di questi nel repo in cui sei già:

60 60>

61 - "Il test in [file] è instabile. Scopri perché e correggilo"61> - "Il test in [file] è instabile. Scopri perché e correggilo"

62 - "Spiegami come [module] gestisce [X]"62> - "Spiegami come [module] gestisce [X]"

63 - "Guarda il mio diff di lavoro e dimmi cosa è rischioso prima che lo63> - "Guarda il mio diff di lavoro e dimmi cosa è rischioso prima che lo

64 pushi"64> pushi"

65 65>

66Dove va il tuo codice: Claude Code funziona nel tuo terminale e comunica66> Dove va il tuo codice: Claude Code funziona nel tuo terminale e comunica

67direttamente con l'API di Anthropic. Con il nostro piano Team o Enterprise,67> direttamente con l'API di Anthropic. Con il nostro piano Team o Enterprise,

68Anthropic non utilizza il tuo codice o i tuoi prompt per addestrare i suoi68> Anthropic non utilizza il tuo codice o i tuoi prompt per addestrare i suoi

69modelli.69> modelli.

70Dettagli: https://code.claude.com/docs/it/data-usage70> Dettagli: https://code.claude.com/docs/it/data-usage

71 https://code.claude.com/docs/it/security71> https://code.claude.com/docs/it/security

72 72>

73Dove andare con le domande: #claude-code. [Owner name] lo sta monitorando73> Dove andare con le domande: #claude-code. [Owner name] lo sta monitorando

74questa settimana.74> questa settimana.

75 75>

76- [Name]76> - [Name]

77 77>

78P.S. Preferisci il tuo editor? C'è un'estensione VS Code e un plugin78> P.S. Preferisci il tuo editor? C'è un'estensione VS Code e un plugin

79JetBrains. Lo stesso agente, nessun terminale richiesto.79> JetBrains. Lo stesso agente, nessun terminale richiesto.

80```80> ```

81 

82**Slack o Teams**

83 

84```markdown theme={null}

85🚀 *Claude Code è live per [team]*

86 

87Agente di codifica AI, funziona nel tuo terminale, legge il tuo repo,

88fa lavoro reale: bug, refactor, test, PR.

89 

90`curl -fsSL https://claude.ai/install.sh | bash` → `cd your-repo` → `claude`

91 

92*Prima cosa da provare* → esegui `/init`, poi: "il test in [file] è

93instabile, scopri perché e correggilo."

94 

95🔒 Funziona nel tuo terminale, comunica direttamente con l'API di Anthropic.

96Con il nostro piano Team o Enterprise, il tuo codice e i tuoi prompt non

97vengono utilizzati per addestrare i modelli.

98Data usage → https://code.claude.com/docs/it/data-usage

99 

100📚 Guida rapida · VS Code · Corso gratuito di 1 ora

101 https://code.claude.com/docs/it/quickstart

102 https://code.claude.com/docs/it/vs-code

103 https://academy.claude.com/courses/claude-code-in-action

104 81 

105Domande → questo thread. [Owner] è il responsabile.82> [tab] Slack o Teams

106```83>

84> ```markdown theme={null}

85> 🚀 *Claude Code è live per [team]*

86>

87> Agente di codifica AI, funziona nel tuo terminale, legge il tuo repo,

88> fa lavoro reale: bug, refactor, test, PR.

89>

90> `curl -fsSL https://claude.ai/install.sh | bash` → `cd your-repo` → `claude`

91>

92> *Prima cosa da provare* → esegui `/init`, poi: "il test in [file] è

93> instabile, scopri perché e correggilo."

94>

95> 🔒 Funziona nel tuo terminale, comunica direttamente con l'API di Anthropic.

96> Con il nostro piano Team o Enterprise, il tuo codice e i tuoi prompt non

97> vengono utilizzati per addestrare i modelli.

98> Data usage → https://code.claude.com/docs/it/data-usage

99>

100> 📚 Guida rapida · VS Code · Corso gratuito di 1 ora

101> https://code.claude.com/docs/it/quickstart

102> https://code.claude.com/docs/it/vs-code

103> https://academy.claude.com/courses/claude-code-in-action

104>

105> Domande → questo thread. [Owner] è il responsabile.

106> ```

107 107 

108### Variante sponsor esecutivo108### Variante sponsor esecutivo

109 109 

111 111 

112Questa versione è deliberatamente ridotta a una richiesta: installatelo ed eseguitelo su un compito reale. Il lavoro del dirigente è far atterrare la richiesta; l'annuncio standard e `#claude-code` gestiscono il come.112Questa versione è deliberatamente ridotta a una richiesta: installatelo ed eseguitelo su un compito reale. Il lavoro del dirigente è far atterrare la richiesta; l'annuncio standard e `#claude-code` gestiscono il come.

113 113 

114**Email**114> [tab] Email

115 115>

116```text theme={null}116> ```text theme={null}

117Subject: Una cosa che vorrei che ogni ingegnere provasse questa settimana117> Subject: Una cosa che vorrei che ogni ingegnere provasse questa settimana

118 118>

119Team,119> Team,

120 120>

121Abbiamo attivato Claude Code per tutto l'ingegneria. È un agente AI che121> Abbiamo attivato Claude Code per tutto l'ingegneria. È un agente AI che

122funziona direttamente nel vostro terminale, sul vostro codebase effettivo,122> funziona direttamente nel vostro terminale, sul vostro codebase effettivo,

123e i risultati iniziali dei team che lo stanno già utilizzando sono123> e i risultati iniziali dei team che lo stanno già utilizzando sono

124abbastanza forti che voglio che tutti lo usino questa settimana.124> abbastanza forti che voglio che tutti lo usino questa settimana.

125 125>

126Vi chiedo dieci minuti:126> Vi chiedo dieci minuti:

127 127>

128 curl -fsSL https://claude.ai/install.sh | bash128> curl -fsSL https://claude.ai/install.sh | bash

129 cd <your-repo>129> cd <your-repo>

130 claude130> claude

131 131>

132Poi dategli un compito reale: il bug che state rimandando, o "spiegami come132> Poi dategli un compito reale: il bug che state rimandando, o "spiegami come

133funziona [module]".133> funziona [module]".

134 134>

135Questa è tutta la richiesta. [Owner name] e il team sono in #claude-code135> Questa è tutta la richiesta. [Owner name] e il team sono in #claude-code

136per qualsiasi cosa incontriate lungo il percorso.136> per qualsiasi cosa incontriate lungo il percorso.

137 137>

138- [Exec Name]138> - [Exec Name]

139 [Title]139> [Title]

140```140> ```

141 

142**Slack o Teams**

143 

144```markdown theme={null}

145📣 *Da [Exec Name]: una cosa da provare questa settimana*

146 

147Abbiamo attivato *Claude Code* per tutto l'ingegneria. I risultati iniziali

148sono abbastanza forti che sto chiedendo a tutti di dargli dieci minuti su

149lavoro reale questa settimana.

150 

151`curl -fsSL https://claude.ai/install.sh | bash` → `cd your-repo` →

152`claude` → dategli un compito reale.

153 141 

154Questo è tutto. Domande → #claude-code.142> [tab] Slack o Teams

155```143>

144> ```markdown theme={null}

145> 📣 *Da [Exec Name]: una cosa da provare questa settimana*

146>

147> Abbiamo attivato *Claude Code* per tutto l'ingegneria. I risultati iniziali

148> sono abbastanza forti che sto chiedendo a tutti di dargli dieci minuti su

149> lavoro reale questa settimana.

150>

151> `curl -fsSL https://claude.ai/install.sh | bash` → `cd your-repo` →

152> `claude` → dategli un compito reale.

153>

154> Questo è tutto. Domande → #claude-code.

155> ```

156 156 

157### Variante gruppo pilota157### Variante gruppo pilota

158 158 

computer-use.md +2 −2

Details

8 8 

9> [!NOTE]9> [!NOTE]

10>10>

11> Computer use è un'anteprima di ricerca su macOS che richiede un piano Pro o Max. Non è disponibile nei piani Team o Enterprise. Richiede una sessione interattiva, quindi non è disponibile in modalità non interattiva con il flag `-p`.11> Computer use è un'anteprima di ricerca su macOS che richiede un piano Pro, Max o Ultra. Non è disponibile nei piani Team o Enterprise. Richiede una sessione interattiva, quindi non è disponibile in modalità non interattiva con il flag `-p`.

12 12 

13Computer use consente a Claude di aprire app, controllare il tuo schermo e lavorare sulla tua macchina come faresti tu. Dalla CLI, Claude può compilare un'app Swift, avviarla, fare clic su ogni pulsante e acquisire uno screenshot del risultato, il tutto nella stessa conversazione in cui ha scritto il codice.13Computer use consente a Claude di aprire app, controllare il tuo schermo e lavorare sulla tua macchina come faresti tu. Dalla CLI, Claude può compilare un'app Swift, avviarla, fare clic su ogni pulsante e acquisire uno screenshot del risultato, il tutto nella stessa conversazione in cui ha scritto il codice.

14 14 

198Il server appare solo su configurazioni idonee. Verifica che:198Il server appare solo su configurazioni idonee. Verifica che:

199 199 

200* Sei su macOS. Computer use nella CLI non è disponibile su Linux o Windows. Su Windows, usa [computer use in Desktop](https://code.claude.com/docs/it/desktop.md#let-claude-use-your-computer) invece.200* Sei su macOS. Computer use nella CLI non è disponibile su Linux o Windows. Su Windows, usa [computer use in Desktop](https://code.claude.com/docs/it/desktop.md#let-claude-use-your-computer) invece.

201* Sei su un piano Pro o Max. Esegui `/status` per confermare il tuo abbonamento.201* Sei su un piano Pro, Max o Ultra. Esegui `/status` per confermare il tuo abbonamento.

202* Sei autenticato tramite claude.ai. Computer use non è disponibile con provider di terze parti come Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry. Se accedi a Claude esclusivamente tramite un provider di terze parti, hai bisogno di un account claude.ai separato per usare questa funzionalità.202* Sei autenticato tramite claude.ai. Computer use non è disponibile con provider di terze parti come Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry. Se accedi a Claude esclusivamente tramite un provider di terze parti, hai bisogno di un account claude.ai separato per usare questa funzionalità.

203* Sei in una sessione interattiva. Computer use non è disponibile in modalità non interattiva con il flag `-p`.203* Sei in una sessione interattiva. Computer use non è disponibile in modalità non interattiva con il flag `-p`.

204 204 

costs.md +50 −50

Details

6 6 

7> Traccia l'utilizzo dei token, imposta i limiti di spesa del team e riduci i costi di Claude Code con la gestione del contesto, la selezione del modello, le impostazioni del pensiero esteso e gli hook di pre-elaborazione.7> Traccia l'utilizzo dei token, imposta i limiti di spesa del team e riduci i costi di Claude Code con la gestione del contesto, la selezione del modello, le impostazioni del pensiero esteso e gli hook di pre-elaborazione.

8 8 

9Claude Code addebita il consumo di token API. Per i prezzi dei piani di abbonamento (Pro, Max, Team, Enterprise), vedi [claude.com/pricing](https://claude.com/pricing). I costi per sviluppatore variano notevolmente in base alla selezione del modello, alle dimensioni della codebase e ai modelli di utilizzo come l'esecuzione di più istanze o l'automazione.9Claude Code addebita il consumo di token API. Per i prezzi dei piani di abbonamento (Pro, Max, Ultra, Team, Enterprise), vedi [claude.com/pricing](https://claude.com/pricing). I costi per sviluppatore variano notevolmente in base alla selezione del modello, alle dimensioni del codebase e ai modelli di utilizzo come l'esecuzione di più istanze o l'automazione.

10 10 

11Nelle distribuzioni aziendali, il costo medio è di circa \$13 per sviluppatore per giorno attivo e \$150-250 per sviluppatore al mese, con costi che rimangono al di sotto di \$30 per giorno attivo per il 90% degli utenti. Per stimare la spesa per il tuo team, inizia con un piccolo gruppo pilota e utilizza gli strumenti di tracciamento di seguito per stabilire una baseline prima di un rollout più ampio.11Nelle distribuzioni aziendali, il costo medio è di circa \$13 per sviluppatore per giorno attivo e \$150-250 per sviluppatore al mese, con costi che rimangono al di sotto di \$30 per giorno attivo per il 90% degli utenti. Per stimare la spesa per il tuo team, inizia con un piccolo gruppo pilota e utilizza gli strumenti di tracciamento di seguito per stabilire una baseline prima di un rollout più ampio.

12 12 

18 18 

19> [!NOTE]19> [!NOTE]

20>20>

21> Il blocco Session in `/usage` mostra l'utilizzo dei token API ed è destinato agli utenti API. I sottoscrittori di Claude Max e Pro hanno l'utilizzo incluso nel loro abbonamento, quindi la cifra del costo della sessione non è rilevante per scopi di fatturazione. I sottoscrittori vedono barre di utilizzo del piano, statistiche di attività e una suddivisione dell'utilizzo sulla stessa schermata.21> Il blocco Session in `/usage` mostra l'utilizzo dei token API ed è destinato agli utenti API. I sottoscrittori di Claude Pro, Max e Ultra hanno l'utilizzo incluso nel loro abbonamento, quindi la cifra del costo della sessione non è rilevante per scopi di fatturazione. I sottoscrittori vedono barre di utilizzo del piano, statistiche di attività e una suddivisione dell'utilizzo sulla stessa schermata.

22 22 

23Il blocco Session in cima a `/usage` mostra statistiche dettagliate sull'utilizzo dei token per la tua sessione attuale. Claude Code calcola la cifra in dollari localmente dai conteggi dei token al prezzo di listino, a meno che non sia in vigore una tabella [`modelPricing`](https://code.claude.com/docs/it/settings-reference#modelpricing). Un amministratore ne imposta una nelle impostazioni gestite della tua organizzazione in modo che la cifra utilizzi le tue tariffe contrattuali, e mentre una tabella è in vigore la riga `Total cost` riporta la nota `at your organization's configured rates`. La cifra è una stima, quindi per la fatturazione autorevole vedi la pagina Usage nella [Claude Console](https://platform.claude.com/usage).23Il blocco Session in cima a `/usage` mostra statistiche dettagliate sull'utilizzo dei token per la tua sessione attuale. Claude Code calcola la cifra in dollari localmente dai conteggi dei token al prezzo di listino, a meno che non sia in vigore una tabella [`modelPricing`](https://code.claude.com/docs/it/settings-reference#modelpricing). Un amministratore ne imposta una nelle impostazioni gestite della tua organizzazione in modo che la cifra utilizzi le tue tariffe contrattuali, e mentre una tabella è in vigore la riga `Total cost` riporta la nota `at your organization's configured rates`. La cifra è una stima, quindi per la fatturazione autorevole vedi la pagina Usage nella [Claude Console](https://platform.claude.com/usage).

24 24 

55 55 

56#### Suddivisione dell'utilizzo del piano56#### Suddivisione dell'utilizzo del piano

57 57 

58Su un piano Pro, Max, Team o Enterprise, `/usage` mostra anche una suddivisione di ciò che conta rispetto ai limiti del tuo piano, con delle raccomandazioni:58Su un piano Pro, Max, Ultra, Team o Enterprise, `/usage` mostra anche una suddivisione di ciò che conta rispetto ai limiti del tuo piano, con delle raccomandazioni:

59 59 

60* **Attribution**: utilizzo recente attribuito a skills, subagent, plugin e singoli server MCP, ciascuno mostrato come percentuale del totale. La quota di un server MCP conta solo le richieste che hanno consumato uno dei risultati dei suoi strumenti. Prima della v2.1.222, dopo una chiamata a un server MCP, Claude Code attribuiva ogni richiesta successiva a quel server, sovrastimando la sua quota.60* **Attribution**: utilizzo recente attribuito a skills, subagent, plugin e singoli server MCP, ciascuno mostrato come percentuale del totale. La quota di un server MCP conta solo le richieste che hanno consumato uno dei risultati dei suoi strumenti. Prima della v2.1.222, dopo una chiamata a un server MCP, Claude Code attribuiva ogni richiesta successiva a quel server, sovrastimando la sua quota.

61* **Recommendations**: modifiche suggerite, una per riga. Ogni riga inizia con una quota del tuo utilizzo recente, almeno il 10%, come in `25% Trim ~/code/api/CLAUDE.md · 49k tokens per request`.61* **Recommendations**: modifiche suggerite, una per riga. Ogni riga inizia con una quota del tuo utilizzo recente, almeno il 10%, come in `25% Trim ~/code/api/CLAUDE.md · 49k tokens per request`.

92 92 

93`/usage` mostra anche una riga di crediti di utilizzo mentre i [crediti di utilizzo](#add-usage-credits-to-your-subscription) sono attivi. Ciò che la riga mostra dipende dal tuo piano:93`/usage` mostra anche una riga di crediti di utilizzo mentre i [crediti di utilizzo](#add-usage-credits-to-your-subscription) sono attivi. Ciò che la riga mostra dipende dal tuo piano:

94 94 

95* **Pro e Max**: la tua spesa per il mese corrente, misurata rispetto al tuo limite di spesa mensile quando ne hai impostato uno. Quando non hai impostato un limite, la riga mostra `Unlimited` e nessuna cifra di spesa.95* **Pro, Max e Ultra**: la tua spesa per il mese corrente, misurata rispetto al tuo limite di spesa mensile quando ne hai impostato uno. Quando non hai impostato un limite, la riga mostra `Unlimited` e nessuna cifra di spesa.

96* **Team e Enterprise**: la tua spesa per il mese corrente, misurata rispetto a qualsiasi [limite impostato dalla tua organizzazione](#claude-for-teams-and-enterprise) che si applica a te. Un limite che copre l'intera organizzazione non appare nella riga. Quando non hai un limite tuo, la riga mostra la tua spesa senza limite accanto. Mentre i crediti di utilizzo sono disattivati per te, `/usage` non mostra alcuna riga di crediti di utilizzo.96* **Team e Enterprise**: la tua spesa per il mese corrente, misurata rispetto a qualsiasi [limite impostato dalla tua organizzazione](#claude-for-teams-and-enterprise) che si applica a te. Un limite che copre l'intera organizzazione non appare nella riga. Quando non hai un limite tuo, la riga mostra la tua spesa senza limite accanto. Mentre i crediti di utilizzo sono disattivati per te, `/usage` non mostra alcuna riga di crediti di utilizzo.

97 97 

98Quando hai un limite di spesa, la riga appare non appena i crediti di utilizzo sono attivi e mostra 0% fino a quando non spendi per la prima volta i crediti di utilizzo. Prima della v2.1.236, `/usage` mostrava la riga solo su piani Pro e Max, e una riga con un limite di spesa rimaneva nascosta fino a quando non avevi speso qualcosa.98Quando hai un limite di spesa, la riga appare non appena i crediti di utilizzo sono attivi e mostra 0% fino a quando non spendi per la prima volta i crediti di utilizzo. Prima della v2.1.236, `/usage` mostrava la riga solo su piani Pro, Max e Ultra, e una riga con un limite di spesa rimaneva nascosta fino a quando non avevi speso qualcosa.

99 99 

100#### Quando la richiesta di utilizzo non riesce100#### Quando la richiesta di utilizzo non riesce

101 101 

130 130 

131| Il tuo ruolo | Cosa fa `/usage-credits` |131| Il tuo ruolo | Cosa fa `/usage-credits` |

132| :- | :- |132| :- | :- |

133| Sottoscrittore Pro o Max | Apre [**Settings > Usage**](https://claude.ai/settings/usage) su claude.ai nel browser. Nella sua sezione **Usage credits** puoi attivare o disattivare i crediti di utilizzo e controllare il saldo dei crediti, la spesa di questo mese e il tuo limite di spesa mensile |133| Sottoscrittore Pro, Max o Ultra | Apre [**Settings > Usage**](https://claude.ai/settings/usage) su claude.ai nel browser. Nella sua sezione **Usage credits** puoi attivare o disattivare i crediti di utilizzo e controllare il saldo dei crediti, la spesa di questo mese e il tuo limite di spesa mensile |

134| Membro Team o Enterprise con accesso alla fatturazione | Apre le impostazioni di utilizzo della tua organizzazione, [**Organization settings > Usage**](https://claude.ai/admin-settings/usage), nel browser |134| Membro Team o Enterprise con accesso alla fatturazione | Apre le impostazioni di utilizzo della tua organizzazione, [**Organization settings > Usage**](https://claude.ai/admin-settings/usage), nel browser |

135| Membro Team o Enterprise senza accesso alla fatturazione | Ti chiede di confermare, quindi invia una richiesta agli amministratori della tua organizzazione. Prima della v2.1.211, Claude Code ha inviato la richiesta senza un passaggio di conferma |135| Membro Team o Enterprise senza accesso alla fatturazione | Ti chiede di confermare, quindi invia una richiesta agli amministratori della tua organizzazione. Prima della v2.1.211, Claude Code ha inviato la richiesta senza un passaggio di conferma |

136 136 

144 144 

145I controlli che hai a disposizione dipendono da come la tua organizzazione accede a Claude Code: un piano Claude for Teams o Enterprise, la Claude Console, o un provider cloud. Nei piani Teams e Enterprise, l'utilizzo viene prelevato dall'indennità di posto di ogni membro. Nella Console e presso i provider cloud, l'utilizzo viene fatturato per token alla tua organizzazione. Se la tua organizzazione mescola metodi di accesso, ogni sviluppatore viene misurato in base a quello con cui si è autenticato.145I controlli che hai a disposizione dipendono da come la tua organizzazione accede a Claude Code: un piano Claude for Teams o Enterprise, la Claude Console, o un provider cloud. Nei piani Teams e Enterprise, l'utilizzo viene prelevato dall'indennità di posto di ogni membro. Nella Console e presso i provider cloud, l'utilizzo viene fatturato per token alla tua organizzazione. Se la tua organizzazione mescola metodi di accesso, ogni sviluppatore viene misurato in base a quello con cui si è autenticato.

146 146 

147La tabella mappa ogni configurazione a dove vedi la spesa, dove la limiti, e come estrai i numeri per utente. Su un piano individuale Pro o Max non hai un'organizzazione da gestire, quindi traccia il tuo utilizzo di crediti di spesa, incluso [fast mode](https://code.claude.com/docs/it/fast-mode.md#see-where-fast-mode-spend-appears), in [Aggiungi crediti di utilizzo al tuo abbonamento](#add-usage-credits-to-your-subscription).147La tabella mappa ogni configurazione a dove vedi la spesa, dove la limiti, e come estrai i numeri per utente. Su un piano individuale Pro, Max o Ultra non hai un'organizzazione da gestire, quindi traccia la tua spesa in crediti di utilizzo, inclusa la [modalità veloce](https://code.claude.com/docs/it/fast-mode.md#see-where-fast-mode-spend-appears), in [Aggiungi crediti di utilizzo al tuo abbonamento](#add-usage-credits-to-your-subscription).

148 148 

149| La tua configurazione | Visualizza spesa | Limita spesa | Rapporto per utente |149| La tua configurazione | Visualizza spesa | Limita spesa | Rapporto per utente |

150| :- | :- | :- | :- |150| :- | :- | :- | :- |

294 294 

295Ad esempio, questo hook PreToolUse filtra l'output del test per mostrare solo i fallimenti:295Ad esempio, questo hook PreToolUse filtra l'output del test per mostrare solo i fallimenti:

296 296 

297**settings.json**297> [tab] settings.json

298 298>

299Aggiungi questo al tuo [settings.json](https://code.claude.com/docs/it/settings.md#where-settings-live) per eseguire l'hook prima di ogni comando Bash:299> Aggiungi questo al tuo [settings.json](https://code.claude.com/docs/it/settings.md#where-settings-live) per eseguire l'hook prima di ogni comando Bash:

300 300>

301```json theme={null}301> ```json theme={null}

302{302> {

303 "hooks": {303> "hooks": {

304 "PreToolUse": [304> "PreToolUse": [

305 {305> {

306 "matcher": "Bash",306> "matcher": "Bash",

307 "hooks": [307> "hooks": [

308 {308> {

309 "type": "command",309> "type": "command",

310 "command": "~/.claude/hooks/filter-test-output.sh"310> "command": "~/.claude/hooks/filter-test-output.sh"

311 }311> }

312 ]312> ]

313 }313> }

314 ]314> ]

315 }315> }

316}316> }

317```317> ```

318 318 

319**filter-test-output.sh**319> [tab] filter-test-output.sh

320 320>

321L'hook chiama questo script. Crea la cartella con `mkdir -p ~/.claude/hooks`, salva lo script sottostante come `~/.claude/hooks/filter-test-output.sh` e rendilo eseguibile con `chmod +x ~/.claude/hooks/filter-test-output.sh`. Controlla se il comando è un test runner e lo modifica per mostrare solo i fallimenti:321> L'hook chiama questo script. Crea la cartella con `mkdir -p ~/.claude/hooks`, salva lo script sottostante come `~/.claude/hooks/filter-test-output.sh` e rendilo eseguibile con `chmod +x ~/.claude/hooks/filter-test-output.sh`. Controlla se il comando è un test runner e lo modifica per mostrare solo i fallimenti:

322 322>

323```bash theme={null}323> ```bash theme={null}

324#!/bin/bash324> #!/bin/bash

325input=$(cat)325> input=$(cat)

326cmd=$(echo "$input" | jq -r '.tool_input.command')326> cmd=$(echo "$input" | jq -r '.tool_input.command')

327 327>

328# If running tests, filter to show only failures328> # If running tests, filter to show only failures

329pattern='^(npm test|pytest|go test)( [^;&|<>`$#\\[:cntrl:]]*)?$'329> pattern='^(npm test|pytest|go test)( [^;&|<>`$#\\[:cntrl:]]*)?$'

330if [[ "$cmd" =~ $pattern ]]; then330> if [[ "$cmd" =~ $pattern ]]; then

331 filtered_cmd="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100"331> filtered_cmd="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100"

332 echo "$input" | jq --arg filtered "$filtered_cmd" \332> echo "$input" | jq --arg filtered "$filtered_cmd" \

333 '{hookSpecificOutput: {hookEventName: "PreToolUse", updatedInput: (.tool_input + {command: $filtered})}}'333> '{hookSpecificOutput: {hookEventName: "PreToolUse", updatedInput: (.tool_input + {command: $filtered})}}'

334else334> else

335 echo "{}"335> echo "{}"

336fi336> fi

337```337> ```

338 338 

339Per verificare la configurazione, esegui `/hooks` e controlla che l'hook appaia sotto PreToolUse. Puoi anche avviare Claude Code con `claude --debug-file ./claude-debug.txt` e chiedere a Claude di eseguire `npm test`. Quando l'hook riscrive il comando, quel file di log contiene una riga `modified tool input keys` che elenca `command` e gli altri campi di input Bash.339Per verificare la configurazione, esegui `/hooks` e controlla che l'hook appaia sotto PreToolUse. Puoi anche avviare Claude Code con `claude --debug-file ./claude-debug.txt` e chiedere a Claude di eseguire `npm test`. Quando l'hook riscrive il comando, quel file di log contiene una riga `modified tool input keys` che elenca `command` e gli altri campi di input Bash.

340 340 

392* **Agent teammates**: ogni [teammate](#agent-team-token-costs) attivo continua a consumare token fino a quando non esce392* **Agent teammates**: ogni [teammate](#agent-team-token-costs) attivo continua a consumare token fino a quando non esce

393* **Compaction**: `/compact` legge la conversazione che riassume, quindi [compacting a large context](https://code.claude.com/docs/it/prompt-caching.md#compacting-the-conversation) è essa stessa una richiesta grande. Quando volete un nuovo inizio invece della continuità, `/clear` non costa nulla393* **Compaction**: `/compact` legge la conversazione che riassume, quindi [compacting a large context](https://code.claude.com/docs/it/prompt-caching.md#compacting-the-conversation) è essa stessa una richiesta grande. Quando volete un nuovo inizio invece della continuità, `/clear` non costa nulla

394 394 

395Su un piano Pro, Max, Team o Enterprise, la [ripartizione di `/usage`](#plan-usage-breakdown) consiglia una modifica per i comportamenti che rappresentano il 10% o più del tuo utilizzo recente, come il contesto lungo o i cache miss.395Per capire cosa modificare su un piano Pro, Max, Ultra, Team o Enterprise, esegui [`/usage`](#plan-usage-breakdown) nel prompt di Claude Code. La sua ripartizione consiglia una modifica per i comportamenti che rappresentano il 10% o più del tuo utilizzo recente. Tra questi comportamenti ci sono il contesto lungo e i cache miss.

396 396 

397## Comprensione dei cambiamenti nel comportamento di Claude Code397## Comprensione dei cambiamenti nel comportamento di Claude Code

398 398 

400 400 

401Per domande sulla fatturazione relative al tuo account specifico, contatta il supporto Anthropic tramite il messenger integrato nel prodotto:401Per domande sulla fatturazione relative al tuo account specifico, contatta il supporto Anthropic tramite il messenger integrato nel prodotto:

402 402 

403* **Piani di abbonamento** (Pro, Max, Team, Enterprise): accedi a [claude.ai](https://claude.ai), fai clic sulle tue iniziali in basso a sinistra e seleziona **Ottieni aiuto**403* **Piani di abbonamento** (Pro, Max, Ultra, Team, Enterprise): accedi a [claude.ai](https://claude.ai), fai clic sulle tue iniziali in basso a sinistra e seleziona **Ottieni aiuto**

404* **Fatturazione Console (API)**: accedi a [platform.claude.com](https://platform.claude.com), fai clic sulle tue iniziali e seleziona **Ottieni aiuto**404* **Fatturazione Console (API)**: accedi a [platform.claude.com](https://platform.claude.com), fai clic sulle tue iniziali e seleziona **Ottieni aiuto**

405 405 

406Consulta [Come ottenere supporto](https://support.claude.com/en/articles/9015913-how-to-get-support) per il flusso completo, incluso chi può raggiungere un agente umano per ogni piano.406Consulta [Come ottenere supporto](https://support.claude.com/en/articles/9015913-how-to-get-support) per il flusso completo, incluso chi può raggiungere un agente umano per ogni piano.

data-usage.md +6 −6

Details

10 10 

11### Politica di addestramento sui dati11### Politica di addestramento sui dati

12 12 

13**Utenti consumer (piani Free, Pro e Max)**:13**Utenti consumer (piani Free, Pro, Max e Ultra)**:

14Ti diamo la possibilità di scegliere se consentire l'uso dei tuoi dati per migliorare i futuri modelli Claude. Addestreremo nuovi modelli utilizzando i dati degli account Free, Pro e Max quando questa impostazione è attiva (anche quando usi Claude Code da questi account).14Ti diamo la possibilità di scegliere se consentire l'uso dei tuoi dati per migliorare i futuri modelli Claude. Addestreremo nuovi modelli utilizzando i dati degli account Free, Pro, Max e Ultra quando questa impostazione è attiva (anche quando usi Claude Code da questi account).

15 15 

16**Utenti commerciali**: (piani Team ed Enterprise, API, piattaforme di terze parti e Claude Gov) mantengono le politiche esistenti: Anthropic non addestra modelli generativi utilizzando codice o prompt inviati a Claude Code secondo i termini commerciali, a meno che il cliente non abbia scelto di fornirci i propri dati per il miglioramento dei modelli (ad esempio, il [Developer Partner Program](https://support.claude.com/en/articles/11174108-about-the-development-partner-program)).16**Utenti commerciali**: (piani Team ed Enterprise, API, piattaforme di terze parti e Claude Gov) mantengono le politiche esistenti: Anthropic non addestra modelli generativi utilizzando codice o prompt inviati a Claude Code secondo i termini commerciali, a meno che il cliente non abbia scelto di fornirci i propri dati per il miglioramento dei modelli (ad esempio, il [Developer Partner Program](https://support.claude.com/en/articles/11174108-about-the-development-partner-program)).

17 17 

43 43 

44Anthropic conserva i dati di Claude Code in base al tipo di account e alle tue preferenze.44Anthropic conserva i dati di Claude Code in base al tipo di account e alle tue preferenze.

45 45 

46**Utenti consumer (piani Free, Pro e Max)**:46**Utenti consumer (piani Free, Pro, Max e Ultra)**:

47 47 

48* Utenti che consentono l'uso dei dati per il miglioramento dei modelli: periodo di conservazione di 5 anni per supportare lo sviluppo dei modelli e i miglioramenti della sicurezza48* Utenti che consentono l'uso dei dati per il miglioramento dei modelli: periodo di conservazione di 5 anni per supportare lo sviluppo dei modelli e i miglioramenti della sicurezza

49* Utenti che non consentono l'uso dei dati per il miglioramento dei modelli: periodo di conservazione di 30 giorni49* Utenti che non consentono l'uso dei dati per il miglioramento dei modelli: periodo di conservazione di 30 giorni

61 61 

62Scopri di più sulle pratiche di conservazione dei dati nel nostro [Privacy Center](https://privacy.anthropic.com/).62Scopri di più sulle pratiche di conservazione dei dati nel nostro [Privacy Center](https://privacy.anthropic.com/).

63 63 

64Per tutti i dettagli, consulta i nostri [Termini di servizio commerciali](https://www.anthropic.com/legal/commercial-terms) (per gli utenti Team, Enterprise e API) o i [Termini per i consumatori](https://www.anthropic.com/legal/consumer-terms) (per gli utenti Free, Pro e Max) e l'[Informativa sulla privacy](https://www.anthropic.com/legal/privacy).64Per tutti i dettagli, consulta i nostri [Termini di servizio commerciali](https://www.anthropic.com/legal/commercial-terms) (per gli utenti Team, Enterprise e API) o i [Termini per i consumatori](https://www.anthropic.com/legal/consumer-terms) (per gli utenti Free, Pro, Max e Ultra) e l'[Informativa sulla privacy](https://www.anthropic.com/legal/privacy).

65 65 

66## Accesso ai dati66## Accesso ai dati

67 67 

107 107 

108La registrazione degli errori è attiva solo quando si applicano tutte queste condizioni:108La registrazione degli errori è attiva solo quando si applicano tutte queste condizioni:

109 109 

110* vi accedete con un abbonamento Claude Pro o Max110* accedi con un abbonamento Claude Pro, Max o Ultra

111* state eseguendo Claude Code v2.1.198 o versione successiva111* state eseguendo Claude Code v2.1.198 o versione successiva

112* vi state connettendo direttamente all'API Claude112* vi state connettendo direttamente all'API Claude

113* la vostra organizzazione non ha un accordo di conservazione dati zero o HIPAA113* la vostra organizzazione non ha un accordo di conservazione dati zero o HIPAA

123| Servizio | Claude API | Google Cloud's Agent Platform API | Amazon Bedrock API | Microsoft Foundry API | Claude Platform su AWS |123| Servizio | Claude API | Google Cloud's Agent Platform API | Amazon Bedrock API | Microsoft Foundry API | Claude Platform su AWS |

124| - | - | - | - | - | - |124| - | - | - | - | - | - |

125| **Metriche** | Attivo per impostazione predefinita. `DISABLE_TELEMETRY=1` per disabilitare. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |125| **Metriche** | Attivo per impostazione predefinita. `DISABLE_TELEMETRY=1` per disabilitare. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |

126| **Segnalazioni di errore** | Attivo per accessi Pro e Max su v2.1.198+, altrimenti disattivo. `DISABLE_ERROR_REPORTING=1` per disabilitare. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |126| **Segnalazioni di errore** | Attivo per accessi Pro, Max e Ultra su v2.1.198+, altrimenti disattivo. `DISABLE_ERROR_REPORTING=1` per disabilitare. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |

127| **Claude API (report `/feedback`)** | Attivo per impostazione predefinita. `DISABLE_FEEDBACK_COMMAND=1` per disabilitare. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |127| **Claude API (report `/feedback`)** | Attivo per impostazione predefinita. `DISABLE_FEEDBACK_COMMAND=1` per disabilitare. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_VERTEX` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_BEDROCK` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_FOUNDRY` deve essere 1. | Disattivo per impostazione predefinita. `CLAUDE_CODE_USE_ANTHROPIC_AWS` deve essere 1. |

128| **Sondaggi sulla qualità della sessione** | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. |128| **Sondaggi sulla qualità della sessione** | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. | Attivo per impostazione predefinita. `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` per disabilitare. |

129| **Controllo di sicurezza del dominio WebFetch** | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. |129| **Controllo di sicurezza del dominio WebFetch** | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. | Attivo per impostazione predefinita. `skipWebFetchPreflight: true` in [settings](https://code.claude.com/docs/it/settings.md) per disabilitare. |

Details

95 95 

96Nella tua shell, senza alcuna sessione di Claude Code in esecuzione, crea la directory e spostati al suo interno:96Nella tua shell, senza alcuna sessione di Claude Code in esecuzione, crea la directory e spostati al suo interno:

97 97 

98**Bash o Zsh**98> [tab] Bash o Zsh

99 99>

100```bash theme={null}100> ```bash theme={null}

101mkdir -p ~/claude-clean/empty && cd ~/claude-clean/empty101> mkdir -p ~/claude-clean/empty && cd ~/claude-clean/empty

102```102> ```

103 

104**PowerShell**

105 103 

106```powershell theme={null}104> [tab] PowerShell

107New-Item -ItemType Directory -Force "$HOME/claude-clean/empty" | Out-Null105>

108Set-Location "$HOME/claude-clean/empty"106> ```powershell theme={null}

109```107> New-Item -ItemType Directory -Force "$HOME/claude-clean/empty" | Out-Null

108> Set-Location "$HOME/claude-clean/empty"

109> ```

110 110 

111**2. Avvia Claude Code con una directory di configurazione pulita**111**2. Avvia Claude Code con una directory di configurazione pulita**

112 112 

113Dalla stessa shell, imposta [`CLAUDE_CONFIG_DIR`](https://code.claude.com/docs/it/env-vars) su una nuova directory al posto di `~/.claude` e passa [`--setting-sources user`](https://code.claude.com/docs/it/cli-reference#cli-flags) per disattivare la configurazione del progetto, come `.claude/settings.json`, `CLAUDE.md` e `.mcp.json`:113Dalla stessa shell, imposta [`CLAUDE_CONFIG_DIR`](https://code.claude.com/docs/it/env-vars) su una nuova directory al posto di `~/.claude` e passa [`--setting-sources user`](https://code.claude.com/docs/it/cli-reference#cli-flags) per disattivare la configurazione del progetto, come `.claude/settings.json`, `CLAUDE.md` e `.mcp.json`:

114 114 

115**Bash o Zsh**115> [tab] Bash o Zsh

116 116>

117La variabile si applica solo a questo avvio.117> La variabile si applica solo a questo avvio.

118 118>

119```bash theme={null}119> ```bash theme={null}

120CLAUDE_CONFIG_DIR=~/claude-clean/config claude --setting-sources user120> CLAUDE_CONFIG_DIR=~/claude-clean/config claude --setting-sources user

121```121> ```

122 

123**PowerShell**

124 

125La variabile resta impostata per il resto di questa sessione di PowerShell, quindi i successivi avvii di `claude` nella stessa finestra continuano a usare la directory pulita. Per tornare alla tua directory abituale, esegui `Remove-Item Env:CLAUDE_CONFIG_DIR` prima dell'avvio successivo.

126 122 

127```powershell theme={null}123> [tab] PowerShell

128$env:CLAUDE_CONFIG_DIR = "$HOME/claude-clean/config"124>

129claude --setting-sources user125> La variabile resta impostata per il resto di questa sessione di PowerShell, quindi i successivi avvii di `claude` nella stessa finestra continuano a usare la directory pulita. Per tornare alla tua directory abituale, esegui `Remove-Item Env:CLAUDE_CONFIG_DIR` prima dell'avvio successivo.

130```126>

127> ```powershell theme={null}

128> $env:CLAUDE_CONFIG_DIR = "$HOME/claude-clean/config"

129> claude --setting-sources user

130> ```

131 131 

132Al primo avvio, ripercorri le schermate di configurazione iniziale, segno che la directory di configurazione pulita è in vigore. Le impostazioni gestite si applicano comunque, e i [connettori](https://code.claude.com/docs/it/mcp.md#use-mcp-servers-from-claude-ai) vengono comunque caricati se accedi con un account claude.ai.132Al primo avvio, ripercorri le schermate di configurazione iniziale, segno che la directory di configurazione pulita è in vigore. Le impostazioni gestite si applicano comunque, e i [connettori](https://code.claude.com/docs/it/mcp.md#use-mcp-servers-from-claude-ai) vengono comunque caricati se accedi con un account claude.ai.

133 133 

desktop.md +122 −92

Details

8 8 

9Nell'app Claude Desktop, Claude Code è la scheda **Code**. L'app include anche la chat e [Cowork](https://claude.com/product/cowork), che gestisce Dispatch e il lavoro agentico più lungo. Questa pagina è il riferimento per la scheda Code.9Nell'app Claude Desktop, Claude Code è la scheda **Code**. L'app include anche la chat e [Cowork](https://claude.com/product/cowork), che gestisce Dispatch e il lavoro agentico più lungo. Questa pagina è il riferimento per la scheda Code.

10 10 

11> **[Scarica per macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect?utm_source=claude_code\&utm_medium=docs)**11> [card] [Scarica per macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect?utm_source=claude_code\&utm_medium=docs)

12>12>

13> Build universale per Intel e Apple Silicon13> Build universale per Intel e Apple Silicon

14 14 

15> **[Scarica per Windows](https://claude.ai/api/desktop/win32/x64/setup/latest/redirect?utm_source=claude_code\&utm_medium=docs)**15> [card] [Scarica per Windows](https://claude.ai/api/desktop/win32/x64/setup/latest/redirect?utm_source=claude_code\&utm_medium=docs)

16>16>

17> Per processori x6417> Per processori x64

18 18 

19> **[Ottieni Claude per Linux (beta)](https://code.claude.com/docs/it/desktop-linux.md)**19> [card] [Ottieni Claude per Linux (beta)](https://code.claude.com/docs/it/desktop-linux.md)

20>20>

21> apt o .deb per Ubuntu e Debian21> apt o .deb per Ubuntu e Debian

22 22 

92| **Accept edits** | `acceptEdits` | Claude accetta automaticamente le modifiche ai file e i comandi comuni del filesystem come `mkdir`, `touch` e `mv`, ma chiede comunque prima di eseguire altri comandi del terminale. Usala quando ti fidi delle modifiche ai file e vuoi iterare più velocemente. |92| **Accept edits** | `acceptEdits` | Claude accetta automaticamente le modifiche ai file e i comandi comuni del filesystem come `mkdir`, `touch` e `mv`, ma chiede comunque prima di eseguire altri comandi del terminale. Usala quando ti fidi delle modifiche ai file e vuoi iterare più velocemente. |

93| **Plan** | `plan` | Claude legge i file ed esegue comandi per esplorare, quindi propone un piano senza modificare il tuo codice sorgente. Ideale per attività complesse in cui vuoi prima rivedere l'approccio. |93| **Plan** | `plan` | Claude legge i file ed esegue comandi per esplorare, quindi propone un piano senza modificare il tuo codice sorgente. Ideale per attività complesse in cui vuoi prima rivedere l'approccio. |

94| **Auto** | `auto` | Claude lavora senza richieste di permesso abituali; prima che vengano eseguite azioni come comandi shell e richieste di rete, un classificatore in background verifica che siano in linea con la tua richiesta. Compare quando [la modalità auto è disponibile](#auto-mode-availability); non esiste un interruttore separato in Settings. |94| **Auto** | `auto` | Claude lavora senza richieste di permesso abituali; prima che vengano eseguite azioni come comandi shell e richieste di rete, un classificatore in background verifica che siano in linea con la tua richiesta. Compare quando [la modalità auto è disponibile](#auto-mode-availability); non esiste un interruttore separato in Settings. |

95| **Bypass permissions** | `bypassPermissions` | Claude lavora senza richieste di permesso, tranne per le [azioni che nessuna modalità approva automaticamente](https://code.claude.com/docs/it/permission-modes.md#actions-no-mode-auto-approves), i classificatori di sicurezza quando Claude [agisce su siti esterni](#browse-external-sites), o azioni del desktop come eliminare una sessione, ma non [archiviarla](#work-across-sessions). Equivale a `--dangerously-skip-permissions` nella CLI. Nei piani Pro e Max, abilita "Allow bypass permissions mode" in **Settings > Code** o **Settings > Claude Code**. Nei piani Team ed Enterprise non esiste un interruttore in Settings e la controlla invece la policy dell'organizzazione. Usala solo in container o VM isolati. |95| **Bypass permissions** | `bypassPermissions` | Claude lavora senza richieste di permesso, tranne per le [azioni che nessuna modalità approva automaticamente](https://code.claude.com/docs/it/permission-modes.md#actions-no-mode-auto-approves), i classificatori di sicurezza quando Claude [agisce su siti esterni](#browse-external-sites), o azioni del desktop come eliminare una sessione, ma non [archiviarla](#work-across-sessions). Equivale a `--dangerously-skip-permissions` nella CLI. Nei piani Pro, Max e Ultra, abilita "Allow bypass permissions mode" in **Settings > Code** o **Settings > Claude Code**. Nei piani Team ed Enterprise non esiste un interruttore in Settings e la controlla invece la policy dell'organizzazione. Usala solo in container o VM isolati. |

96 96 

97Le versioni precedenti della scheda Code chiamavano queste modalità Ask permissions, Auto accept edits e Plan mode.97Le versioni precedenti della scheda Code chiamavano queste modalità Ask permissions, Auto accept edits e Plan mode.

98 98 

320 320 

321> [!NOTE]321> [!NOTE]

322>322>

323> L'utilizzo del computer è un'anteprima di ricerca su macOS e Windows che richiede un piano Pro o Max. Non è disponibile su piani Team o Enterprise. L'app Claude Desktop deve essere in esecuzione. Su macOS, l'utilizzo del computer richiede macOS 14 o versioni successive.323> L'utilizzo del computer è un'anteprima di ricerca su macOS e Windows che richiede un piano Pro, Max o Ultra. Non è disponibile su piani Team o Enterprise. L'app Claude Desktop deve essere in esecuzione. Su macOS, l'utilizzo del computer richiede macOS 14 o versioni successive.

324 324 

325L'utilizzo del computer è disabilitato per impostazione predefinita. [Abilitalo in Impostazioni](#enable-computer-use) prima che Claude possa controllare lo schermo. Su macOS, devi anche concedere i permessi di Accessibilità e Registrazione dello schermo.325L'utilizzo del computer è disabilitato per impostazione predefinita. [Abilitalo in Impostazioni](#enable-computer-use) prima che Claude possa controllare lo schermo. Su macOS, devi anche concedere i permessi di Accessibilità e Registrazione dello schermo.

326 326 

362* **Windows**: l'interruttore ha effetto immediatamente e la configurazione è completa362* **Windows**: l'interruttore ha effetto immediatamente e la configurazione è completa

363* **macOS**: continua al passaggio successivo363* **macOS**: continua al passaggio successivo

364 364 

365Se non vedi l'interruttore, conferma che sei su macOS o Windows con un piano Pro o Max, quindi aggiorna e riavvia l'app.365Se non vedi l'interruttore, conferma che sei su macOS o Windows con un piano Pro, Max o Ultra, quindi aggiorna e riavvia l'app.

366 366 

367**3. Concedi i permessi macOS**367**3. Concedi i permessi macOS**

368 368 

562 562 

563#### Configura Dispatch563#### Configura Dispatch

564 564 

565Per la configurazione, l'accoppiamento e le impostazioni di Dispatch, vedi l'[articolo di aiuto di Dispatch](https://support.claude.com/en/articles/13947068). Dispatch richiede un piano Pro o Max e non è disponibile su piani Team o Enterprise.565* **Piani**: Dispatch richiede un piano Pro, Max o Ultra e non è disponibile sui piani Team o Enterprise

566* **Configurazione, accoppiamento e impostazioni di Dispatch**: vedi l'[articolo di aiuto di Dispatch](https://support.claude.com/en/articles/13947068)

566 567 

567Dispatch è uno dei diversi modi per lavorare con Claude quando sei lontano dal tuo terminale. Per un confronto con le altre opzioni, vedi [Piattaforme e integrazioni](https://code.claude.com/docs/it/platforms.md#work-when-you-are-away-from-your-terminal).568Dispatch è uno dei diversi modi per lavorare con Claude quando sei lontano dal tuo terminale. Per un confronto con le altre opzioni, vedi [Piattaforme e integrazioni](https://code.claude.com/docs/it/platforms.md#work-when-you-are-away-from-your-terminal).

568 569 

738 739 

739Queste configurazioni mostrano configurazioni comuni per diversi tipi di progetto:740Queste configurazioni mostrano configurazioni comuni per diversi tipi di progetto:

740 741 

741**Next.js**742> [tab] Next.js

742 743>

743Questa configurazione esegue un'app Next.js usando Yarn sulla porta 3000:744> Questa configurazione esegue un'app Next.js usando Yarn sulla porta 3000:

744 745>

745```json theme={null}746> ```json theme={null}

746{747> {

747 "version": "0.0.1",748> "version": "0.0.1",

748 "configurations": [749> "configurations": [

749 {750> {

750 "name": "web",751> "name": "web",

751 "runtimeExecutable": "yarn",752> "runtimeExecutable": "yarn",

752 "runtimeArgs": ["dev"],753> "runtimeArgs": ["dev"],

753 "port": 3000754> "port": 3000

754 }755> }

755 ]756> ]

756}757> }

757```758> ```

758 759 

759**Multiple servers**760> [tab] Multiple servers

760 761>

761Per un monorepo con un frontend e un server API, definisci più configurazioni. Il frontend usa `autoPort: true` in modo che scelga una porta libera se 3000 è occupata, mentre il server API richiede la porta 8080 esattamente:762> Per un monorepo con un frontend e un server API, definisci più configurazioni. Il frontend usa `autoPort: true` in modo che scelga una porta libera se 3000 è occupata, mentre il server API richiede la porta 8080 esattamente:

762 763>

763```json theme={null}764> ```json theme={null}

764{765> {

765 "version": "0.0.1",766> "version": "0.0.1",

766 "configurations": [767> "configurations": [

767 {768> {

768 "name": "frontend",769> "name": "frontend",

769 "runtimeExecutable": "npm",770> "runtimeExecutable": "npm",

770 "runtimeArgs": ["run", "dev"],771> "runtimeArgs": ["run", "dev"],

771 "cwd": "apps/web",772> "cwd": "apps/web",

772 "port": 3000,773> "port": 3000,

773 "autoPort": true774> "autoPort": true

774 },775> },

775 {776> {

776 "name": "api",777> "name": "api",

777 "runtimeExecutable": "npm",778> "runtimeExecutable": "npm",

778 "runtimeArgs": ["run", "start"],779> "runtimeArgs": ["run", "start"],

779 "cwd": "server",780> "cwd": "server",

780 "port": 8080,781> "port": 8080,

781 "env": { "NODE_ENV": "development" },782> "env": { "NODE_ENV": "development" },

782 "autoPort": false783> "autoPort": false

783 }784> }

784 ]785> ]

785}786> }

786```787> ```

787 788 

788**Node.js script**789> [tab] Node.js script

789 790>

790Per eseguire uno script Node.js direttamente invece di usare un comando del gestore di pacchetti, usa il campo `program`:791> Per eseguire uno script Node.js direttamente invece di usare un comando del gestore di pacchetti, usa il campo `program`:

791 792>

792```json theme={null}793> ```json theme={null}

793{794> {

794 "version": "0.0.1",795> "version": "0.0.1",

795 "configurations": [796> "configurations": [

796 {797> {

797 "name": "server",798> "name": "server",

798 "program": "server.js",799> "program": "server.js",

799 "args": ["--verbose"],800> "args": ["--verbose"],

800 "port": 4000801> "port": 4000

801 }802> }

802 ]803> ]

803}804> }

804```805> ```

805 806 

806## Configurazione dell'ambiente807## Configurazione dell'ambiente

807 808 

1327* **Workflow**: Desktop controlla ogni nuovo [workflow](https://code.claude.com/docs/it/workflows.md) prima che venga avviato, quindi mentre Desktop è disconnesso un nuovo workflow attende fino a 10 minuti e poi non riesce1328* **Workflow**: Desktop controlla ogni nuovo [workflow](https://code.claude.com/docs/it/workflows.md) prima che venga avviato, quindi mentre Desktop è disconnesso un nuovo workflow attende fino a 10 minuti e poi non riesce

1328* **Server MCP**: i server MCP che Claude Code avvia sulla macchina remota non passano attraverso Desktop, quindi Claude può ancora chiamare i loro strumenti. I server da `claude_desktop_config.json` rientrano tra questi solo se Desktop non usa il suo [client SSH integrato](#worktree-edits-while-disconnected). Altrimenti, e su [alcune macchine remote Windows](#windows-remote-machines), Claude non può chiamare i loro strumenti mentre Desktop è disconnesso.1329* **Server MCP**: i server MCP che Claude Code avvia sulla macchina remota non passano attraverso Desktop, quindi Claude può ancora chiamare i loro strumenti. I server da `claude_desktop_config.json` rientrano tra questi solo se Desktop non usa il suo [client SSH integrato](#worktree-edits-while-disconnected). Altrimenti, e su [alcune macchine remote Windows](#windows-remote-machines), Claude non può chiamare i loro strumenti mentre Desktop è disconnesso.

1329 1330 

1330> **Quando le modifiche in un worktree continuano a funzionare**1331> [accordion] Quando le modifiche in un worktree continuano a funzionare

1331>1332>

1332> Su una macchina remota Linux o macOS, il controllo non passa attraverso Desktop, quindi le modifiche all'interno del worktree continuano a funzionare mentre Desktop è disconnesso. Prima di Claude Desktop v2.37337.0, questo vale solo su una macchina remota Linux.1333> Su una macchina remota Linux o macOS, il controllo non passa attraverso Desktop, quindi le modifiche all'interno del worktree continuano a funzionare mentre Desktop è disconnesso. Prima di Claude Desktop v2.37337.0, questo vale solo su una macchina remota Linux.

1333>1334>

1368* **Password memorizzata**: anche una password che lasci memorizzare a Desktop funziona senza prompt, ma per un'assenza prolungata è preferibile una chiave detenuta dal tuo agente SSH. Se gli accessi con quella password si interrompono o si bloccano, Desktop può smettere di riconnettersi e attenderti.1369* **Password memorizzata**: anche una password che lasci memorizzare a Desktop funziona senza prompt, ma per un'assenza prolungata è preferibile una chiave detenuta dal tuo agente SSH. Se gli accessi con quella password si interrompono o si bloccano, Desktop può smettere di riconnettersi e attenderti.

1369* **Qualsiasi altro prompt**: se la macchina remota chiede qualcos'altro, ad esempio un codice monouso, puoi ricevere una notifica sul tuo computer. Fai clic sulla notifica, oppure invia un messaggio nella sessione, e Desktop mostra il prompt.1370* **Qualsiasi altro prompt**: se la macchina remota chiede qualcos'altro, ad esempio un codice monouso, puoi ricevere una notifica sul tuo computer. Fai clic sulla notifica, oppure invia un messaggio nella sessione, e Desktop mostra il prompt.

1370 1371 

1371> **Se un jump host chiede un accesso, l'interruzione è lunga, manca dell'output o il processo non c'è più**1372> [accordion] Se un jump host chiede un accesso, l'interruzione è lunga, manca dell'output o il processo non c'è più

1372>1373>

1373> * **Jump host, le notifiche push si interrompono mentre sei via**: questo può accadere con Desktop su macOS o Linux quando nessuno risponde alla richiesta di accesso di un jump host, ad esempio una notifica push su un telefono. Desktop smette quindi di riconnettersi mentre nessuno è al tuo computer. Quando sblocchi o usi il computer, puoi ricevere un'altra notifica push, perché Desktop può riprovare. Dopo tre tentativi senza risposta, attende finché non riprovi o invii un messaggio.1374> * **Jump host, le notifiche push si interrompono mentre sei via**: questo può accadere con Desktop su macOS o Linux quando nessuno risponde alla richiesta di accesso di un jump host, ad esempio una notifica push su un telefono. Desktop smette quindi di riconnettersi mentre nessuno è al tuo computer. Quando sblocchi o usi il computer, puoi ricevere un'altra notifica push, perché Desktop può riprovare. Dopo tre tentativi senza risposta, attende finché non riprovi o invii un messaggio.

1374> * **Jump host, le notifiche push continuano ad arrivare**: dove Desktop non può capire che nessuno risponde, come con Desktop su Windows, continua a tentare finché ha un processo a cui ricollegarsi, che quel processo sia ancora in esecuzione o meno. Puoi ricevere un'altra notifica push a ogni tentativo. Per interrompere i tentativi, chiudi Desktop, il che [può farti perdere l'attività in esecuzione](#reopen-a-session-after-you-quit-desktop).1375> * **Jump host, le notifiche push continuano ad arrivare**: dove Desktop non può capire che nessuno risponde, come con Desktop su Windows, continua a tentare finché ha un processo a cui ricollegarsi, che quel processo sia ancora in esecuzione o meno. Puoi ricevere un'altra notifica push a ogni tentativo. Per interrompere i tentativi, chiudi Desktop, il che [può farti perdere l'attività in esecuzione](#reopen-a-session-after-you-quit-desktop).

1592>1593>

1593> Le connessioni da un comando richiedono Claude Desktop v3.6556.0 o versione successiva su macOS o Linux, con accesso effettuato tramite un account Claude. Gli amministratori possono [distribuire i comandi a un team](#distribute-commands-to-your-team).1594> Le connessioni da un comando richiedono Claude Desktop v3.6556.0 o versione successiva su macOS o Linux, con accesso effettuato tramite un account Claude. Gli amministratori possono [distribuire i comandi a un team](#distribute-commands-to-your-team).

1594 1595 

1595Ogni voce è una connessione, con un host alla volta. Desktop esegue il comando solo quando crei la connessione o [sostituisci il suo host](#replace-the-host), non ogni volta che ti connetti. Per mantenere due macchine contemporaneamente, aggiungi una seconda voce.1596Desktop esegue il comando solo quando crei la connessione o [crei un'altra macchina](#create-another-machine), non ogni volta che ti connetti. Ogni voce è una connessione, che punta all'host che Desktop ha salvato per ultimo dal comando della voce.

1596 1597 

1597> [!WARNING]1598> [!WARNING]

1598>1599>

1599> Desktop non arresta né elimina le macchine. Ciascuna di queste continua a essere in esecuzione, e può continuare a costare denaro, finché non la elimini con il tuo strumento:1600> Desktop non arresta né elimina le macchine. Ciascuna di queste continua a essere in esecuzione, e può continuare a costare denaro, finché non la elimini con il tuo strumento:

1600>1601>

1601> * Un host che hai sostituito1602> * Una macchina a cui una voce puntava prima che tu ne [creassi un'altra](#create-another-machine)

1602> * L'host di una voce che hai rimosso dal file, o di cui hai modificato l'`id`1603> * Le macchine di una voce che hai rimosso dal file, o di cui hai modificato l'`id`

1603> * Una macchina creata dal tuo comando senza che Desktop ne abbia salvato l'host, ad esempio in questi casi:1604> * Una macchina che il tuo comando ha creato senza che Desktop ne salvasse l'host, ad esempio in questi casi:

1604> * Il comando non riesce o esaurisce il tempo1605> * Il comando non riesce o esaurisce il tempo

1605> * Desktop non può usare l'host stampato, un'altra connessione lo usa già, oppure la tua organizzazione non lo consente1606> * Desktop non può usare l'host stampato, un'altra connessione lo usa già, o la tua organizzazione non lo consente

1606> * Mentre il comando è in esecuzione, lo annulli, rimuovi la sua voce, modifichi il suo `command` o `id`, oppure chiudi Desktop1607> * Mentre il comando è in esecuzione, lo annulli, rimuovi la sua voce, modifichi il suo `command` o `id`, o chiudi Desktop

1607 1608 

1608L'esempio seguente aggiunge una connessione denominata Dev box. Se il file non esiste, crealo. Se contiene già delle impostazioni, aggiungi la chiave accanto a esse. Il comando `acme-dev create` rappresenta il tuo strumento, e `~/project` è la cartella che Desktop seleziona su ogni macchina creata dal tuo comando:1609L'esempio seguente aggiunge una connessione denominata Dev box. Se il file non esiste, crealo. Se contiene già delle impostazioni, aggiungi la chiave accanto a esse. Il comando `acme-dev create` rappresenta il tuo strumento, e `~/project` è la cartella che Desktop seleziona su ogni macchina creata dal tuo comando:

1609 1610 

1624 1625 

1625| Campo | Valore |1626| Campo | Valore |

1626| :- | :- |1627| :- | :- |

1627| `id` | Fino a 64 lettere ASCII, cifre, `.`, `_` e `-`, che inizi con una lettera o una cifra. Usa un `id` che nessun'altra voce in `sshHostCommands` o [`sshConfigs`](#pre-configure-ssh-connections-for-your-team) abbia. Desktop conserva l'host della connessione sotto di esso, quindi se lo modifichi, la connessione ricomincia senza host e la vecchia macchina continua a essere in esecuzione. |1628| `id` | Fino a 64 lettere ASCII, cifre, `.`, `_` e `-`, che inizia con una lettera o una cifra. Usa un `id` che nessun'altra voce in `sshHostCommands` o [`sshConfigs`](#pre-configure-ssh-connections-for-your-team) abbia. Desktop conserva l'host della connessione sotto di esso, quindi se lo modifichi, la connessione ricomincia senza host, le sue macchine continuano a essere eseguite e Desktop può [ancora connettersi a esse](#remove-an-entry). |

1628| `name` | Il nome della connessione nel selettore dell'ambiente, fino a 200 caratteri su una riga |1629| `name` | Il nome della connessione nel selettore dell'ambiente, fino a 200 caratteri su una riga |

1629| `command` | Un programma e i suoi argomenti, come descritto in [Scrivere il comando](#write-the-command) |1630| `command` | Un programma e i suoi argomenti, come descritto in [Scrivere il comando](#write-the-command) |

1630| `sshIdentityFile` | Percorso della tua chiave privata, come `~/.ssh/id_ed25519`. Omettilo per usare la tua configurazione SSH o il tuo agente SSH. |1631| `sshIdentityFile` | Percorso della tua chiave privata, come `~/.ssh/id_ed25519`. Omettilo per usare la tua configurazione SSH o il tuo agente SSH. |

1677 1678 

1678Mantieni attivo il controllo delle chiavi host per questi host e mantieni un file `known_hosts` per essi. Se `StrictHostKeyChecking` è `no` o `accept-new` e anche `UserKnownHostsFile` è `/dev/null` o `none`, nulla registra la chiave. Quando il tuo strumento riutilizza poi un nome, puoi connetterti a una macchina diversa senza alcun avviso.1679Mantieni attivo il controllo delle chiavi host per questi host e mantieni un file `known_hosts` per essi. Se `StrictHostKeyChecking` è `no` o `accept-new` e anche `UserKnownHostsFile` è `/dev/null` o `none`, nulla registra la chiave. Quando il tuo strumento riutilizza poi un nome, puoi connetterti a una macchina diversa senza alcun avviso.

1679 1680 

1680##### Sostituire l'host1681Un nome riutilizzato conta anche senza nessuno al computer, perché Desktop si connette a questi host da solo. Ad esempio, consegna un messaggio che hai inviato mentre l'host non era raggiungibile, una volta che l'host risponde. Anche con il controllo delle chiavi degli host attivo, il messaggio può raggiungere la nuova macchina con quel nome in questi casi, quindi [smetti di usare una macchina](#stop-using-a-machine) prima che venga eliminata:

1682 

1683* Tu, il tuo comando o un altro programma avete aggiunto la nuova chiave a `known_hosts` o rimosso la riga della vecchia chiave, come fa il tuo comando se aggiunge chiavi degli host

1684* Le macchine del tuo strumento condividono una chiave dell'host

1685* Le macchine del tuo strumento condividono un'autorità di certificazione considerata attendibile da `known_hosts`

1686* Tu o il tuo amministratore avete impostato `KnownHostsCommand` o `VerifyHostKeyDNS yes`, quindi SSH accetta chiavi da fuori `known_hosts`

1687 

1688##### Creare un'altra macchina

1689 

1690Le tue sessioni sulle macchine precedenti continuano a funzionare dopo che selezioni **Create another Dev box**, e le nuove sessioni usano la nuova macchina. Seleziona l'elemento nel selettore dell'ambiente per creare una macchina nuova o per sostituirne una che non c'è più. Nella pagina di nuova sessione, lo offre anche il messaggio che indica che Desktop non riesce a raggiungere l'host.

1681 1691 

1682Una volta che Dev box ha un host, il selettore elenca Dev box tra le tue connessioni SSH e **Create Dev box** diventa **Replace Dev box's host**. Se quell'elemento non è nell'elenco, cerca sotto **More**.1692* **Sessioni sulle macchine precedenti**: continuale dalla barra laterale, perché il selettore elenca la macchina attuale di Dev box e non quelle precedenti. Desktop può connettersi alle loro macchine da solo, ad esempio all'avvio di Desktop, quindi [smetti di usare una macchina](#stop-using-a-machine) quando hai finito con essa.

1693* **Un host sostituito prima di Claude Desktop v4.4212.0**: quelle versioni mostrano **Replace Dev box's host** e smettono di connettersi all'host sostituito. Per continuare una sessione su quell'host, apri la sessione, seleziona **Add SSH connection** e salva la connessione che Desktop compila. Aggiorna Desktop prima di sostituire un altro host.

1694* **Nuove sessioni su due macchine**: aggiungi una seconda voce a [`sshHostCommands`](#create-an-ssh-connection-from-a-command)

1695* **Un nuovo host che non risponde ancora**: lascia aperta la pagina di nuova sessione fino a 10 minuti mentre continua a tentare di connettersi. Se l'host continua a non rispondere, seleziona **Create another Dev box** nel messaggio della pagina.

1696* **Un'altra macchina poco dopo**: dopo diverse esecuzioni del comando entro un'ora, conferma ogni esecuzione successiva nella finestra di dialogo che Desktop apre, che mostra il comando

1683 1697 

1684Selezionalo quando la macchina non esiste più o ne vuoi una nuova. Nella pagina di nuova sessione, lo offre anche il messaggio che indica che Desktop non riesce a raggiungere l'host. Desktop esegue di nuovo il comando e le nuove sessioni usano il nuovo host.1698##### Smettere di usare una macchina

1685 1699 

1686* **Un nuovo host**: l'elemento è grigio per 10 minuti dopo che Desktop ha salvato un host, perché una nuova macchina può impiegare un po' di tempo per avviarsi. Finché un nuovo host non risponde, la pagina di nuova sessione continua a tentare di connettersi per quei 10 minuti.1700Per impedire a Desktop di connettersi da solo a una macchina creata da un comando, archivia ogni sessione sulla macchina:

1687* **Sessioni sul vecchio host**: rimangono su di esso, e Desktop non si connette a quell'host a meno che tu non lo aggiunga di nuovo. Per continuarne una, apri la sessione e seleziona **Add SSH connection**. Desktop compila il vecchio host. Salvalo come connessione a sé stante.1701 

17021. Trova le sessioni della macchina nella barra laterale. Il [pannello dei dettagli](#see-session-details) di una sessione mostra l'host su cui viene eseguita.

17032. [Archivia ogni sessione](#archive-a-session) e lasciala archiviata.

17043. Se non hai creato un'altra macchina dalla stessa voce `sshHostCommands` da quando hai creato questa, [creane una](#create-another-machine) oppure [rimuovi la voce](#remove-an-entry). Fino ad allora, la macchina è la connessione salvata della voce, e Desktop può connettersi a essa quando apri la pagina di nuova sessione con quella connessione selezionata.

17054. Elimina nell'app qualsiasi altra connessione SSH alla macchina, o rimuovi la sua voce [`sshConfigs`](#pre-configure-ssh-connections-for-your-team).

17065. Chiudi e riapri Desktop, il che chiude la sua connessione alla macchina e interrompe i suoi tentativi di raggiungerla.

17076. Elimina la macchina con il tuo strumento.

1708 

1709##### Rimuovere una voce

1710 

1711Dopo che rimuovi una voce dal file delle impostazioni o ne modifichi l'`id`, le sessioni sulle sue macchine restano, quindi Desktop può ancora connettersi a quelle macchine. Può farlo senza nessuno al computer, ad esempio per ricollegarsi al processo in esecuzione di una sessione o per consegnare un messaggio in attesa di invio. Per impedirlo, archivia le sessioni, come descritto in [Smettere di usare una macchina](#stop-using-a-machine).

1712 

1713Se sei un amministratore e hai rimosso una voce gestita, anche le sessioni dei tuoi utenti restano, e ogni utente deve archiviare le proprie. Per bloccare tu stesso le macchine della voce, imposta un [`sshHostAllowlist`](#restrict-which-ssh-hosts-users-can-connect-to) che corrisponda agli host di cui i tuoi utenti hanno ancora bisogno e non ai nomi host delle macchine. Puoi farlo solo dove un pattern distingue le due cose.

1688 1714 

1689##### Distribuire i comandi al tuo team1715##### Distribuire i comandi al tuo team

1690 1716 

1711* **L'`id`**: se la voce `sshHostCommands` di un utente ha il tuo `id`, funziona solo la tua. Se qualsiasi altra connessione SSH lo ha, come una nei `sshConfigs` di un utente, la tua voce è grigia. Scegli un `id` che difficilmente gli utenti sceglierebbero.1737* **L'`id`**: se la voce `sshHostCommands` di un utente ha il tuo `id`, funziona solo la tua. Se qualsiasi altra connessione SSH lo ha, come una nei `sshConfigs` di un utente, la tua voce è grigia. Scegli un `id` che difficilmente gli utenti sceglierebbero.

1712* **Il programma**: indica il suo percorso completo, perché Desktop cerca un nome semplice nel `PATH` di ciascun utente. Il programma viene eseguito come l'utente, con le variabili esportate dalla sua shell di login.1738* **Il programma**: indica il suo percorso completo, perché Desktop cerca un nome semplice nel `PATH` di ciascun utente. Il programma viene eseguito come l'utente, con le variabili esportate dalla sua shell di login.

1713* **Le voci degli utenti**: Desktop tratta la voce di un utente come un [hook](https://code.claude.com/docs/it/hooks.md), perché entrambi eseguono un programma sul computer. Per consentire solo le tue voci, imposta [`strictPluginOnlyCustomization`](https://code.claude.com/docs/it/settings-reference#strictpluginonlycustomization) su `["hooks"]`, oppure aggiungi `"hooks"` al suo elenco. Blocchi anche gli hook di Claude Code dalle impostazioni utente, di progetto e locali, senza alcun modo per mantenerli. Se imposti invece quella chiave o [`allowManagedHooksOnly`](https://code.claude.com/docs/it/settings-reference#allowmanagedhooksonly) su `true`, blocchi di più, come indicato nella voce di ciascuna chiave.1739* **Le voci degli utenti**: Desktop tratta la voce di un utente come un [hook](https://code.claude.com/docs/it/hooks.md), perché entrambi eseguono un programma sul computer. Per consentire solo le tue voci, imposta [`strictPluginOnlyCustomization`](https://code.claude.com/docs/it/settings-reference#strictpluginonlycustomization) su `["hooks"]`, oppure aggiungi `"hooks"` al suo elenco. Blocchi anche gli hook di Claude Code dalle impostazioni utente, di progetto e locali, senza alcun modo per mantenerli. Se imposti invece quella chiave o [`allowManagedHooksOnly`](https://code.claude.com/docs/it/settings-reference#allowmanagedhooksonly) su `true`, blocchi di più, come indicato nella voce di ciascuna chiave.

1714* **Tutte le voci**: per disattivare anche le tue voci, imposta [`disableAllHooks`](https://code.claude.com/docs/it/settings-reference#disableallhooks) nelle impostazioni gestite. Se imposti [`disableDesktopLocalSessions`](https://code.claude.com/docs/it/settings-reference#disabledesktoplocalsessions), oppure un `sshHostAllowlist` che non consente alcun host, il selettore non elenca elementi **Create** o **Replace**.1740* **Ogni voce**: per disattivare anche le tue voci, imposta [`disableAllHooks`](https://code.claude.com/docs/it/settings-reference#disableallhooks) nelle impostazioni gestite. Se imposti [`disableDesktopLocalSessions`](https://code.claude.com/docs/it/settings-reference#disabledesktoplocalsessions), o un `sshHostAllowlist` che non consente alcun host, il selettore non elenca alcun elemento **Create** o **Create another**.

1715* **Dove contano i blocchi**: per queste voci, Desktop legge `allowManagedHooksOnly`, `strictPluginOnlyCustomization` e `disableAllHooks` dalle impostazioni gestite dal server e dal file o dalla policy del computer stesso, e applica il risultato più restrittivo. Ogni voce rimane grigia finché Desktop non ha verificato su claude.ai le impostazioni gestite dal server, anche se la tua organizzazione non ne ha.1741* **Dove contano i blocchi**: per queste voci, Desktop legge `allowManagedHooksOnly`, `strictPluginOnlyCustomization` e `disableAllHooks` dalle impostazioni gestite dal server e dal file o dalla policy del computer stesso, e applica il risultato più restrittivo. Ogni voce rimane grigia finché Desktop non ha verificato su claude.ai le impostazioni gestite dal server, anche se la tua organizzazione non ne ha.

1716* **Host consentiti**: se imposti [`sshHostAllowlist`](#restrict-which-ssh-hosts-users-can-connect-to), assicurati che un pattern corrisponda a ogni nome host stampato dal tuo strumento, e ometti `user@` dal pattern. Desktop verifica il nome stampato solo dopo che il comando è stato eseguito, quindi una macchina rifiutata dall'elenco esiste già, e l'utente deve eliminarla con il tuo strumento. A ogni connessione, deve corrispondere anche l'`HostName` risolto.1742* **Host consentiti**: se imposti [`sshHostAllowlist`](#restrict-which-ssh-hosts-users-can-connect-to), assicurati che un pattern corrisponda a ogni nome host stampato dal tuo strumento, e ometti `user@` dal pattern. Desktop verifica il nome stampato solo dopo che il comando è stato eseguito, quindi una macchina rifiutata dall'elenco esiste già, e l'utente deve eliminarla con il tuo strumento. A ogni connessione, deve corrispondere anche l'`HostName` risolto.

1717 1743 

1719 1745 

1720##### Se un comando manca o è grigio1746##### Se un comando manca o è grigio

1721 1747 

1722Il selettore dell'ambiente non elenca alcun elemento **Create** o **Replace** in questi casi:1748Il selettore dell'ambiente non elenca alcun elemento **Create** o **Create another** in questi casi:

1723 1749 

1724* **Il file**: `~/.claude/settings.json` contiene [JSON non valido o un valore rifiutato dallo schema](https://code.claude.com/docs/it/settings.md#fix-a-broken-settings-file), hai scritto male la chiave, oppure l'hai inserita nelle impostazioni di un progetto. Correggi il file.1750* **Il file**: `~/.claude/settings.json` contiene [JSON non valido o un valore rifiutato dallo schema](https://code.claude.com/docs/it/settings.md#fix-a-broken-settings-file), hai scritto male la chiave, oppure l'hai inserita nelle impostazioni di un progetto. Correggi il file.

1725* **Piattaforma e account**: usi Windows, oppure un [provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md) anziché un account Claude. Aggiungi tu stesso ogni host come [connessione SSH](#ssh-sessions).1751* **Piattaforma e account**: usi Windows, oppure un [provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md) anziché un account Claude. Aggiungi tu stesso ogni host come [connessione SSH](#ssh-sessions).

1728 1754 

1729Una voce che non puoi selezionare è grigia. Passaci sopra con il puntatore per vedere il motivo:1755Una voce che non puoi selezionare è grigia. Passaci sopra con il puntatore per vedere il motivo:

1730 1756 

1731* **Un errore nella voce**: correggi il campo o il comando indicato dal messaggio. Se l'`id` è già in uso, assegna alla voce un altro `id`.1757* **Un errore nella voce**: correggi il campo o il comando indicato dal messaggio. Se l'`id` è già in uso, assegnane un altro alla voce.

1732* **Un file di impostazioni danneggiato**: finché il tuo file di impostazioni è danneggiato, le voci del tuo amministratore potrebbero essere grigie, con un messaggio che indica il file. [Correggi il file](https://code.claude.com/docs/it/settings.md#fix-a-broken-settings-file).1758* **Un file di impostazioni danneggiato**: finché il tuo file di impostazioni è danneggiato, le voci del tuo amministratore potrebbero essere grigie, con un messaggio che indica il file. [Correggi il file](https://code.claude.com/docs/it/settings.md#fix-a-broken-settings-file).

1733* **Un nuovo host**: puoi [sostituire un host](#replace-the-host) una volta trascorsi 10 minuti dalla sua creazione.1759* **Un nuovo host**: [**Create another**](#create-another-machine) è grigio per un minuto dopo che Desktop ha salvato un host. Selezionalo dopo quel minuto. Prima di Claude Desktop v4.4212.0, **Replace Dev box's host** è grigio per 10 minuti.

1734* **Gli hook sono disattivati o limitati**: le tue voci funzionano solo dove possono essere eseguiti i tuoi hook. Rimuovi `disableAllHooks` dalle tue impostazioni, oppure chiedi al tuo amministratore.1760* **Gli hook sono disattivati o limitati**: le tue voci funzionano solo dove possono essere eseguiti i tuoi hook. Rimuovi `disableAllHooks` dalle tue impostazioni, oppure chiedi al tuo amministratore.

1735* **Le impostazioni sono ancora in caricamento**: ogni voce è grigia finché Desktop non ha caricato le [impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md) della tua organizzazione, di solito pochi secondi dopo l'avvio. Se le voci rimangono grigie, verifica la tua connessione a claude.ai.1761* **Le impostazioni sono ancora in caricamento**: ogni voce è grigia finché Desktop non ha caricato le [impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md) della tua organizzazione, di solito pochi secondi dopo l'avvio. Se le voci rimangono grigie, verifica la tua connessione a claude.ai.

1736 1762 

1946 1972 

1947Sostituisci il segnaposto con l'ID della tua organizzazione claude.ai, mostrato nelle [impostazioni di amministrazione di claude.ai](https://claude.ai/admin-settings/organization). È lo stesso ID accettato dall'impostazione [`forceLoginOrgUUID`](https://code.claude.com/docs/it/settings-reference#forceloginorguuid) di Claude Code. Per esempi per macOS e Windows che impostano questa chiave, vedi [Distribuisci il criterio di Claude Desktop](https://claude.com/docs/cowork/hipaa-setup#deploy-the-claude-desktop-policy) nella guida di Cowork per le organizzazioni pronte per HIPAA.1973Sostituisci il segnaposto con l'ID della tua organizzazione claude.ai, mostrato nelle [impostazioni di amministrazione di claude.ai](https://claude.ai/admin-settings/organization). È lo stesso ID accettato dall'impostazione [`forceLoginOrgUUID`](https://code.claude.com/docs/it/settings-reference#forceloginorguuid) di Claude Code. Per esempi per macOS e Windows che impostano questa chiave, vedi [Distribuisci il criterio di Claude Desktop](https://claude.com/docs/cowork/hipaa-setup#deploy-the-claude-desktop-policy) nella guida di Cowork per le organizzazioni pronte per HIPAA.

1948 1974 

1975> [!WARNING]

1976>

1977> Controlla il valore di `forceLoginOrgUUID` prima di distribuirlo. Se l'ID non è quello della tua organizzazione, le persone della tua organizzazione non possono usare Claude Desktop a meno che non appartengano anche a un'organizzazione con quell'ID. Per risolvere, distribuisci l'ID corretto e chiedi loro di riavviare Claude Desktop.

1978 

1949Se imposti `forceLoginMethod` e `forceLoginOrgUUID` nelle [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) di Claude Code, non modifichi la schermata di accesso di Claude Desktop.1979Se imposti `forceLoginMethod` e `forceLoginOrgUUID` nelle [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) di Claude Code, non modifichi la schermata di accesso di Claude Desktop.

1950 1980 

1951### Requisiti di accesso alla rete1981### Requisiti di accesso alla rete

2055| `--model sonnet` | Selettore del modello nella riga sotto la casella del prompt |2085| `--model sonnet` | Selettore del modello nella riga sotto la casella del prompt |

2056| `--resume`, `--continue` | Fai clic su una sessione nella barra laterale, o digita `/resume` nella casella del prompt per riprendere una sessione che hai avviato dalla CLI |2086| `--resume`, `--continue` | Fai clic su una sessione nella barra laterale, o digita `/resume` nella casella del prompt per riprendere una sessione che hai avviato dalla CLI |

2057| `--permission-mode` | Selettore di modalità nella riga sotto la casella del prompt |2087| `--permission-mode` | Selettore di modalità nella riga sotto la casella del prompt |

2058| `--dangerously-skip-permissions` | Modalità Bypass permissions. Su piani Pro e Max, abilita "Allow bypass permissions mode" in **Impostazioni > Code** o **Impostazioni > Claude Code**; su piani Team ed Enterprise, la politica organizzativa la controlla |2088| `--dangerously-skip-permissions` | Modalità Bypass permissions. Su piani Pro, Max e Ultra, abilita "Allow bypass permissions mode" in **Impostazioni > Code** o **Impostazioni > Claude Code**; su piani Team ed Enterprise, la politica organizzativa la controlla |

2059| `--add-dir` | [Aggiungi cartelle a una sessione](#add-folders-to-a-session) nelle sessioni locali e SSH, oppure seleziona [più repository](#run-long-running-tasks-in-the-cloud) in una sessione cloud |2089| `--add-dir` | [Aggiungi cartelle a una sessione](#add-folders-to-a-session) nelle sessioni locali e SSH, oppure seleziona [più repository](#run-long-running-tasks-in-the-cloud) in una sessione cloud |

2060| `--allowedTools`, `--disallowedTools` | Nessun equivalente per sessione. Le regole di permesso nei [file di impostazioni](https://code.claude.com/docs/it/settings.md) si applicano ancora. |2090| `--allowedTools`, `--disallowedTools` | Nessun equivalente per sessione. Le regole di permesso nei [file di impostazioni](https://code.claude.com/docs/it/settings.md) si applicano ancora. |

2061| `--verbose` | [Modalità di visualizzazione Verbose](#switch-view-modes) |2091| `--verbose` | [Modalità di visualizzazione Verbose](#switch-view-modes) |

2091 2121 

2092| Funzionalità | CLI | Desktop |2122| Funzionalità | CLI | Desktop |

2093| - | - | - |2123| - | - | - |

2094| Modalità di permesso | Tutte le modalità inclusa `dontAsk` | Manuale, Accetta modifiche, Plan e Auto. Bypass permissions appare nel selettore di modalità una volta abilitato: tramite l'interruttore Impostazioni su piani Pro e Max, o tramite la politica organizzativa su piani Team ed Enterprise |2124| Modalità di permesso | Tutte le modalità inclusa `dontAsk` | Manuale, Accetta modifiche, Plan e Auto. Bypass permissions appare nel selettore di modalità una volta abilitato: tramite l'interruttore Impostazioni su piani Pro, Max e Ultra, o tramite la politica organizzativa su piani Team ed Enterprise |

2095| [Provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md) | Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry | API di Anthropic per impostazione predefinita. Per il routing tramite gateway, vedi [connetti l'app desktop a un gateway](https://code.claude.com/docs/it/llm-gateway-connect.md#desktop-app). Per eseguire la scheda Code su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry o un gateway LLM self-hosted, vedi [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview). |2125| [Provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md) | Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry | API di Anthropic per impostazione predefinita. Per il routing tramite gateway, vedi [connetti l'app desktop a un gateway](https://code.claude.com/docs/it/llm-gateway-connect.md#desktop-app). Per eseguire la scheda Code su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry o un gateway LLM self-hosted, vedi [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview). |

2096| [Server MCP](https://code.claude.com/docs/it/mcp.md) | Configura nei file di impostazioni | UI Connectors per sessioni locali e SSH, o file di impostazioni |2126| [Server MCP](https://code.claude.com/docs/it/mcp.md) | Configura nei file di impostazioni | UI Connectors per sessioni locali e SSH, o file di impostazioni |

2097| [Plugin](https://code.claude.com/docs/it/plugins/overview.md) | Comando `/plugin` | UI gestore plugin |2127| [Plugin](https://code.claude.com/docs/it/plugins/overview.md) | Comando `/plugin` | UI gestore plugin |

2153Se vedi `Error 403: Forbidden` o altri errori di autenticazione quando usi la scheda Code:2183Se vedi `Error 403: Forbidden` o altri errori di autenticazione quando usi la scheda Code:

2154 2184 

21551. Esci e accedi di nuovo dal menu dell'app. Questo è il fix più comune.21851. Esci e accedi di nuovo dal menu dell'app. Questo è il fix più comune.

21562. Verifica di avere un abbonamento a pagamento attivo: Pro, Max, Team o Enterprise.21862. Verifica di avere un abbonamento a pagamento attivo: Pro, Max, Ultra, Team o Enterprise.

21573. Se la CLI funziona ma Desktop no, esci completamente dall'app desktop, non solo chiudere la finestra, quindi riapri e accedi di nuovo.21873. Se la CLI funziona ma Desktop no, esci completamente dall'app desktop, non solo chiudere la finestra, quindi riapri e accedi di nuovo.

21584. Controlla la tua connessione Internet e le impostazioni del proxy.21884. Controlla la tua connessione Internet e le impostazioni del proxy.

2159 2189 

Details

8 8 

9> [!NOTE]9> [!NOTE]

10>10>

11> Il riquadro iOS Simulator è in beta pubblica in Claude Code Desktop su macOS. È disponibile nei piani Pro, Max, Team ed Enterprise, tranne nelle organizzazioni Enterprise che hanno una configurazione HIPAA abilitata.11> Il riquadro iOS Simulator è in beta pubblica in Claude Code Desktop su macOS. È disponibile nei piani Pro, Max, Ultra, Team ed Enterprise, tranne nelle organizzazioni Enterprise che hanno una configurazione HIPAA abilitata.

12 12 

13Il riquadro iOS Simulator mostra la tua app in esecuzione nell'iOS Simulator di Apple accanto alla tua conversazione in Claude Code Desktop. Quando Claude compila, installa, avvia o verifica la tua app in un simulatore, il riquadro si apre automaticamente e trasmette lo schermo del dispositivo in diretta. Usalo per osservare Claude mentre esegue e testa la tua app, oppure per navigare tu stesso nell'app mentre Claude continua a lavorare.13Il riquadro iOS Simulator mostra la tua app in esecuzione nell'iOS Simulator di Apple accanto alla tua conversazione in Claude Code Desktop. Quando Claude compila, installa, avvia o verifica la tua app in un simulatore, il riquadro si apre automaticamente e trasmette lo schermo del dispositivo in diretta. Usalo per osservare Claude mentre esegue e testa la tua app, oppure per navigare tu stesso nell'app mentre Claude continua a lavorare.

14 14 

Details

6 6 

7> Installa l'app desktop di Claude, apri la scheda Code e avvia la tua prima sessione di Claude Code su una cartella di progetto sul tuo computer.7> Installa l'app desktop di Claude, apri la scheda Code e avvia la tua prima sessione di Claude Code su una cartella di progetto sul tuo computer.

8 8 

9L'app desktop ti offre Claude Code con un'interfaccia grafica. Puoi chiedere a Claude di lavorare sul codice in una cartella sul tuo computer e rivedere le sue modifiche senza usare un terminale.9L'app desktop ti offre Claude Code con un'interfaccia grafica. Puoi chiedere a Claude di lavorare sul codice in una cartella sul tuo computer e poi rivedere tu stesso le modifiche, senza usare un terminale.

10 10 

11Claude Code si trova nella scheda **Code** nella parte superiore della barra laterale dell'app. Questa pagina illustra l'installazione dell'app e l'avvio della tua prima sessione in quella scheda. Claude Code richiede un [abbonamento Pro, Max, Team o Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=desktop_quickstart_pricing).11Claude Code si trova nella scheda **Code** nella parte superiore della barra laterale dell'app. Questa pagina illustra l'installazione dell'app e l'avvio della tua prima sessione in quella scheda. Claude Code richiede un [abbonamento Pro, Max, Ultra, Team o Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=desktop_quickstart_pricing).

12 12 

13> **[Scarica per macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect?utm_source=claude_code\&utm_medium=docs)**13> [card] [Scarica per macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect?utm_source=claude_code\&utm_medium=docs)

14>14>

15> Build universale per Intel e Apple Silicon15> Build universale per Intel e Apple Silicon

16 16 

17> **[Scarica per Windows](https://claude.ai/api/desktop/win32/x64/setup/latest/redirect?utm_source=claude_code\&utm_medium=docs)**17> [card] [Scarica per Windows](https://claude.ai/api/desktop/win32/x64/setup/latest/redirect?utm_source=claude_code\&utm_medium=docs)

18>18>

19> Per processori x6419> Per processori x64

20 20 

21> **[Ottieni Claude per Linux (beta)](https://code.claude.com/docs/it/desktop-linux.md)**21> [card] [Ottieni Claude per Linux (beta)](https://code.claude.com/docs/it/desktop-linux.md)

22>22>

23> apt o .deb per Ubuntu e Debian23> apt o .deb per Ubuntu e Debian

24 24 

devcontainer.md +1 −1

Details

17> Utilizza i dev container solo quando sviluppi con repository affidabili e monitora le attività di Claude.17> Utilizza i dev container solo quando sviluppi con repository affidabili e monitora le attività di Claude.

18> Evita di montare segreti host come `~/.ssh` o file di credenziali cloud nel contenitore; preferisci token con ambito repository o di breve durata.18> Evita di montare segreti host come `~/.ssh` o file di credenziali cloud nel contenitore; preferisci token con ambito repository o di breve durata.

19 19 

20> **Come i dev container funzionano con il tuo editor**20> [accordion] Come i dev container funzionano con il tuo editor

21>21>

22> ![Diagramma che mostra un editor sull'host che si connette a un dev container Docker. Claude Code, il terminale e gli strumenti di build vengono eseguiti all'interno del contenitore. Il repository host è bind-montato nel contenitore come workspace.](https://mintcdn.com/claude-code/YvJyjZfd9yMihr0i/images/devcontainer-architecture.svg?fit=max\&auto=format\&n=YvJyjZfd9yMihr0i\&q=85\&s=9017b1d16a446c6cc37ba562f35b9aae)22> ![Diagramma che mostra un editor sull'host che si connette a un dev container Docker. Claude Code, il terminale e gli strumenti di build vengono eseguiti all'interno del contenitore. Il repository host è bind-montato nel contenitore come workspace.](https://mintcdn.com/claude-code/YvJyjZfd9yMihr0i/images/devcontainer-architecture.svg?fit=max\&auto=format\&n=YvJyjZfd9yMihr0i\&q=85\&s=9017b1d16a446c6cc37ba562f35b9aae)

23>23>

env-vars.md +41 −41

Details

23 23 

24Imposta la variabile prima di avviare `claude`:24Imposta la variabile prima di avviare `claude`:

25 25 

26**macOS, Linux, WSL**26> [tab] macOS, Linux, WSL

27 27>

28```bash theme={null}28> ```bash theme={null}

29export API_TIMEOUT_MS="1200000"29> export API_TIMEOUT_MS="1200000"

30claude30> claude

31```31> ```

32 32>

33Per impostarla per ogni sessione, aggiungi la riga `export` a `~/.bashrc`, `~/.zshrc`, o al file di profilo della tua shell.33> Per impostarla per ogni sessione, aggiungi la riga `export` a `~/.bashrc`, `~/.zshrc`, o al file di profilo della tua shell.

34 

35**Windows PowerShell**

36 

37```powershell theme={null}

38$env:API_TIMEOUT_MS = "1200000"

39claude

40```

41 

42Per impostarla per ogni sessione, esegui `[Environment]::SetEnvironmentVariable("API_TIMEOUT_MS", "1200000", "User")` e apri un nuovo terminale.

43 

44**Windows CMD**

45 34 

46```batch theme={null}35> [tab] Windows PowerShell

47set API_TIMEOUT_MS=120000036>

48claude37> ```powershell theme={null}

49```38> $env:API_TIMEOUT_MS = "1200000"

39> claude

40> ```

41>

42> Per impostarla per ogni sessione, esegui `[Environment]::SetEnvironmentVariable("API_TIMEOUT_MS", "1200000", "User")` e apri un nuovo terminale.

50 43 

51Per impostarla per ogni sessione, esegui `setx API_TIMEOUT_MS "1200000"` e apri un nuovo terminale.44> [tab] Windows CMD

45>

46> ```batch theme={null}

47> set API_TIMEOUT_MS=1200000

48> claude

49> ```

50>

51> Per impostarla per ogni sessione, esegui `setx API_TIMEOUT_MS "1200000"` e apri un nuovo terminale.

52 52 

53La riga di assegnazione non stampa nulla in caso di successo. Per confermare che la variabile è impostata, stampala nella stessa shell:53La riga di assegnazione non stampa nulla in caso di successo. Per confermare che la variabile è impostata, stampala nella stessa shell:

54 54 

55**macOS, Linux, WSL**55> [tab] macOS, Linux, WSL

56 56>

57```bash theme={null}57> ```bash theme={null}

58echo $API_TIMEOUT_MS58> echo $API_TIMEOUT_MS

59```59> ```

60 

61**Windows PowerShell**

62 

63```powershell theme={null}

64echo $env:API_TIMEOUT_MS

65```

66 60 

67**Windows CMD**61> [tab] Windows PowerShell

62>

63> ```powershell theme={null}

64> echo $env:API_TIMEOUT_MS

65> ```

68 66 

69```batch theme={null}67> [tab] Windows CMD

70echo %API_TIMEOUT_MS%68>

71```69> ```batch theme={null}

70> echo %API_TIMEOUT_MS%

71> ```

72 72 

73### Impostare variabili nei file di impostazioni73### Impostare variabili nei file di impostazioni

74 74 

130 130 

131| Variabile | Scopo |131| Variabile | Scopo |

132| :- | :- |132| :- | :- |

133| `ANTHROPIC_API_KEY` | Chiave API inviata come header `X-Api-Key`. Quando è impostata, questa chiave viene usata al posto del tuo abbonamento Claude Pro, Max, Team o Enterprise anche se hai effettuato l'accesso. In modalità non interattiva (`-p`), la chiave viene sempre usata quando presente. In modalità interattiva, ti viene chiesto di approvare la chiave una volta prima che sostituisca il tuo abbonamento. Per usare invece il tuo abbonamento, esegui `unset ANTHROPIC_API_KEY` |133| `ANTHROPIC_API_KEY` | Chiave API inviata come header `X-Api-Key`. Quando è impostata, questa chiave viene usata al posto del tuo abbonamento Claude Pro, Max, Ultra, Team o Enterprise anche se hai effettuato l'accesso. In modalità non interattiva (`-p`), la chiave viene sempre usata quando presente. In modalità interattiva, ti viene chiesto di approvare la chiave una volta prima che sostituisca il tuo abbonamento. Per usare invece il tuo abbonamento, esegui `unset ANTHROPIC_API_KEY` |

134| `ANTHROPIC_AUTH_TOKEN` | Valore personalizzato per l'header `Authorization` (al valore impostato qui verrà anteposto `Bearer `) |134| `ANTHROPIC_AUTH_TOKEN` | Valore personalizzato per l'header `Authorization` (al valore impostato qui verrà anteposto `Bearer `) |

135| `ANTHROPIC_AWS_API_KEY` | Chiave API del workspace per [Claude Platform on AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md), generata nella AWS Console. Inviata come `x-api-key` e ha la precedenza su AWS SigV4 |135| `ANTHROPIC_AWS_API_KEY` | Chiave API del workspace per [Claude Platform on AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md), generata nella AWS Console. Inviata come `x-api-key` e ha la precedenza su AWS SigV4 |

136| `ANTHROPIC_AWS_BASE_URL` | Sovrascrive l'URL dell'endpoint di [Claude Platform on AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md). Usala per regioni personalizzate o quando instradi le richieste attraverso un [gateway LLM](https://code.claude.com/docs/it/llm-gateway). Il valore predefinito è `https://aws-external-anthropic.{region}.api.aws`. Claude Code risolve la regione con la [stessa precedenza usata su Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md#3-configure-claude-code) |136| `ANTHROPIC_AWS_BASE_URL` | Sovrascrive l'URL dell'endpoint di [Claude Platform on AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md). Usala per regioni personalizzate o quando instradi le richieste attraverso un [gateway LLM](https://code.claude.com/docs/it/llm-gateway). Il valore predefinito è `https://aws-external-anthropic.{region}.api.aws`. Claude Code risolve la regione con la [stessa precedenza usata su Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md#3-configure-claude-code) |

575* [Inviare messaggi a sessioni al di fuori di questa macchina](https://code.claude.com/docs/it/cross-session-messaging.md#message-sessions-on-other-machines) quando [Remote Control](https://code.claude.com/docs/it/remote-control.md#requirements) non è disponibile. La messaggistica tra sessioni su questa macchina funziona con il recupero disattivato575* [Inviare messaggi a sessioni al di fuori di questa macchina](https://code.claude.com/docs/it/cross-session-messaging.md#message-sessions-on-other-machines) quando [Remote Control](https://code.claude.com/docs/it/remote-control.md#requirements) non è disponibile. La messaggistica tra sessioni su questa macchina funziona con il recupero disattivato

576* Eseguire [`claude import` o il comando `/import`](https://code.claude.com/docs/it/cli-reference#cli-commands)576* Eseguire [`claude import` o il comando `/import`](https://code.claude.com/docs/it/cli-reference#cli-commands)

577* Eseguire [`/skill-doctor`](https://code.claude.com/docs/it/skills#find-unused-skills) o aprirne il report nella scheda **Stats** di `/plugin`577* Eseguire [`/skill-doctor`](https://code.claude.com/docs/it/skills#find-unused-skills) o aprirne il report nella scheda **Stats** di `/plugin`

578* Eseguire [`/restart`](https://code.claude.com/docs/it/commands) sui piani Pro e Max578* Eseguire [`/restart`](https://code.claude.com/docs/it/commands) sui piani Pro, Max e Ultra

579* Sincronizzare le [skill](https://code.claude.com/docs/it/skills.md#where-synced-skills-load) e i [plugin](https://code.claude.com/docs/it/plugins/loading.md#synced-plugins) abilitati per il tuo account claude.ai nelle sessioni del terminale579* Sincronizzare le [skill](https://code.claude.com/docs/it/skills.md#where-synced-skills-load) e i [plugin](https://code.claude.com/docs/it/plugins/loading.md#synced-plugins) abilitati per il tuo account claude.ai nelle sessioni del terminale

580* Attivare il [mod You should know](https://code.claude.com/docs/it/interactive-mode.md#you-should-know-suggestions)580* Attivare il [mod You should know](https://code.claude.com/docs/it/interactive-mode.md#you-should-know-suggestions)

581* Usare [lo strumento advisor](https://code.claude.com/docs/it/advisor.md#requirements)581* Usare [lo strumento advisor](https://code.claude.com/docs/it/advisor.md#requirements)

errors.md +5 −5

Details

830* Nella scheda Code dell'[app Desktop](https://code.claude.com/docs/it/desktop.md), la scheda session-limit offre una casella di controllo **Auto-continue when limits reset**. La scheda weekly-limit non lo fa. Quando è selezionata, l'app Desktop riprova il turno interrotto dopo il ripristino e mostra l'ora del nuovo tentativo sulla scheda. La casella di controllo Desktop e l'impostazione **Continue automatically at usage limit** della CLI in `/config` sono separate, quindi disattiva ciascuna per conto proprio.830* Nella scheda Code dell'[app Desktop](https://code.claude.com/docs/it/desktop.md), la scheda session-limit offre una casella di controllo **Auto-continue when limits reset**. La scheda weekly-limit non lo fa. Quando è selezionata, l'app Desktop riprova il turno interrotto dopo il ripristino e mostra l'ora del nuovo tentativo sulla scheda. La casella di controllo Desktop e l'impostazione **Continue automatically at usage limit** della CLI in `/config` sono separate, quindi disattiva ciascuna per conto proprio.

831* Per il limite Opus o Sonnet, esegui `/model` e passa a un modello al di fuori di quella famiglia per continuare a lavorare. Ogni modello ha la propria cache di prompt, quindi la richiesta successiva rilegge l'intera conversazione senza hit della cache; vedi [Switching models](https://code.claude.com/docs/it/prompt-caching.md#switching-models)831* Per il limite Opus o Sonnet, esegui `/model` e passa a un modello al di fuori di quella famiglia per continuare a lavorare. Ogni modello ha la propria cache di prompt, quindi la richiesta successiva rilegge l'intera conversazione senza hit della cache; vedi [Switching models](https://code.claude.com/docs/it/prompt-caching.md#switching-models)

832* Esegui `/usage` per vedere i limiti del tuo piano e quando si ripristinano832* Esegui `/usage` per vedere i limiti del tuo piano e quando si ripristinano

833* Esegui `/usage-credits` per acquistare utilizzo aggiuntivo su Pro e Max, o per richiederlo al tuo amministratore su Team ed Enterprise. Vedi [usage credits for paid plans](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) per come viene fatturato.833* Esegui `/usage-credits` per acquistare utilizzo aggiuntivo su Pro, Max e Ultra, o per richiederlo al tuo amministratore su Team ed Enterprise. Vedi [usage credits for paid plans](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) per come viene fatturato.

834* Per aggiornare il tuo piano per limiti di base più elevati, vedi [claude.com/pricing](https://claude.com/pricing)834* Per aggiornare il tuo piano per limiti di base più elevati, vedi [claude.com/pricing](https://claude.com/pricing)

835 835 

836Prima che una finestra si esaurisca, Claude Code può avvertirti che hai utilizzato la maggior parte di essa, con un messaggio come `You've used 85% of your session limit · resets 3:45pm`. Per monitorare l'indennità rimanente continuamente, aggiungi i campi `rate_limits` a una [riga di stato personalizzata](https://code.claude.com/docs/it/statusline.md#rate-limit-usage), oppure nell'app Desktop fai clic sull'[anello di utilizzo](https://code.claude.com/docs/it/desktop.md#check-usage) accanto al selettore di modelli.836Prima che una finestra si esaurisca, Claude Code può avvertirti che hai utilizzato la maggior parte di essa, con un messaggio come `You've used 85% of your session limit · resets 3:45pm`. Per monitorare l'indennità rimanente continuamente, aggiungi i campi `rate_limits` a una [riga di stato personalizzata](https://code.claude.com/docs/it/statusline.md#rate-limit-usage), oppure nell'app Desktop fai clic sull'[anello di utilizzo](https://code.claude.com/docs/it/desktop.md#check-usage) accanto al selettore di modelli.

852**Cosa fare:**852**Cosa fare:**

853 853 

854* Esegui `/model` e seleziona la variante senza il suffisso `[1m]` per tornare alla finestra di contesto standard854* Esegui `/model` e seleziona la variante senza il suffisso `[1m]` per tornare alla finestra di contesto standard

855* Dove il messaggio nomina `/usage-credits`, eseguilo per attivare la fatturazione a consumo per la variante 1M su Pro e Max, o per richiedere crediti di utilizzo al tuo amministratore su Team ed Enterprise. Una volta che i crediti di utilizzo sono attivati, riavvia Claude Code o avvia una nuova sessione, a seconda di quello che dice il messaggio. Fino al riavvio, la sessione rimane al limite di contesto standard.855* Dove il messaggio nomina `/usage-credits`, eseguilo per attivare la fatturazione a consumo per la variante 1M su Pro, Max e Ultra, o per richiedere crediti di utilizzo al tuo amministratore su Team ed Enterprise. Una volta che i crediti di utilizzo sono attivati, riavvia Claude Code o avvia una nuova sessione, a seconda di quello che dice il messaggio. Fino al riavvio, la sessione rimane al limite di contesto standard.

856* Se l'errore persiste dopo `/model`, un ID modello 1M potrebbe essere impostato altrove. Vedi [Setting your model](https://code.claude.com/docs/it/model-config.md#setting-your-model) per i percorsi di configurazione da controllare in ordine di priorità.856* Se l'errore persiste dopo `/model`, un ID modello 1M potrebbe essere impostato altrove. Vedi [Setting your model](https://code.claude.com/docs/it/model-config.md#setting-your-model) per i percorsi di configurazione da controllare in ordine di priorità.

857* Per rimuovere completamente le varianti 1M dal selettore di modelli, imposta [`CLAUDE_CODE_DISABLE_1M_CONTEXT=1`](https://code.claude.com/docs/it/env-vars)857* Per rimuovere completamente le varianti 1M dal selettore di modelli, imposta [`CLAUDE_CODE_DISABLE_1M_CONTEXT=1`](https://code.claude.com/docs/it/env-vars)

858 858 

933 933 

934**Cosa fare:**934**Cosa fare:**

935 935 

936* Su Pro e Max, aumenta il tuo limite di spesa mensile in [**Settings > Usage**](https://claude.ai/settings/usage) su claude.ai, o esegui `/usage-credits`936* Su Pro, Max e Ultra, aumenta il tuo limite di spesa mensile in [**Settings > Usage**](https://claude.ai/settings/usage) su claude.ai, o esegui `/usage-credits`

937* Su Team ed Enterprise, aumenta il limite in [**Organization settings > Usage**](https://claude.ai/admin-settings/usage) se gestisci la fatturazione, o chiedi a un amministratore di farlo. `/usage-credits` invia quella richiesta al tuo amministratore per te937* Su Team ed Enterprise, aumenta il limite in [**Organization settings > Usage**](https://claude.ai/admin-settings/usage) se gestisci la fatturazione, o chiedi a un amministratore di farlo. `/usage-credits` invia quella richiesta al tuo amministratore per te

938* Per il limite di un canale, chiedi a un proprietario dell'organizzazione o al manager del canale di aumentarlo su claude.ai. Vedi [Per-channel limits](https://claude.com/docs/claude-tag/admins/set-spend-limit#per-channel-limits) nella documentazione Claude Tag938* Per il limite di un canale, chiedi a un proprietario dell'organizzazione o al manager del canale di aumentarlo su claude.ai. Vedi [Per-channel limits](https://claude.com/docs/claude-tag/admins/set-spend-limit#per-channel-limits) nella documentazione Claude Tag

939* Se il messaggio nomina un'ora di ripristino per la finestra del tuo piano, puoi invece aspettare939* Se il messaggio nomina un'ora di ripristino per la finestra del tuo piano, puoi invece aspettare

966 966 

967**Cosa fare:**967**Cosa fare:**

968 968 

969* Se hai un piano Pro, Max, Team o Enterprise e vedi questo, esegui `/status` e controlla la riga `API key`. Un `ANTHROPIC_API_KEY` approvato nel tuo ambiente instrada le richieste attraverso quella chiave invece del tuo abbonamento. Annullalo nella shell corrente e rimuovilo dal tuo profilo shell, quindi riavvia `claude`. Esegui `/login` se non hai ancora effettuato l'accesso con il tuo abbonamento.969* Se hai un piano Pro, Max, Ultra, Team o Enterprise e vedi questo, esegui `/status` e controlla la riga `API key`. Un `ANTHROPIC_API_KEY` approvato nel tuo ambiente instrada le richieste attraverso quella chiave invece del tuo abbonamento. Annullalo nella shell corrente e rimuovilo dal tuo profilo shell, quindi riavvia `claude`. Esegui `/login` se non hai ancora effettuato l'accesso con il tuo abbonamento.

970* Aggiungi crediti su [platform.claude.com/settings/billing](https://platform.claude.com/settings/billing), e considera di abilitare il ricaricamento automatico lì in modo che il saldo si riempia prima di raggiungere lo zero970* Aggiungi crediti su [platform.claude.com/settings/billing](https://platform.claude.com/settings/billing), e considera di abilitare il ricaricamento automatico lì in modo che il saldo si riempia prima di raggiungere lo zero

971* Imposta i limiti di spesa per workspace nella Console per evitare che un singolo progetto esaurisca il saldo dell'organizzazione. Vedi [Manage costs effectively](https://code.claude.com/docs/it/costs.md).971* Imposta i limiti di spesa per workspace nella Console per evitare che un singolo progetto esaurisca il saldo dell'organizzazione. Vedi [Manage costs effectively](https://code.claude.com/docs/it/costs.md).

972 972 

1120 1120 

1121Il suggerimento dopo il `·` dipende dalle tue credenziali salvate: la prima forma appare quando un `/login` memorizzato può subentrare dopo che hai rimosso la chiave, la seconda quando la chiave è la tua unica credenziale.1121Il suggerimento dopo il `·` dipende dalle tue credenziali salvate: la prima forma appare quando un `/login` memorizzato può subentrare dopo che hai rimosso la chiave, la seconda quando la chiave è la tua unica credenziale.

1122 1122 

1123Le variabili d'ambiente hanno la precedenza su `/login`, quindi una chiave esportata nel profilo della tua shell o caricata da un file `.env` viene usata anche quando hai un abbonamento Pro o Max funzionante. In modalità non interattiva (`-p`), la chiave viene sempre usata quando è presente.1123Se esporti una chiave nel profilo della shell o ne carichi una da `.env`, Claude Code la usa al posto di `/login`, anche con un abbonamento Pro, Max o Ultra funzionante. In modalità non interattiva (`-p`), la chiave viene sempre usata quando presente.

1124 1124 

1125**Cosa fare:**1125**Cosa fare:**

1126 1126 

fast-mode.md +6 −6

Details

20 20 

21* Usa `/fast` per attivare/disattivare la modalità veloce in Claude Code CLI. L'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md) offre un comando **Toggle fast mode** quando il modello selezionato supporta la modalità veloce. Claude Code salva tale attivazione/disattivazione nella tua impostazione [`fastMode`](#toggle-fast-mode).21* Usa `/fast` per attivare/disattivare la modalità veloce in Claude Code CLI. L'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md) offre un comando **Toggle fast mode** quando il modello selezionato supporta la modalità veloce. Claude Code salva tale attivazione/disattivazione nella tua impostazione [`fastMode`](#toggle-fast-mode).

22* I prezzi della modalità veloce per MTok input/output sono \$8/\$40 su Opus 5.5 e \$10/\$50 su Opus 5 e Opus 4.8.22* I prezzi della modalità veloce per MTok input/output sono \$8/\$40 su Opus 5.5 e \$10/\$50 su Opus 5 e Opus 4.8.

23* Disponibile per gli utenti di Claude Code sui piani di abbonamento (Pro/Max/Team/Enterprise) e su Claude Console. Le organizzazioni Team ed Enterprise hanno bisogno che un Owner la abiliti prima, e le organizzazioni Console hanno bisogno che l'accesso sia fornito prima di poterla usare con Opus 5 o Opus 4.8. [Requisiti](#requirements) descrive entrambi i casi.23* Disponibile per gli utenti di Claude Code sui piani di abbonamento (Pro/Max/Ultra/Team/Enterprise) e su Claude Console. Le organizzazioni Team ed Enterprise hanno bisogno che un Owner la abiliti prima, e le organizzazioni Console hanno bisogno che l'accesso sia fornito prima di poterla usare con Opus 5 o Opus 4.8. [Requisiti](#requirements) descrive entrambi i casi.

24* Per gli utenti di Claude Code sui piani di abbonamento (Pro/Max/Team/Enterprise), la modalità veloce è disponibile solo tramite crediti di utilizzo e non è inclusa nei limiti di velocità dell'abbonamento.24* Per gli utenti di Claude Code sui piani di abbonamento (Pro/Max/Ultra/Team/Enterprise), la modalità veloce è disponibile solo tramite crediti di utilizzo e non è inclusa nei rate limit dell'abbonamento.

25 25 

26## Attivare o disattivare la modalità veloce26## Attivare o disattivare la modalità veloce

27 27 

86 86 

87Vedi la spesa della modalità veloce in un posto diverso a seconda di come hai effettuato l'accesso, quindi prima esegui [`/status`](https://code.claude.com/docs/it/commands) per verificare. Se mostra una riga `Login method` come `Claude Max account`, hai effettuato l'accesso con un abbonamento Claude. Se mostra invece una riga `API key`, le tue richieste vengono fatturate a un'organizzazione Claude Console.87Vedi la spesa della modalità veloce in un posto diverso a seconda di come hai effettuato l'accesso, quindi prima esegui [`/status`](https://code.claude.com/docs/it/commands) per verificare. Se mostra una riga `Login method` come `Claude Max account`, hai effettuato l'accesso con un abbonamento Claude. Se mostra invece una riga `API key`, le tue richieste vengono fatturate a un'organizzazione Claude Console.

88 88 

89* **Pro e Max**: paghi la modalità veloce dai tuoi crediti di utilizzo. Vai a [**Settings > Usage**](https://claude.ai/settings/usage) su claude.ai, dove la sezione **Usage credits** mostra quanto hai speso in crediti di utilizzo questo mese. Quella cifra include la modalità veloce ma non la separa singolarmente.89* **Pro, Max e Ultra**: paghi la modalità veloce dai tuoi crediti di utilizzo. Vai a [**Settings > Usage**](https://claude.ai/settings/usage) su claude.ai, dove la sezione **Usage credits** mostra quanto hai speso in crediti di utilizzo questo mese. Quella cifra include la modalità veloce ma non la separa singolarmente.

90* **Team ed Enterprise**: la tua organizzazione paga l'utilizzo della modalità veloce dai suoi crediti di utilizzo. Per vedere la tua spesa in crediti di utilizzo, esegui [`/usage`](https://code.claude.com/docs/it/costs#check-your-usage-credits-spend). Per vedere dove la tua organizzazione vede quella spesa, consulta [Claude per Teams ed Enterprise](https://code.claude.com/docs/it/costs.md#claude-for-teams-and-enterprise).90* **Team ed Enterprise**: la tua organizzazione paga l'utilizzo della modalità veloce dai suoi crediti di utilizzo. Per vedere la tua spesa in crediti di utilizzo, esegui [`/usage`](https://code.claude.com/docs/it/costs#check-your-usage-credits-spend). Per vedere dove la tua organizzazione vede quella spesa, consulta [Claude per Teams ed Enterprise](https://code.claude.com/docs/it/costs.md#claude-for-teams-and-enterprise).

91* **Claude Console**: la tua organizzazione paga la modalità veloce insieme al resto dell'utilizzo della sua API. Sulle pagine [Usage](https://platform.claude.com/usage) e [Cost](https://platform.claude.com/cost) di Console, seleziona **Speed (Research Preview)** nel menu **Group by** per separare la modalità veloce dall'utilizzo a velocità standard. Vedi quell'opzione solo quando l'intervallo di date selezionato include l'utilizzo della modalità veloce.91* **Claude Console**: la tua organizzazione paga la modalità veloce insieme al resto dell'utilizzo della sua API. Sulle pagine [Usage](https://platform.claude.com/usage) e [Cost](https://platform.claude.com/cost) di Console, seleziona **Speed (Research Preview)** nel menu **Group by** per separare la modalità veloce dall'utilizzo a velocità standard. Vedi quell'opzione solo quando l'intervallo di date selezionato include l'utilizzo della modalità veloce.

92 92 

120La modalità veloce richiede tutti i seguenti elementi:120La modalità veloce richiede tutti i seguenti elementi:

121 121 

122* **Solo API Anthropic o abbonamento**: la modalità veloce è disponibile tramite l'API Anthropic Console e per i piani di abbonamento Claude utilizzando i crediti di utilizzo. Non è disponibile su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry o Claude Platform su AWS. Le organizzazioni Console devono anche avere [l'accesso alla modalità veloce abilitato](#enable-fast-mode-for-your-organization) per usarla con Opus 5 o Opus 4.8.122* **Solo API Anthropic o abbonamento**: la modalità veloce è disponibile tramite l'API Anthropic Console e per i piani di abbonamento Claude utilizzando i crediti di utilizzo. Non è disponibile su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry o Claude Platform su AWS. Le organizzazioni Console devono anche avere [l'accesso alla modalità veloce abilitato](#enable-fast-mode-for-your-organization) per usarla con Opus 5 o Opus 4.8.

123* **Crediti di utilizzo abilitati per i piani di abbonamento**: su un piano Pro, Max, Team o Enterprise, il tuo account deve avere i [crediti di utilizzo](https://code.claude.com/docs/it/costs.md#add-usage-credits-to-your-subscription) abilitati, che consente la fatturazione oltre l'utilizzo incluso nel tuo piano. Finché non sono abilitati, `/fast` mostra "Fast mode requires usage credits". Come abilitarli dipende dal tuo piano:123* **Crediti di utilizzo attivati per i piani di abbonamento**: su un piano Pro, Max, Ultra, Team o Enterprise, il tuo account deve avere i [crediti di utilizzo](https://code.claude.com/docs/it/costs.md#add-usage-credits-to-your-subscription) attivati, il che consente la fatturazione oltre l'utilizzo incluso nel tuo piano. Finché non sono attivati, `/fast` segnala "Fast mode requires usage credits". Per attivarli, segui il passaggio relativo al tuo piano:

124 * Su Pro e Max, abilitali nella sezione **Usage credits** di [**Settings > Usage**](https://claude.ai/settings/usage) su claude.ai, oppure esegui `/usage-credits` per aprire quella pagina.124 * Su Pro, Max e Ultra, attivali nella sezione **Usage credits** di [**Settings > Usage**](https://claude.ai/settings/usage) su claude.ai, oppure esegui `/usage-credits` per aprire quella pagina.

125 * Su Team e Enterprise, un membro con accesso alla fatturazione li abilita per l'organizzazione in [**Organization settings > Usage**](https://claude.ai/admin-settings/usage), e un membro senza accesso esegue `/usage-credits` per inviare una richiesta agli amministratori dell'organizzazione.125 * Su Team e Enterprise, un membro con accesso alla fatturazione li attiva per l'organizzazione in [**Organization settings > Usage**](https://claude.ai/admin-settings/usage), e un membro senza accesso esegue `/usage-credits` per inviare una richiesta agli amministratori dell'organizzazione.

126 126 

127> [!NOTE]127> [!NOTE]

128>128>

Details

14 14 

15Il modo in cui ti autentichi determina quali funzionalità Claude Code può raggiungere. Per un singolo elenco di ciò che manca sul tuo provider, consulta le schede [riepilogo per provider](#summary-by-provider). Per trovare la tua colonna nelle tabelle:15Il modo in cui ti autentichi determina quali funzionalità Claude Code può raggiungere. Per un singolo elenco di ciò che manca sul tuo provider, consulta le schede [riepilogo per provider](#summary-by-provider). Per trovare la tua colonna nelle tabelle:

16 16 

17* **Abbonamento Claude**: accedi con un account claude.ai nel piano Pro, Max, Team o Enterprise17* **Abbonamento Claude**: accedi con un account claude.ai nel piano Pro, Max, Ultra, Team o Enterprise

18* **Console Anthropic**: ti autentichi con una chiave API Anthropic o [accedendo a un account Console senza una](https://code.claude.com/docs/it/authentication.md#sign-in-without-an-api-key)18* **Console Anthropic**: ti autentichi con una chiave API Anthropic o [accedendo a un account Console senza una](https://code.claude.com/docs/it/authentication.md#sign-in-without-an-api-key)

19* **Amazon Bedrock**: utilizzi modelli Claude dal catalogo dei modelli Bedrock e imposti `CLAUDE_CODE_USE_BEDROCK`. L'[endpoint Mantle](https://code.claude.com/docs/it/amazon-bedrock.md#use-the-mantle-endpoint) (`CLAUDE_CODE_USE_MANTLE`) è coperto da questa colonna19* **Amazon Bedrock**: utilizzi modelli Claude dal catalogo dei modelli Bedrock e imposti `CLAUDE_CODE_USE_BEDROCK`. L'[endpoint Mantle](https://code.claude.com/docs/it/amazon-bedrock.md#use-the-mantle-endpoint) (`CLAUDE_CODE_USE_MANTLE`) è coperto da questa colonna

20* **Claude Platform on AWS**: hai acquistato Claude tramite AWS Marketplace ma chiami l'API Anthropic, e imposti `CLAUDE_CODE_USE_ANTHROPIC_AWS`20* **Claude Platform on AWS**: hai acquistato Claude tramite AWS Marketplace ma chiami l'API Anthropic, e imposti `CLAUDE_CODE_USE_ANTHROPIC_AWS`

46Queste richiedono l'accesso con un account claude.ai e non sono raggiungibili con una chiave API della Console Anthropic o da un provider di terze parti:46Queste richiedono l'accesso con un account claude.ai e non sono raggiungibili con una chiave API della Console Anthropic o da un provider di terze parti:

47 47 

48* [Sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e Claude Code su mobile48* [Sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e Claude Code su mobile

49* [Claude Code in Slack](https://code.claude.com/docs/it/slack.md): piani Pro e Max49* [Claude Code in Slack](https://code.claude.com/docs/it/slack.md): piani Pro, Max e Ultra

50* [Claude Code Desktop](https://code.claude.com/docs/it/desktop.md)50* [Claude Code Desktop](https://code.claude.com/docs/it/desktop.md)

51* [Attività pianificate cloud](https://code.claude.com/docs/it/routines.md) (`/schedule`)51* [Attività pianificate cloud](https://code.claude.com/docs/it/routines.md) (`/schedule`)

52* [Ultrareview](https://code.claude.com/docs/it/ultrareview.md)52* [Ultrareview](https://code.claude.com/docs/it/ultrareview.md)

53* [Code Review](https://code.claude.com/docs/it/code-review.md): piani Team e Enterprise53* [Code Review](https://code.claude.com/docs/it/code-review.md): piani Team e Enterprise

54* [Remote Control](https://code.claude.com/docs/it/remote-control.md)54* [Remote Control](https://code.claude.com/docs/it/remote-control.md)

55* [Estensione Chrome](https://code.claude.com/docs/it/chrome.md)55* [Estensione Chrome](https://code.claude.com/docs/it/chrome.md)

56* [Computer use](https://code.claude.com/docs/it/computer-use.md): piani Pro e Max56* [Computer use](https://code.claude.com/docs/it/computer-use.md): piani Pro, Max e Ultra

57* [Artifacts](https://code.claude.com/docs/it/artifacts.md): piani Pro, Max, Team e Enterprise57* [Artifacts](https://code.claude.com/docs/it/artifacts.md): piani Pro, Max, Ultra, Team e Enterprise

58* [Voice dictation](https://code.claude.com/docs/it/voice-dictation.md)58* [Voice dictation](https://code.claude.com/docs/it/voice-dictation.md)

59 59 

60Desktop è l'eccezione parziale: il [routing del gateway può essere configurato nell'app o da un amministratore](https://code.claude.com/docs/it/llm-gateway-connect.md#desktop-app). [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview) esegue inoltre la scheda Code su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry o un gateway LLM self-hosted. Esegue anche la scheda Code sull'[API Claude](https://claude.com/docs/third-party/claude-desktop/claude-api) con una chiave API della Console Anthropic. Per la disponibilità per piano di queste funzionalità, consulta [Disponibilità per piano di abbonamento](#availability-by-subscription-plan).60Desktop è l'eccezione parziale: il [routing del gateway può essere configurato nell'app o da un amministratore](https://code.claude.com/docs/it/llm-gateway-connect.md#desktop-app). [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview) esegue inoltre la scheda Code su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry o un gateway LLM self-hosted. Esegue anche la scheda Code sull'[API Claude](https://claude.com/docs/third-party/claude-desktop/claude-api) con una chiave API della Console Anthropic. Per la disponibilità per piano di queste funzionalità, consulta [Disponibilità per piano di abbonamento](#availability-by-subscription-plan).

229 229 

230Ogni scheda elenca ciò che non è disponibile o è parzialmente supportato su quel provider, con alternative dove ne esiste una. Tutto ciò che non è elencato funziona allo stesso modo di un abbonamento Claude, a parte le [differenze specifiche del provider](#features-available-on-every-provider) indicate sopra. Su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry e Claude Platform on AWS, la segnalazione degli errori e la telemetria ad Anthropic sono disattivate per impostazione predefinita. Consulta [comportamenti predefiniti per provider API](https://code.claude.com/docs/it/data-usage.md#default-behaviors-by-api-provider) per il traffico che raggiunge ancora Anthropic e come rinunciare.230Ogni scheda elenca ciò che non è disponibile o è parzialmente supportato su quel provider, con alternative dove ne esiste una. Tutto ciò che non è elencato funziona allo stesso modo di un abbonamento Claude, a parte le [differenze specifiche del provider](#features-available-on-every-provider) indicate sopra. Su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry e Claude Platform on AWS, la segnalazione degli errori e la telemetria ad Anthropic sono disattivate per impostazione predefinita. Consulta [comportamenti predefiniti per provider API](https://code.claude.com/docs/it/data-usage.md#default-behaviors-by-api-provider) per il traffico che raggiunge ancora Anthropic e come rinunciare.

231 231 

232**Amazon Bedrock**232> [tab] Amazon Bedrock

233 233>

234**Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription), più [web search](https://code.claude.com/docs/it/tools-reference.md#websearch-tool-behavior), [fast mode](https://code.claude.com/docs/it/fast-mode.md), [Advisor](https://code.claude.com/docs/it/advisor.md), [Channels](https://code.claude.com/docs/it/channels.md), il [dashboard analytics](https://code.claude.com/docs/it/analytics.md), [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) e i [comandi `/design-sync` e `/import`](https://code.claude.com/docs/it/commands#all-commands).234> **Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription), più [web search](https://code.claude.com/docs/it/tools-reference.md#websearch-tool-behavior), [fast mode](https://code.claude.com/docs/it/fast-mode.md), [Advisor](https://code.claude.com/docs/it/advisor.md), [Channels](https://code.claude.com/docs/it/channels.md), il [dashboard analytics](https://code.claude.com/docs/it/analytics.md), [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) e i [comandi `/design-sync` e `/import`](https://code.claude.com/docs/it/commands#all-commands).

235 235>

236**Supporto parziale:**236> **Supporto parziale:**

237 237>

238* [Desktop](https://code.claude.com/docs/it/desktop.md): solo tramite [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview)238> * [Desktop](https://code.claude.com/docs/it/desktop.md): solo tramite [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview)

239* [Auto mode](https://code.claude.com/docs/it/auto-mode-config.md): Sonnet 5 o successivi, Opus 4.7 o successivi, Haiku 5.5 e modelli Fable soltanto239> * [Auto mode](https://code.claude.com/docs/it/auto-mode-config.md): Sonnet 5 o successivi, Opus 4.7 o successivi, Haiku 5.5 e modelli Fable soltanto

240* [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md): tra le tue sessioni su questa macchina soltanto <sup>[5](#fn5)</sup>240> * [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md): tra le tue sessioni su questa macchina soltanto <sup>[5](#fn5)</sup>

241* [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md): soggetto al tuo accordo AWS241> * [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md): soggetto al tuo accordo AWS

242 242>

243**Alternative:** per la pianificazione, utilizza [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) invece di `/schedule`. Per le sessioni cloud, utilizza [GitHub Actions](https://code.claude.com/docs/it/github-actions.md) o [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md). Per le ricerche web, utilizza lo [strumento WebFetch](https://code.claude.com/docs/it/tools-reference.md#webfetch-tool-behavior) con un URL specifico.243> **Alternative:** per la pianificazione, utilizza [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) invece di `/schedule`. Per le sessioni cloud, utilizza [GitHub Actions](https://code.claude.com/docs/it/github-actions.md) o [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md). Per le ricerche web, utilizza lo [strumento WebFetch](https://code.claude.com/docs/it/tools-reference.md#webfetch-tool-behavior) con un URL specifico.

244 

245**Claude Platform on AWS**

246 

247**Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription), più [fast mode](https://code.claude.com/docs/it/fast-mode.md), [Advisor](https://code.claude.com/docs/it/advisor.md), [Channels](https://code.claude.com/docs/it/channels.md), [GitHub Actions](https://code.claude.com/docs/it/github-actions.md), il [dashboard analytics](https://code.claude.com/docs/it/analytics.md), [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) e i [comandi `/design-sync` e `/import`](https://code.claude.com/docs/it/commands#all-commands).

248 

249**Disponibile dove Amazon Bedrock non lo è:** [web search](https://code.claude.com/docs/it/tools-reference.md#websearch-tool-behavior).

250 

251**Supporto parziale:**

252 

253* [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md): tra le tue sessioni su questa macchina soltanto <sup>[5](#fn5)</sup>

254 

255**Alternative:** per la pianificazione, utilizza [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) invece di `/schedule`. Per le sessioni cloud, utilizza [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md).

256 

257**Google Cloud's Agent Platform**

258 

259**Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription), più [fast mode](https://code.claude.com/docs/it/fast-mode.md), [Advisor](https://code.claude.com/docs/it/advisor.md), [Channels](https://code.claude.com/docs/it/channels.md), il [dashboard analytics](https://code.claude.com/docs/it/analytics.md), [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) e i [comandi `/design-sync` e `/import`](https://code.claude.com/docs/it/commands#all-commands).

260 

261**Supporto parziale:**

262 

263* [Desktop](https://code.claude.com/docs/it/desktop.md): tramite [impostazioni gestite](https://claude.com/docs/third-party/claude-desktop/configuration) o [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview)

264* [Web search](https://code.claude.com/docs/it/tools-reference.md#websearch-tool-behavior): Opus 4, Sonnet 4, Haiku 4.5 e modelli successivi

265* [Auto mode](https://code.claude.com/docs/it/auto-mode-config.md): Sonnet 5 o successivi, Opus 4.7 o successivi, Haiku 5.5 e modelli Fable soltanto

266* [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md): tra le tue sessioni su questa macchina soltanto <sup>[5](#fn5)</sup>

267* [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md): soggetto al tuo accordo Google Cloud

268 

269**Alternative:** per la pianificazione, utilizza [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) invece di `/schedule`. Per le sessioni cloud, utilizza [GitHub Actions](https://code.claude.com/docs/it/github-actions.md) o [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md).

270 

271**Microsoft Foundry**

272 

273**Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription), più [fast mode](https://code.claude.com/docs/it/fast-mode.md), [Advisor](https://code.claude.com/docs/it/advisor.md), [Channels](https://code.claude.com/docs/it/channels.md), [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md), il [dashboard analytics](https://code.claude.com/docs/it/analytics.md), [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) e i [comandi `/design-sync` e `/import`](https://code.claude.com/docs/it/commands#all-commands).

274 

275**Supporto parziale:**

276 

277* [Desktop](https://code.claude.com/docs/it/desktop.md): solo tramite [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview)

278* [Auto mode](https://code.claude.com/docs/it/auto-mode-config.md): Sonnet 5 o successivi, Opus 4.7 o successivi, Haiku 5.5 e modelli Fable soltanto

279* [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md): tra le tue sessioni su questa macchina soltanto <sup>[5](#fn5)</sup>

280* [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md): soggetto al tuo accordo Azure

281 

282**Alternative:** per la pianificazione, utilizza [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) invece di `/schedule`. Per le sessioni cloud, utilizza [GitHub Actions](https://code.claude.com/docs/it/github-actions.md).

283 

284**Anthropic Console**

285 244 

286**Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription).245> [tab] Claude Platform on AWS

246>

247> **Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription), più [fast mode](https://code.claude.com/docs/it/fast-mode.md), [Advisor](https://code.claude.com/docs/it/advisor.md), [Channels](https://code.claude.com/docs/it/channels.md), [GitHub Actions](https://code.claude.com/docs/it/github-actions.md), il [dashboard analytics](https://code.claude.com/docs/it/analytics.md), [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) e i [comandi `/design-sync` e `/import`](https://code.claude.com/docs/it/commands#all-commands).

248>

249> **Disponibile dove Amazon Bedrock non lo è:** [web search](https://code.claude.com/docs/it/tools-reference.md#websearch-tool-behavior).

250>

251> **Supporto parziale:**

252>

253> * [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md): tra le tue sessioni su questa macchina soltanto <sup>[5](#fn5)</sup>

254>

255> **Alternative:** per la pianificazione, utilizza [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) invece di `/schedule`. Per le sessioni cloud, utilizza [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md).

287 256 

288Tutto in [Funzionalità CLI che variano per provider](#cli-capabilities-that-vary-by-provider) è disponibile, tranne che [fast mode](https://code.claude.com/docs/it/fast-mode.md) con Claude Opus 5 o Claude Opus 4.8 richiede [accesso provisioned](https://code.claude.com/docs/it/fast-mode.md#enable-fast-mode-for-your-organization). Le [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) che configuri in un'organizzazione Team o Enterprise su claude.ai non raggiungono una sessione che si autentica con una chiave API della Console. Consulta [Disponibilità per piattaforma](https://code.claude.com/docs/it/server-managed-settings.md#platform-availability) per sapere come coprire quelle sessioni.257> [tab] Google Cloud's Agent Platform

258>

259> **Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription), più [fast mode](https://code.claude.com/docs/it/fast-mode.md), [Advisor](https://code.claude.com/docs/it/advisor.md), [Channels](https://code.claude.com/docs/it/channels.md), il [dashboard analytics](https://code.claude.com/docs/it/analytics.md), [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) e i [comandi `/design-sync` e `/import`](https://code.claude.com/docs/it/commands#all-commands).

260>

261> **Supporto parziale:**

262>

263> * [Desktop](https://code.claude.com/docs/it/desktop.md): tramite [impostazioni gestite](https://claude.com/docs/third-party/claude-desktop/configuration) o [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview)

264> * [Web search](https://code.claude.com/docs/it/tools-reference.md#websearch-tool-behavior): Opus 4, Sonnet 4, Haiku 4.5 e modelli successivi

265> * [Auto mode](https://code.claude.com/docs/it/auto-mode-config.md): Sonnet 5 o successivi, Opus 4.7 o successivi, Haiku 5.5 e modelli Fable soltanto

266> * [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md): tra le tue sessioni su questa macchina soltanto <sup>[5](#fn5)</sup>

267> * [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md): soggetto al tuo accordo Google Cloud

268>

269> **Alternative:** per la pianificazione, utilizza [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) invece di `/schedule`. Per le sessioni cloud, utilizza [GitHub Actions](https://code.claude.com/docs/it/github-actions.md) o [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md).

289 270 

290**Supporto parziale:**271> [tab] Microsoft Foundry

272>

273> **Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription), più [fast mode](https://code.claude.com/docs/it/fast-mode.md), [Advisor](https://code.claude.com/docs/it/advisor.md), [Channels](https://code.claude.com/docs/it/channels.md), [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md), il [dashboard analytics](https://code.claude.com/docs/it/analytics.md), [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) e i [comandi `/design-sync` e `/import`](https://code.claude.com/docs/it/commands#all-commands).

274>

275> **Supporto parziale:**

276>

277> * [Desktop](https://code.claude.com/docs/it/desktop.md): solo tramite [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview)

278> * [Auto mode](https://code.claude.com/docs/it/auto-mode-config.md): Sonnet 5 o successivi, Opus 4.7 o successivi, Haiku 5.5 e modelli Fable soltanto

279> * [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md): tra le tue sessioni su questa macchina soltanto <sup>[5](#fn5)</sup>

280> * [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md): soggetto al tuo accordo Azure

281>

282> **Alternative:** per la pianificazione, utilizza [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) invece di `/schedule`. Per le sessioni cloud, utilizza [GitHub Actions](https://code.claude.com/docs/it/github-actions.md).

291 283 

292* [Desktop](https://code.claude.com/docs/it/desktop.md): tramite [Claude Desktop on 3P con l'API Claude](https://claude.com/docs/third-party/claude-desktop/claude-api)284> [tab] Anthropic Console

285>

286> **Non disponibile:** tutte le [funzionalità che richiedono un abbonamento Claude](#features-that-require-a-claude-subscription).

287>

288> Tutto in [Funzionalità CLI che variano per provider](#cli-capabilities-that-vary-by-provider) è disponibile, tranne che [fast mode](https://code.claude.com/docs/it/fast-mode.md) con Claude Opus 5 o Claude Opus 4.8 richiede [accesso provisioned](https://code.claude.com/docs/it/fast-mode.md#enable-fast-mode-for-your-organization). Le [server-managed settings](https://code.claude.com/docs/it/server-managed-settings.md) che configuri in un'organizzazione Team o Enterprise su claude.ai non raggiungono una sessione che si autentica con una chiave API della Console. Consulta [Disponibilità per piattaforma](https://code.claude.com/docs/it/server-managed-settings.md#platform-availability) per sapere come coprire quelle sessioni.

289>

290> **Supporto parziale:**

291>

292> * [Desktop](https://code.claude.com/docs/it/desktop.md): tramite [Claude Desktop on 3P con l'API Claude](https://claude.com/docs/third-party/claude-desktop/claude-api)

293 293 

294## Disponibilità per piano di abbonamento294## Disponibilità per piano di abbonamento

295 295 

297 297 

298Nelle organizzazioni Enterprise in cui è applicata la [configurazione HIPAA](https://code.claude.com/docs/it/hipaa-setup.md), alcune funzionalità di questa tabella sono disattivate.298Nelle organizzazioni Enterprise in cui è applicata la [configurazione HIPAA](https://code.claude.com/docs/it/hipaa-setup.md), alcune funzionalità di questa tabella sono disattivate.

299 299 

300| Funzionalità | Pro | Max | Team | Enterprise |300| Funzionalità | Pro | Max | Ultra | Team | Enterprise |

301| :- | :- | :- | :- | :- |301| :- | :- | :- | :- | :- | :- |

302| [Cloud sessions](https://code.claude.com/docs/it/claude-code-on-the-web.md) | ✓ | ✓ | ✓ | ✓ <sup>[6](#fn6)</sup> |302| [Cloud sessions](https://code.claude.com/docs/it/claude-code-on-the-web.md) | ✓ | ✓ | ✓ | ✓ | ✓ <sup>[6](#fn6)</sup> |

303| [Attività pianificate nel cloud](https://code.claude.com/docs/it/routines.md) | ✓ | ✓ | ✓ | ✓ |303| [Attività pianificate nel cloud](https://code.claude.com/docs/it/routines.md) | ✓ | ✓ | ✓ | ✓ | ✓ |

304| [Remote Control](https://code.claude.com/docs/it/remote-control.md) | ✓ | ✓ | Admin-enabled | Admin-enabled |304| [Remote Control](https://code.claude.com/docs/it/remote-control.md) | ✓ | ✓ | ✓ | Admin-enabled | Admin-enabled |

305| [Channels](https://code.claude.com/docs/it/channels.md) | ✓ | ✓ | Admin-enabled | Admin-enabled |305| [Channels](https://code.claude.com/docs/it/channels.md) | ✓ | ✓ | ✓ | Admin-enabled | Admin-enabled |

306| [Computer use](https://code.claude.com/docs/it/computer-use.md) | ✓ | ✓ | ✗ | ✗ |306| [Computer use](https://code.claude.com/docs/it/computer-use.md) | ✓ | ✓ | ✓ | ✗ | ✗ |

307| Dispatch ([Desktop](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch)) | ✓ | ✓ | ✗ | ✗ |307| Dispatch ([Desktop](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch)) | ✓ | ✓ | ✓ | ✗ | ✗ |

308| [Code Review](https://code.claude.com/docs/it/code-review.md) | ✗ | ✗ | ✓ | ✓ |308| [Code Review](https://code.claude.com/docs/it/code-review.md) | ✗ | ✗ | ✗ | ✓ | ✓ |

309| [Artifacts](https://code.claude.com/docs/it/artifacts.md) | ✓ | ✓ | ✓ | ✓ |309| [Artifacts](https://code.claude.com/docs/it/artifacts.md) | ✓ | ✓ | ✓ | ✓ | ✓ |

310| [Dashboard analytics e metriche di contribuzione](https://code.claude.com/docs/it/analytics.md) | ✗ | ✗ | ✓ | ✓ |310| [Dashboard analytics e metriche di contribuzione](https://code.claude.com/docs/it/analytics.md) | ✗ | ✗ | ✗ | ✓ | ✓ |

311| [Enterprise Analytics API](https://code.claude.com/docs/it/analytics.md#access-data-programmatically) | ✗ | ✗ | ✗ | ✓ |311| [Enterprise Analytics API](https://code.claude.com/docs/it/analytics.md#access-data-programmatically) | ✗ | ✗ | ✗ | ✗ | ✓ |

312| [Impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md) | ✗ | ✗ | ✓ | ✓ |312| [Impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md) | ✗ | ✗ | ✗ | ✓ | ✓ |

313| [SSO](https://support.claude.com/en/articles/9266767-what-is-the-team-plan) | ✗ | ✗ | ✓ | ✓ |313| [SSO](https://support.claude.com/en/articles/9266767-what-is-the-team-plan) | ✗ | ✗ | ✗ | ✓ | ✓ |

314| SCIM | ✗ | ✗ | ✗ | ✓ |314| SCIM | ✗ | ✗ | ✗ | ✗ | ✓ |

315| [Compliance API](https://platform.claude.com/docs/en/api/compliance) | ✗ | ✗ | ✗ | ✓ |315| [Compliance API](https://platform.claude.com/docs/en/api/compliance) | ✗ | ✗ | ✗ | ✗ | ✓ |

316| [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md) | ✗ | ✗ | ✗ | ✓ <sup>[7](#fn7)</sup> |316| [Zero Data Retention](https://code.claude.com/docs/it/zero-data-retention.md) | ✗ | ✗ | ✗ | ✗ | ✓ <sup>[7](#fn7)</sup> |

317 317 

318<sup>6</sup> Su Enterprise, richiede un premium seat o un Chat + Claude Code seat. Consulta [Use Claude Code in the cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md).\318<sup>6</sup> Su Enterprise, richiede un premium seat o un Chat + Claude Code seat. Consulta [Use Claude Code in the cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md).\

319 319 

321 321 

322Per i prezzi e il confronto completo dei piani, consulta [Piani Team](https://support.claude.com/en/articles/9266767-what-is-the-team-plan) e [Piani Enterprise](https://support.claude.com/en/articles/9797531-what-is-the-enterprise-plan).322Per i prezzi e il confronto completo dei piani, consulta [Piani Team](https://support.claude.com/en/articles/9266767-what-is-the-team-plan) e [Piani Enterprise](https://support.claude.com/en/articles/9797531-what-is-the-enterprise-plan).

323 323 

324### Piano Ultra

325 

326Ultra è il nuovo nome del piano Max 20x, e Max è il nuovo nome di Max 5x. Per verificare quale piano hai, controlla il tuo abbonamento su claude.ai.

327 

328In Claude Code, Max e Ultra hanno le stesse funzionalità, elencate nelle colonne Max e Ultra della [tabella di disponibilità](#availability-by-subscription-plan). Per i limiti di utilizzo e i prezzi, consulta la [pagina dei prezzi di Claude](https://claude.com/pricing).

329 

324## Disponibilità dei modelli330## Disponibilità dei modelli

325 331 

326Per sapere quali modelli Claude e dimensioni della finestra di contesto sono disponibili per provider e regione, consulta [Configurazione dei modelli](https://code.claude.com/docs/it/model-config.md) e la [panoramica dei modelli](https://platform.claude.com/docs/en/about-claude/models/overview). Vision, input PDF e extended thinking sono funzionalità dei modelli piuttosto che funzionalità di Claude Code e funzionano su ogni provider che offre il modello. [Prompt caching](https://code.claude.com/docs/it/prompt-caching.md) funziona allo stesso modo sulla maggior parte dei provider; su Amazon Bedrock, il supporto varia in base al modello.332Per sapere quali modelli Claude e dimensioni della finestra di contesto sono disponibili per provider e regione, consulta [Configurazione dei modelli](https://code.claude.com/docs/it/model-config.md) e la [panoramica dei modelli](https://platform.claude.com/docs/en/about-claude/models/overview). Vision, input PDF e extended thinking sono funzionalità dei modelli piuttosto che funzionalità di Claude Code e funzionano su ogni provider che offre il modello. [Prompt caching](https://code.claude.com/docs/it/prompt-caching.md) funziona allo stesso modo sulla maggior parte dei provider; su Amazon Bedrock, il supporto varia in base al modello.

features-overview.md +193 −193

Details

72 72 

73Alcune funzionalità possono sembrare simili. Per una spiegazione più approfondita sulla scelta tra di esse, consultate [Steering Claude Code: when to use CLAUDE.md, skills, hooks, and subagents](https://claude.com/blog/steering-claude-code-skills-hooks-rules-subagents-and-more) sul blog. Ecco come distinguerle.73Alcune funzionalità possono sembrare simili. Per una spiegazione più approfondita sulla scelta tra di esse, consultate [Steering Claude Code: when to use CLAUDE.md, skills, hooks, and subagents](https://claude.com/blog/steering-claude-code-skills-hooks-rules-subagents-and-more) sul blog. Ecco come distinguerle.

74 74 

75**Skill vs Subagent**75> [tab] Skill vs Subagent

76 76>

77Skills e subagents risolvono problemi diversi:77> Skills e subagents risolvono problemi diversi:

78 78>

79* **Skills** sono contenuti riutilizzabili che potete caricare in qualsiasi contesto79> * **Skills** sono contenuti riutilizzabili che potete caricare in qualsiasi contesto

80* **Subagents** sono worker isolati che vengono eseguiti separatamente dalla vostra conversazione principale80> * **Subagents** sono worker isolati che vengono eseguiti separatamente dalla vostra conversazione principale

81 81>

82| Aspetto | Skill | Subagent |82> | Aspetto | Skill | Subagent |

83| - | - | - |83> | - | - | - |

84| **Cosa è** | Istruzioni, conoscenze o flussi di lavoro riutilizzabili | Worker isolato con il suo proprio contesto |84> | **Cosa è** | Istruzioni, conoscenze o flussi di lavoro riutilizzabili | Worker isolato con il suo proprio contesto |

85| **Vantaggio principale** | Condividere contenuti tra contesti | Isolamento del contesto. Il lavoro avviene separatamente, solo il riassunto ritorna |85> | **Vantaggio principale** | Condividere contenuti tra contesti | Isolamento del contesto. Il lavoro avviene separatamente, solo il riassunto ritorna |

86| **Impatto della [finestra di contesto](https://code.claude.com/docs/it/context-window.md)** | Si aggiunge alla vostra finestra principale | Utilizza una finestra separata con i suoi token di input e output |86> | **Impatto della [finestra di contesto](https://code.claude.com/docs/it/context-window.md)** | Si aggiunge alla vostra finestra principale | Utilizza una finestra separata con i suoi token di input e output |

87| **Migliore per** | Materiale di riferimento, flussi di lavoro invocabili | Compiti che leggono molti file, lavoro parallelo, worker specializzati |87> | **Migliore per** | Materiale di riferimento, flussi di lavoro invocabili | Compiti che leggono molti file, lavoro parallelo, worker specializzati |

88 88>

89**Le skills possono essere di riferimento o di azione.** Le skills di riferimento forniscono conoscenze che Claude utilizza durante la vostra sessione (come la vostra guida di stile API). Le skills di azione dicono a Claude di fare qualcosa di specifico (come `/deploy` che esegue il vostro flusso di lavoro di distribuzione).89> **Le skills possono essere di riferimento o di azione.** Le skills di riferimento forniscono conoscenze che Claude utilizza durante la vostra sessione (come la vostra guida di stile API). Le skills di azione dicono a Claude di fare qualcosa di specifico (come `/deploy` che esegue il vostro flusso di lavoro di distribuzione).

90 90>

91**Utilizzate un subagent** quando avete bisogno di isolamento del contesto o quando la vostra finestra di contesto si sta riempiendo. Il subagent potrebbe leggere dozzine di file o eseguire ricerche estese, ma la vostra conversazione principale riceve solo un riassunto. Poiché il lavoro del subagent non consuma il vostro contesto principale, questo è utile anche quando non avete bisogno che il lavoro intermedio rimanga visibile. I subagents personalizzati possono avere le loro proprie istruzioni e possono precaricare skills.91> **Utilizzate un subagent** quando avete bisogno di isolamento del contesto o quando la vostra finestra di contesto si sta riempiendo. Il subagent potrebbe leggere dozzine di file o eseguire ricerche estese, ma la vostra conversazione principale riceve solo un riassunto. Poiché il lavoro del subagent non consuma il vostro contesto principale, questo è utile anche quando non avete bisogno che il lavoro intermedio rimanga visibile. I subagents personalizzati possono avere le loro proprie istruzioni e possono precaricare skills.

92 92>

93**Possono combinarsi.** Un subagent può precaricare skills specifiche (campo `skills:`). Una skill può essere eseguita in contesto isolato utilizzando `context: fork`. Consultate [Skills](https://code.claude.com/docs/it/skills.md) per i dettagli.93> **Possono combinarsi.** Un subagent può precaricare skills specifiche (campo `skills:`). Una skill può essere eseguita in contesto isolato utilizzando `context: fork`. Consultate [Skills](https://code.claude.com/docs/it/skills.md) per i dettagli.

94 

95**CLAUDE.md vs Skill**

96 

97Entrambi memorizzano istruzioni, ma si caricano diversamente e servono scopi diversi.

98 

99| Aspetto | CLAUDE.md | Skill |

100| - | - | - |

101| **Si carica** | Ogni sessione, automaticamente | Su richiesta |

102| **Può includere file** | Sì, con importazioni `@path` | Sì, con importazioni `@path` |

103| **Può attivare flussi di lavoro** | No | Sì, con `/<name>` |

104| **Migliore per** | Regole "fai sempre X" | Materiale di riferimento, flussi di lavoro invocabili |

105 

106**Mettetelo in CLAUDE.md** se Claude dovrebbe sempre saperlo: convenzioni di codifica, comandi di build, struttura del progetto, regole "non fare mai X".

107 

108**Mettetelo in una skill** se è materiale di riferimento di cui Claude ha bisogno a volte (documentazione API, guide di stile) o un flusso di lavoro che attivate con `/<name>` (deploy, review, release).

109 

110**Regola pratica:** Mantenete CLAUDE.md sotto 200 righe. Se sta crescendo, spostate il contenuto di riferimento in skills o dividetelo in file [`.claude/rules/`](https://code.claude.com/docs/it/memory#organize-rules-with-claude/rules/).

111 

112**CLAUDE.md vs Output style**

113 

114Entrambi danno a Claude istruzioni permanenti. CLAUDE.md contiene ciò che Claude dovrebbe sapere, e uno stile di output imposta come Claude risponde.

115 

116| Aspetto | CLAUDE.md | Output style |

117| - | - | - |

118| **Contiene** | Fatti e regole sul vostro progetto | Un ruolo, un tono e un formato di risposta |

119| **Cambio** | Sempre caricato | Uno attivo alla volta; [cambiate stili](https://code.claude.com/docs/it/output-styles.md#change-your-output-style) quando desiderate |

120| **Migliore per** | Comandi di build, convenzioni, regole "non fare mai X" | Risposte più brevi, spiegazioni insieme al codice, un ruolo non ingegneristico |

121 

122**Mettetelo in CLAUDE.md** se è vero del progetto qualunque stile siate in: convenzioni di codifica, comandi di build, struttura del progetto.

123 

124**Utilizzate uno stile di output** se riguarda la risposta stessa e potreste volerlo disattivare di nuovo: lunghezza, formato, quanto Claude spiega, o un ruolo diverso come un assistente di scrittura. Claude Code include [stili integrati](https://code.claude.com/docs/it/output-styles.md#built-in-output-styles), e potete scrivere i vostri.

125 

126**Si combinano.** CLAUDE.md rimane caricato qualunque stile scegliate. Claude segue entrambi come istruzioni, quindi nessuno è forzato. Per qualsiasi cosa che deve accadere ogni volta, utilizzate un [hook](https://code.claude.com/docs/it/hooks-guide.md).

127 

128**CLAUDE.md vs Rules vs Skills**

129 

130Tutti e tre memorizzano istruzioni, ma si caricano diversamente:

131 

132| Aspetto | CLAUDE.md | `.claude/rules/` | Skill |

133| - | - | - | - |

134| **Si carica** | Ogni sessione | Ogni sessione, o quando vengono aperti file corrispondenti | Su richiesta, quando invocato o rilevante |

135| **Ambito** | Intero progetto | Può essere limitato a percorsi di file | Specifico del compito |

136| **Migliore per** | Convenzioni e comandi di build principali | Linee guida specifiche del linguaggio o della directory | Materiale di riferimento, flussi di lavoro ripetibili |

137 

138**Utilizzate CLAUDE.md** per istruzioni di cui ogni sessione ha bisogno: comandi di build, convenzioni di test, architettura del progetto.

139 

140**Utilizzate rules** per mantenere CLAUDE.md focalizzato. Le rules con [frontmatter `paths`](https://code.claude.com/docs/it/memory#path-specific-rules) si caricano solo quando Claude lavora con file corrispondenti, risparmiando contesto.

141 

142**Utilizzate skills** per contenuti di cui Claude ha bisogno solo a volte, come documentazione API o una checklist di distribuzione che attivate con `/<name>`.

143 

144**Subagent vs Dynamic workflow**

145 

146Entrambi fanno lavoro al di fuori della vostra conversazione principale. Con i subagents, Claude decide turno per turno cosa viene eseguito dopo. In un workflow, lo script decide:

147 

148* **Subagents** sono worker che Claude genera, ognuno restituendo un riassunto alla conversazione che li ha generati

149* **[Dynamic workflows](https://code.claude.com/docs/it/workflows.md)** sono script che Claude scrive che eseguono molti subagents in background e restituiscono un risultato

150 

151**Usa un subagent** quando hai bisogno di un worker rapido e focalizzato: approfondire una domanda, verificare un'affermazione, rivedere un file. Il subagent svolge il lavoro e restituisce un riassunto, così la tua conversazione principale rimane pulita. I subagent a cui Claude ha [assegnato un nome](https://code.claude.com/docs/it/sub-agents.md#subagent-names) quando li ha generati possono anche [scambiarsi messaggi](https://code.claude.com/docs/it/sub-agents.md#what-loads-at-startup).

152 

153**Utilizzate un dynamic workflow** quando un lavoro [cresce oltre una manciata di subagents](https://code.claude.com/docs/it/workflows.md#when-to-use-a-workflow), o quando desiderate che i risultati siano verificati incrociati prima che li vediate, come un audit a livello di codebase, una grande migrazione o un piano redatto da diversi angoli. Per avviarne uno, [chiedete un workflow nel vostro prompt](https://code.claude.com/docs/it/workflows.md#ask-for-a-workflow-in-your-prompt).

154 

155**Per passare un risultato da una delle vostre sessioni a un'altra**, chiedete al Claude della prima sessione di inviarlo. Claude lo consegna con [cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md). [Run agents in parallel](https://code.claude.com/docs/it/agents.md) confronta gli altri modi per eseguire più di un Claude alla volta, incluse sessioni che consegnate e controllate più tardi.

156 

157**MCP vs Skill**

158 

159MCP collega Claude a servizi esterni. Le skills estendono ciò che Claude conosce, incluso come utilizzare efficacemente quei servizi.

160 

161| Aspetto | MCP | Skill |

162| - | - | - |

163| **Cosa è** | Protocollo per il collegamento a servizi esterni | Conoscenze, flussi di lavoro e materiale di riferimento |

164| **Fornisce** | Accesso a strumenti e dati | Conoscenze, flussi di lavoro, materiale di riferimento |

165| **Esempi** | Integrazione Slack, query di database, controllo del browser | Checklist di revisione del codice, flusso di lavoro di distribuzione, guida di stile API |

166 

167Questi risolvono problemi diversi e funzionano bene insieme:

168 

169**MCP** dà a Claude strumenti costruiti appositamente per un sistema esterno, con la connessione e l'autenticazione gestite dal server.

170 

171**Skills** danno a Claude conoscenze su come utilizzare efficacemente quegli strumenti, più flussi di lavoro che potete attivare con `/<name>`. Una skill potrebbe includere lo schema del database del vostro team e i pattern di query, o un flusso di lavoro `/post-to-slack` con le regole di formattazione dei messaggi del vostro team.

172 

173**Hook vs Skill**

174 94 

175Claude Code esegue un hook a un evento del ciclo di vita; carica una skill nel contesto affinché Claude la applichi.95> [tab] CLAUDE.md vs Skill

96>

97> Entrambi memorizzano istruzioni, ma si caricano diversamente e servono scopi diversi.

98>

99> | Aspetto | CLAUDE.md | Skill |

100> | - | - | - |

101> | **Si carica** | Ogni sessione, automaticamente | Su richiesta |

102> | **Può includere file** | Sì, con importazioni `@path` | Sì, con importazioni `@path` |

103> | **Può attivare flussi di lavoro** | No | Sì, con `/<name>` |

104> | **Migliore per** | Regole "fai sempre X" | Materiale di riferimento, flussi di lavoro invocabili |

105>

106> **Mettetelo in CLAUDE.md** se Claude dovrebbe sempre saperlo: convenzioni di codifica, comandi di build, struttura del progetto, regole "non fare mai X".

107>

108> **Mettetelo in una skill** se è materiale di riferimento di cui Claude ha bisogno a volte (documentazione API, guide di stile) o un flusso di lavoro che attivate con `/<name>` (deploy, review, release).

109>

110> **Regola pratica:** Mantenete CLAUDE.md sotto 200 righe. Se sta crescendo, spostate il contenuto di riferimento in skills o dividetelo in file [`.claude/rules/`](https://code.claude.com/docs/it/memory#organize-rules-with-claude/rules/).

176 111 

177| Aspetto | Hook | Skill |112> [tab] CLAUDE.md vs Output style

178| - | - | - |113>

179| **Viene eseguito** | Un comando shell, una richiesta HTTP, una chiamata a strumento MCP, un prompt LLM o un subagent | Istruzioni che Claude legge e segue |114> Entrambi danno a Claude istruzioni permanenti. CLAUDE.md contiene ciò che Claude dovrebbe sapere, e uno stile di output imposta come Claude risponde.

180| **Attivato da** | [Eventi del ciclo di vita](https://code.claude.com/docs/it/hooks.md#hook-events) come `PostToolUse` o `SessionStart` | Voi digitate `/<name>`, o Claude abbina la descrizione al vostro compito |115>

181| **Determinismo** | Si attiva al suo evento senza che Claude lo decida | Claude interpreta le istruzioni; il risultato può variare |116> | Aspetto | CLAUDE.md | Output style |

182| **Costo del contesto** | Zero a meno che l'hook non restituisca output | La descrizione si carica ogni sessione; il contenuto completo si carica quando utilizzato |117> | - | - | - |

183| **Migliore per** | Linting dopo le modifiche, blocco di comandi non sicuri, logging, notifiche | Flussi di lavoro che richiedono ragionamento, materiale di riferimento, compiti multi-step |118> | **Contiene** | Fatti e regole sul vostro progetto | Un ruolo, un tono e un formato di risposta |

119> | **Cambio** | Sempre caricato | Uno attivo alla volta; [cambiate stili](https://code.claude.com/docs/it/output-styles.md#change-your-output-style) quando desiderate |

120> | **Migliore per** | Comandi di build, convenzioni, regole "non fare mai X" | Risposte più brevi, spiegazioni insieme al codice, un ruolo non ingegneristico |

121>

122> **Mettetelo in CLAUDE.md** se è vero del progetto qualunque stile siate in: convenzioni di codifica, comandi di build, struttura del progetto.

123>

124> **Utilizzate uno stile di output** se riguarda la risposta stessa e potreste volerlo disattivare di nuovo: lunghezza, formato, quanto Claude spiega, o un ruolo diverso come un assistente di scrittura. Claude Code include [stili integrati](https://code.claude.com/docs/it/output-styles.md#built-in-output-styles), e potete scrivere i vostri.

125>

126> **Si combinano.** CLAUDE.md rimane caricato qualunque stile scegliate. Claude segue entrambi come istruzioni, quindi nessuno è forzato. Per qualsiasi cosa che deve accadere ogni volta, utilizzate un [hook](https://code.claude.com/docs/it/hooks-guide.md).

184 127 

185**Utilizzate un hook** quando l'azione deve accadere nello stesso modo ogni volta e non ha bisogno che Claude pensi. Ad esempio: formattazione al salvataggio, rifiuto di `rm -rf /`, invio di un messaggio Slack quando una sessione termina.128> [tab] CLAUDE.md vs Rules vs Skills

129>

130> Tutti e tre memorizzano istruzioni, ma si caricano diversamente:

131>

132> | Aspetto | CLAUDE.md | `.claude/rules/` | Skill |

133> | - | - | - | - |

134> | **Si carica** | Ogni sessione | Ogni sessione, o quando vengono aperti file corrispondenti | Su richiesta, quando invocato o rilevante |

135> | **Ambito** | Intero progetto | Può essere limitato a percorsi di file | Specifico del compito |

136> | **Migliore per** | Convenzioni e comandi di build principali | Linee guida specifiche del linguaggio o della directory | Materiale di riferimento, flussi di lavoro ripetibili |

137>

138> **Utilizzate CLAUDE.md** per istruzioni di cui ogni sessione ha bisogno: comandi di build, convenzioni di test, architettura del progetto.

139>

140> **Utilizzate rules** per mantenere CLAUDE.md focalizzato. Le rules con [frontmatter `paths`](https://code.claude.com/docs/it/memory#path-specific-rules) si caricano solo quando Claude lavora con file corrispondenti, risparmiando contesto.

141>

142> **Utilizzate skills** per contenuti di cui Claude ha bisogno solo a volte, come documentazione API o una checklist di distribuzione che attivate con `/<name>`.

186 143 

187**Utilizzate una skill** quando Claude dovrebbe decidere come applicare i passaggi, o quando il contenuto è conoscenza piuttosto che uno script. Ad esempio: una checklist `/release`, la vostra guida di stile API, un playbook di debug.144> [tab] Subagent vs Dynamic workflow

145>

146> Entrambi fanno lavoro al di fuori della vostra conversazione principale. Con i subagents, Claude decide turno per turno cosa viene eseguito dopo. In un workflow, lo script decide:

147>

148> * **Subagents** sono worker che Claude genera, ognuno restituendo un riassunto alla conversazione che li ha generati

149> * **[Dynamic workflows](https://code.claude.com/docs/it/workflows.md)** sono script che Claude scrive che eseguono molti subagents in background e restituiscono un risultato

150>

151> **Usa un subagent** quando hai bisogno di un worker rapido e focalizzato: approfondire una domanda, verificare un'affermazione, rivedere un file. Il subagent svolge il lavoro e restituisce un riassunto, così la tua conversazione principale rimane pulita. I subagent a cui Claude ha [assegnato un nome](https://code.claude.com/docs/it/sub-agents.md#subagent-names) quando li ha generati possono anche [scambiarsi messaggi](https://code.claude.com/docs/it/sub-agents.md#what-loads-at-startup).

152>

153> **Utilizzate un dynamic workflow** quando un lavoro [cresce oltre una manciata di subagents](https://code.claude.com/docs/it/workflows.md#when-to-use-a-workflow), o quando desiderate che i risultati siano verificati incrociati prima che li vediate, come un audit a livello di codebase, una grande migrazione o un piano redatto da diversi angoli. Per avviarne uno, [chiedete un workflow nel vostro prompt](https://code.claude.com/docs/it/workflows.md#ask-for-a-workflow-in-your-prompt).

154>

155> **Per passare un risultato da una delle vostre sessioni a un'altra**, chiedete al Claude della prima sessione di inviarlo. Claude lo consegna con [cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md). [Run agents in parallel](https://code.claude.com/docs/it/agents.md) confronta gli altri modi per eseguire più di un Claude alla volta, incluse sessioni che consegnate e controllate più tardi.

188 156 

189**Mettete i guardrail negli hooks.** Un'istruzione come "non modificare mai `.env`" in CLAUDE.md o una skill è una richiesta, non una garanzia. Un hook `PreToolUse` che blocca la modifica è un'applicazione. Se una regola deve valere ogni volta, fatene un hook piuttosto che un'istruzione di prompt.157> [tab] MCP vs Skill

158>

159> MCP collega Claude a servizi esterni. Le skills estendono ciò che Claude conosce, incluso come utilizzare efficacemente quei servizi.

160>

161> | Aspetto | MCP | Skill |

162> | - | - | - |

163> | **Cosa è** | Protocollo per il collegamento a servizi esterni | Conoscenze, flussi di lavoro e materiale di riferimento |

164> | **Fornisce** | Accesso a strumenti e dati | Conoscenze, flussi di lavoro, materiale di riferimento |

165> | **Esempi** | Integrazione Slack, query di database, controllo del browser | Checklist di revisione del codice, flusso di lavoro di distribuzione, guida di stile API |

166>

167> Questi risolvono problemi diversi e funzionano bene insieme:

168>

169> **MCP** dà a Claude strumenti costruiti appositamente per un sistema esterno, con la connessione e l'autenticazione gestite dal server.

170>

171> **Skills** danno a Claude conoscenze su come utilizzare efficacemente quegli strumenti, più flussi di lavoro che potete attivare con `/<name>`. Una skill potrebbe includere lo schema del database del vostro team e i pattern di query, o un flusso di lavoro `/post-to-slack` con le regole di formattazione dei messaggi del vostro team.

190 172 

191**L'output dell'hook entra nel contesto.** Un hook `PostToolUse` che esegue il vostro linter alimenta i risultati come testo che Claude legge; una skill `/fix-lint` dice a Claude come risolverli.173> [tab] Hook vs Skill

174>

175> Claude Code esegue un hook a un evento del ciclo di vita; carica una skill nel contesto affinché Claude la applichi.

176>

177> | Aspetto | Hook | Skill |

178> | - | - | - |

179> | **Viene eseguito** | Un comando shell, una richiesta HTTP, una chiamata a strumento MCP, un prompt LLM o un subagent | Istruzioni che Claude legge e segue |

180> | **Attivato da** | [Eventi del ciclo di vita](https://code.claude.com/docs/it/hooks.md#hook-events) come `PostToolUse` o `SessionStart` | Voi digitate `/<name>`, o Claude abbina la descrizione al vostro compito |

181> | **Determinismo** | Si attiva al suo evento senza che Claude lo decida | Claude interpreta le istruzioni; il risultato può variare |

182> | **Costo del contesto** | Zero a meno che l'hook non restituisca output | La descrizione si carica ogni sessione; il contenuto completo si carica quando utilizzato |

183> | **Migliore per** | Linting dopo le modifiche, blocco di comandi non sicuri, logging, notifiche | Flussi di lavoro che richiedono ragionamento, materiale di riferimento, compiti multi-step |

184>

185> **Utilizzate un hook** quando l'azione deve accadere nello stesso modo ogni volta e non ha bisogno che Claude pensi. Ad esempio: formattazione al salvataggio, rifiuto di `rm -rf /`, invio di un messaggio Slack quando una sessione termina.

186>

187> **Utilizzate una skill** quando Claude dovrebbe decidere come applicare i passaggi, o quando il contenuto è conoscenza piuttosto che uno script. Ad esempio: una checklist `/release`, la vostra guida di stile API, un playbook di debug.

188>

189> **Mettete i guardrail negli hooks.** Un'istruzione come "non modificare mai `.env`" in CLAUDE.md o una skill è una richiesta, non una garanzia. Un hook `PreToolUse` che blocca la modifica è un'applicazione. Se una regola deve valere ogni volta, fatene un hook piuttosto che un'istruzione di prompt.

190>

191> **L'output dell'hook entra nel contesto.** Un hook `PostToolUse` che esegue il vostro linter alimenta i risultati come testo che Claude legge; una skill `/fix-lint` dice a Claude come risolverli.

192 192 

193### Comprendete come le funzionalità si stratificano193### Comprendete come le funzionalità si stratificano

194 194 

238 238 

239![Caricamento del contesto: CLAUDE.md si carica all'inizio della sessione e rimane in ogni richiesta. I nomi degli strumenti MCP si caricano all'inizio con schemi completi rinviati fino all'uso. Le skills caricano descrizioni all'inizio, contenuto completo all'invocazione. I subagents ottengono contesto isolato. Gli hooks vengono eseguiti esternamente.](https://mintcdn.com/claude-code/ikqp3_70mqIahteV/images/context-loading.svg?fit=max\&auto=format\&n=ikqp3_70mqIahteV\&q=85\&s=aab139e750494a237ae2e0c8f9139b0a)239![Caricamento del contesto: CLAUDE.md si carica all'inizio della sessione e rimane in ogni richiesta. I nomi degli strumenti MCP si caricano all'inizio con schemi completi rinviati fino all'uso. Le skills caricano descrizioni all'inizio, contenuto completo all'invocazione. I subagents ottengono contesto isolato. Gli hooks vengono eseguiti esternamente.](https://mintcdn.com/claude-code/ikqp3_70mqIahteV/images/context-loading.svg?fit=max\&auto=format\&n=ikqp3_70mqIahteV\&q=85\&s=aab139e750494a237ae2e0c8f9139b0a)

240 240 

241**CLAUDE.md**241> [tab] CLAUDE.md

242 

243**Quando:** Inizio della sessione

244 

245**Cosa si carica:** Contenuto completo di ogni file CLAUDE.md che si carica all'inizio della sessione (livelli gestito, utente e progetto).

246 

247**Eredità:** Claude legge i file CLAUDE.md dalla tua directory di lavoro fino alla radice e scopre quelli annidati nelle sottodirectory mentre accede a quei file. Consulta [Come si caricano i file CLAUDE.md](https://code.claude.com/docs/it/memory.md#how-claude-md-files-load) per i dettagli. Se un CLAUDE.md annidato supera il suo [limite di dimensione per file](https://code.claude.com/docs/it/memory.md#claude-ignores-the-end-of-my-subdirectory-claude-md), Claude riceve solo l'inizio del file.

248 

249> [!TIP]

250>242>

251> Mantenete CLAUDE.md sotto 200 righe. Spostate il materiale di riferimento in skills, che si caricano su richiesta. Per ottenere [proposte di ridimensionamento per un CLAUDE.md archiviato](https://code.claude.com/docs/it/memory.md#my-claude-md-is-too-large), eseguite `/doctor`.243> **Quando:** Inizio della sessione

252 

253**Skills**

254 

255Le skills sono capacità extra nel toolkit di Claude. Possono essere materiale di riferimento (come una guida di stile API) o flussi di lavoro invocabili che attivate con `/<name>` (come `/deploy`). Claude Code include [skills raggruppate](https://code.claude.com/docs/it/commands.md) come `/code-review`, `/batch` e `/debug` che funzionano subito. Potete anche crearne di vostre.

256 

257**Quando:** Dipende dalla configurazione della skill. Per impostazione predefinita, le descrizioni si caricano all'inizio della sessione e il contenuto completo si carica quando utilizzate. Per le skills solo utente (`disable-model-invocation: true`), niente si carica fino a quando non le invocate.

258 

259**Cosa si carica:** Per le skills invocabili dal modello, Claude vede nomi e descrizioni in ogni richiesta. Quando invocate una skill con `/<name>` o Claude la carica automaticamente, il contenuto completo si carica nella vostra conversazione.

260 

261**Come Claude sceglie le skill:** Claude confronta il tuo compito con le descrizioni delle skill per decidere quali sono rilevanti. Se le descrizioni sono vaghe o si sovrappongono, Claude potrebbe caricare la skill sbagliata o tralasciarne una che sarebbe utile. Per dire a Claude di utilizzare una skill specifica, invocala con `/<name>`.

262 

263**Costo del contesto:** Basso fino a quando non vengono utilizzate. Le skills solo utente hanno costo zero fino a quando non vengono invocate.

264 

265**Nei subagent:** Il contenuto completo delle skill elencate nel campo `skills` di un subagent [si carica nel suo contesto all'avvio](https://code.claude.com/docs/it/sub-agents.md#preload-skills-into-subagents), anziché su richiesta. I subagent possono comunque scoprire e invocare skill di progetto, utente e plugin non elencate attraverso lo strumento Skill.

266 

267> [!TIP]

268>244>

269> Utilizza `disable-model-invocation: true` per le skill con effetti collaterali. Questo risparmia contesto e assicura che vengano eseguite solo quando le richiami per nome.245> **Cosa si carica:** Contenuto completo di ogni file CLAUDE.md che si carica all'inizio della sessione (livelli gestito, utente e progetto).

270 

271**Server MCP**

272 

273**Quando:** Inizio della sessione.

274 

275**Cosa si carica:** Nomi degli strumenti e istruzioni del server dai server connessi. Gli schemi JSON completi rimangono rinviati fino a quando Claude non ha bisogno di uno strumento specifico.

276 

277**Costo del contesto:** [Ricerca degli strumenti](https://code.claude.com/docs/it/mcp.md#scale-with-mcp-tool-search) è abilitata per impostazione predefinita, quindi gli strumenti MCP inattivi consumano contesto minimo.

278 

279> [!TIP]

280>246>

281> Eseguite `/mcp` per vedere lo stato della connessione di ogni server. Eseguite `/context all` per vedere quanti token utilizza ogni strumento MCP caricato. Claude Code [si riconnette automaticamente ai server remoti](https://code.claude.com/docs/it/mcp.md#automatic-reconnection) se si disconnettono, e potete disconnettere i server che non state utilizzando attivamente.247> **Eredità:** Claude legge i file CLAUDE.md dalla tua directory di lavoro fino alla radice e scopre quelli annidati nelle sottodirectory mentre accede a quei file. Consulta [Come si caricano i file CLAUDE.md](https://code.claude.com/docs/it/memory.md#how-claude-md-files-load) per i dettagli. Se un CLAUDE.md annidato supera il suo [limite di dimensione per file](https://code.claude.com/docs/it/memory.md#claude-ignores-the-end-of-my-subdirectory-claude-md), Claude riceve solo l'inizio del file.

282 

283**Code intelligence**

284 

285**Quando:** Dopo le modifiche ai file e su richiesta quando Claude naviga il codice.

286 

287**Cosa si carica:** Errori di tipo e avvisi dopo ogni modifica ai file. Informazioni di definizione, riferimento e tipo quando Claude cerca un simbolo.

288 

289**Costo del contesto:** Basso. Le ricerche di simboli spesso sostituiscono letture di file ampie, quindi l'uso netto del contesto può diminuire.

290 

291> [!TIP]

292>248>

293> Lo strumento LSP è inattivo fino a quando non installate un [plugin di code intelligence](https://code.claude.com/docs/it/plugins/code-intelligence.md) per il vostro linguaggio.249> > [!TIP]

294 250> >

295**Subagents**251> > Mantenete CLAUDE.md sotto 200 righe. Spostate il materiale di riferimento in skills, che si caricano su richiesta. Per ottenere [proposte di ridimensionamento per un CLAUDE.md archiviato](https://code.claude.com/docs/it/memory.md#my-claude-md-is-too-large), eseguite `/doctor`.

296 

297**Quando:** Su richiesta, quando voi o Claude ne generate uno per un compito.

298 

299**Cosa si carica:** Contesto nuovo e isolato contenente:

300 

301* Il prompt di sistema dell'agente, non il prompt di sistema di Claude Code

302* Contenuto completo delle skill elencate nel campo `skills:` dell'agente

303* CLAUDE.md e stato git. Gli agenti integrati Explore e Plan [non partono con nessuno dei due](https://code.claude.com/docs/it/sub-agents.md#what-loads-at-startup), e un agente la cui definizione imposta [`omitClaudeMd`](https://code.claude.com/docs/it/sub-agents#supported-frontmatter-fields) parte senza i file CLAUDE.md utente, di progetto e locale.

304* Qualsiasi contesto che l'agente principale passa nel prompt

305 

306Per un [fork](https://code.claude.com/docs/it/sub-agents.md#fork-the-current-conversation), Claude Code carica la conversazione del genitore fino a quel momento, il prompt di sistema e gli strumenti invece.

307 

308**Costo del contesto:** Isolato dalla sessione principale.

309 252 

310> [!TIP]253> [tab] Skills

311>254>

312> Utilizzate i subagents per il lavoro che non ha bisogno del vostro contesto di conversazione completo. Il loro isolamento previene il gonfiore della vostra sessione principale.255> Le skills sono capacità extra nel toolkit di Claude. Possono essere materiale di riferimento (come una guida di stile API) o flussi di lavoro invocabili che attivate con `/<name>` (come `/deploy`). Claude Code include [skills raggruppate](https://code.claude.com/docs/it/commands.md) come `/code-review`, `/batch` e `/debug` che funzionano subito. Potete anche crearne di vostre.

313 256>

314**Hooks**257> **Quando:** Dipende dalla configurazione della skill. Per impostazione predefinita, le descrizioni si caricano all'inizio della sessione e il contenuto completo si carica quando utilizzate. Per le skills solo utente (`disable-model-invocation: true`), niente si carica fino a quando non le invocate.

258>

259> **Cosa si carica:** Per le skills invocabili dal modello, Claude vede nomi e descrizioni in ogni richiesta. Quando invocate una skill con `/<name>` o Claude la carica automaticamente, il contenuto completo si carica nella vostra conversazione.

260>

261> **Come Claude sceglie le skill:** Claude confronta il tuo compito con le descrizioni delle skill per decidere quali sono rilevanti. Se le descrizioni sono vaghe o si sovrappongono, Claude potrebbe caricare la skill sbagliata o tralasciarne una che sarebbe utile. Per dire a Claude di utilizzare una skill specifica, invocala con `/<name>`.

262>

263> **Costo del contesto:** Basso fino a quando non vengono utilizzate. Le skills solo utente hanno costo zero fino a quando non vengono invocate.

264>

265> **Nei subagent:** Il contenuto completo delle skill elencate nel campo `skills` di un subagent [si carica nel suo contesto all'avvio](https://code.claude.com/docs/it/sub-agents.md#preload-skills-into-subagents), anziché su richiesta. I subagent possono comunque scoprire e invocare skill di progetto, utente e plugin non elencate attraverso lo strumento Skill.

266>

267> > [!TIP]

268> >

269> > Utilizza `disable-model-invocation: true` per le skill con effetti collaterali. Questo risparmia contesto e assicura che vengano eseguite solo quando le richiami per nome.

315 270 

316**Quando:** Al trigger. Claude Code esegue gli hooks su eventi del ciclo di vita specifici come esecuzione dello strumento, confini della sessione, invio del prompt, richieste di autorizzazione e compattazione. Consultate [Hooks](https://code.claude.com/docs/it/hooks.md) per l'elenco completo.271> [tab] Server MCP

272>

273> **Quando:** Inizio della sessione.

274>

275> **Cosa si carica:** Nomi degli strumenti e istruzioni del server dai server connessi. Gli schemi JSON completi rimangono rinviati fino a quando Claude non ha bisogno di uno strumento specifico.

276>

277> **Costo del contesto:** [Ricerca degli strumenti](https://code.claude.com/docs/it/mcp.md#scale-with-mcp-tool-search) è abilitata per impostazione predefinita, quindi gli strumenti MCP inattivi consumano contesto minimo.

278>

279> > [!TIP]

280> >

281> > Eseguite `/mcp` per vedere lo stato della connessione di ogni server. Eseguite `/context all` per vedere quanti token utilizza ogni strumento MCP caricato. Claude Code [si riconnette automaticamente ai server remoti](https://code.claude.com/docs/it/mcp.md#automatic-reconnection) se si disconnettono, e potete disconnettere i server che non state utilizzando attivamente.

317 282 

318**Cosa si carica:** Niente per impostazione predefinita. Gli hooks vengono eseguiti al di fuori della conversazione principale.283> [tab] Code intelligence

284>

285> **Quando:** Dopo le modifiche ai file e su richiesta quando Claude naviga il codice.

286>

287> **Cosa si carica:** Errori di tipo e avvisi dopo ogni modifica ai file. Informazioni di definizione, riferimento e tipo quando Claude cerca un simbolo.

288>

289> **Costo del contesto:** Basso. Le ricerche di simboli spesso sostituiscono letture di file ampie, quindi l'uso netto del contesto può diminuire.

290>

291> > [!TIP]

292> >

293> > Lo strumento LSP è inattivo fino a quando non installate un [plugin di code intelligence](https://code.claude.com/docs/it/plugins/code-intelligence.md) per il vostro linguaggio.

319 294 

320**Costo del contesto:** Zero, a meno che l'hook non restituisca output che viene aggiunto come messaggi alla vostra conversazione.295> [tab] Subagents

296>

297> **Quando:** Su richiesta, quando voi o Claude ne generate uno per un compito.

298>

299> **Cosa si carica:** Contesto nuovo e isolato contenente:

300>

301> * Il prompt di sistema dell'agente, non il prompt di sistema di Claude Code

302> * Contenuto completo delle skill elencate nel campo `skills:` dell'agente

303> * CLAUDE.md e stato git. Gli agenti integrati Explore e Plan [non partono con nessuno dei due](https://code.claude.com/docs/it/sub-agents.md#what-loads-at-startup), e un agente la cui definizione imposta [`omitClaudeMd`](https://code.claude.com/docs/it/sub-agents#supported-frontmatter-fields) parte senza i file CLAUDE.md utente, di progetto e locale.

304> * Qualsiasi contesto che l'agente principale passa nel prompt

305>

306> Per un [fork](https://code.claude.com/docs/it/sub-agents.md#fork-the-current-conversation), Claude Code carica la conversazione del genitore fino a quel momento, il prompt di sistema e gli strumenti invece.

307>

308> **Costo del contesto:** Isolato dalla sessione principale.

309>

310> > [!TIP]

311> >

312> > Utilizzate i subagents per il lavoro che non ha bisogno del vostro contesto di conversazione completo. Il loro isolamento previene il gonfiore della vostra sessione principale.

321 313 

322> [!TIP]314> [tab] Hooks

315>

316> **Quando:** Al trigger. Claude Code esegue gli hooks su eventi del ciclo di vita specifici come esecuzione dello strumento, confini della sessione, invio del prompt, richieste di autorizzazione e compattazione. Consultate [Hooks](https://code.claude.com/docs/it/hooks.md) per l'elenco completo.

317>

318> **Cosa si carica:** Niente per impostazione predefinita. Gli hooks vengono eseguiti al di fuori della conversazione principale.

319>

320> **Costo del contesto:** Zero, a meno che l'hook non restituisca output che viene aggiunto come messaggi alla vostra conversazione.

323>321>

324> Gli hooks sono ideali per effetti collaterali (linting, logging) che non hanno bisogno di influenzare il contesto di Claude.322> > [!TIP]

323> >

324> > Gli hooks sono ideali per effetti collaterali (linting, logging) che non hanno bisogno di influenzare il contesto di Claude.

325 325 

326## Scopri di più326## Scopri di più

327 327 

328Ogni funzionalità ha la sua propria guida con istruzioni di configurazione, esempi e opzioni di configurazione.328Ogni funzionalità ha la sua propria guida con istruzioni di configurazione, esempi e opzioni di configurazione.

329 329 

330> **[CLAUDE.md](https://code.claude.com/docs/it/memory.md)**330> [card] [CLAUDE.md](https://code.claude.com/docs/it/memory.md)

331>331>

332> Memorizzate il contesto del progetto, le convenzioni e le istruzioni332> Memorizzate il contesto del progetto, le convenzioni e le istruzioni

333 333 

334> **[Skills](https://code.claude.com/docs/it/skills.md)**334> [card] [Skills](https://code.claude.com/docs/it/skills.md)

335>335>

336> Date a Claude competenze di dominio e flussi di lavoro riutilizzabili336> Date a Claude competenze di dominio e flussi di lavoro riutilizzabili

337 337 

338> **[Subagents](https://code.claude.com/docs/it/sub-agents.md)**338> [card] [Subagents](https://code.claude.com/docs/it/sub-agents.md)

339>339>

340> Delegate il lavoro a contesto isolato340> Delegate il lavoro a contesto isolato

341 341 

342> **[Dynamic workflows](https://code.claude.com/docs/it/workflows.md)**342> [card] [Dynamic workflows](https://code.claude.com/docs/it/workflows.md)

343>343>

344> Eseguite molti subagent da uno script344> Eseguite molti subagent da uno script

345 345 

346> **[Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md)**346> [card] [Cross-session messaging](https://code.claude.com/docs/it/cross-session-messaging.md)

347>347>

348> Lasciate che Claude messaggi le vostre altre sessioni348> Lasciate che Claude messaggi le vostre altre sessioni

349 349 

350> **[MCP](https://code.claude.com/docs/it/mcp.md)**350> [card] [MCP](https://code.claude.com/docs/it/mcp.md)

351>351>

352> Collegate Claude a servizi esterni352> Collegate Claude a servizi esterni

353 353 

354> **[Hooks](https://code.claude.com/docs/it/hooks-guide.md)**354> [card] [Hooks](https://code.claude.com/docs/it/hooks-guide.md)

355>355>

356> Automatizzate i flussi di lavoro con gli hooks356> Automatizzate i flussi di lavoro con gli hooks

357 357 

358> **[Plugins](https://code.claude.com/docs/it/plugins/overview.md)**358> [card] [Plugins](https://code.claude.com/docs/it/plugins/overview.md)

359>359>

360> Confezionate e condividete set di funzionalità360> Confezionate e condividete set di funzionalità

361 361 

362> **[Marketplaces](https://code.claude.com/docs/it/plugins/create-marketplace.md)**362> [card] [Marketplaces](https://code.claude.com/docs/it/plugins/create-marketplace.md)

363>363>

364> Ospitate e distribuite raccolte di plugin364> Ospitate e distribuite raccolte di plugin

Details

74Aggiungi uno dei seguenti secret al tuo repository, a seconda di come ti autentichi. Vedi la guida di GitHub su [utilizzo dei secret in GitHub Actions](https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions).74Aggiungi uno dei seguenti secret al tuo repository, a seconda di come ti autentichi. Vedi la guida di GitHub su [utilizzo dei secret in GitHub Actions](https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions).

75 75 

76* `ANTHROPIC_API_KEY`: una chiave API Claude dalla [Claude Console](https://platform.claude.com)76* `ANTHROPIC_API_KEY`: una chiave API Claude dalla [Claude Console](https://platform.claude.com)

77* `CLAUDE_CODE_OAUTH_TOKEN`: un token OAuth che si autentica con la tua sottoscrizione Claude, disponibile su piani Pro, Max, Team ed Enterprise. Generane uno eseguendo `claude setup-token` localmente. Vedi [Genera un token di lunga durata](https://code.claude.com/docs/it/authentication.md#generate-a-long-lived-token)77* `CLAUDE_CODE_OAUTH_TOKEN`: un token OAuth che si autentica con il tuo abbonamento Claude, disponibile sui piani Pro, Max, Ultra, Team ed Enterprise. Generane uno eseguendo `claude setup-token` localmente. Vedi [Genera un token di lunga durata](https://code.claude.com/docs/it/authentication.md#generate-a-long-lived-token)

78 78 

79Nei file di flusso di lavoro, passa il secret all'input corrispondente: `anthropic_api_key` per una chiave API, o `claude_code_oauth_token` per un token OAuth.79Nei file di flusso di lavoro, passa il secret all'input corrispondente: `anthropic_api_key` per una chiave API, o `claude_code_oauth_token` per un token OAuth.

80 80 

Details

59 59 

60Configura il tuo cloud per fidarsi del token OIDC che GitHub emette al workflow, in modo che ogni esecuzione del workflow ottenga credenziali cloud di breve durata. I punti elenco in ogni scheda riassumono cosa creare, e ogni scheda collega la guida del fornitore cloud per i passaggi a livello di console.60Configura il tuo cloud per fidarsi del token OIDC che GitHub emette al workflow, in modo che ogni esecuzione del workflow ottenga credenziali cloud di breve durata. I punti elenco in ogni scheda riassumono cosa creare, e ogni scheda collega la guida del fornitore cloud per i passaggi a livello di console.

61 61 

62**Amazon Bedrock**62> [tab] Amazon Bedrock

63 63>

64Crea la configurazione della fiducia nel tuo account AWS, seguendo la [guida AWS per la creazione di provider di identità OIDC](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html):64> Crea la configurazione della fiducia nel tuo account AWS, seguendo la [guida AWS per la creazione di provider di identità OIDC](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html):

65 65>

66* Aggiungi un provider di identità OIDC GitHub con URL del provider `https://token.actions.githubusercontent.com` e audience `sts.amazonaws.com`66> * Aggiungi un provider di identità OIDC GitHub con URL del provider `https://token.actions.githubusercontent.com` e audience `sts.amazonaws.com`

67* Crea un ruolo IAM di cui il provider si fida come identità web, e allega la politica di invocazione con ambito dalla [configurazione IAM](https://code.claude.com/docs/it/amazon-bedrock.md#iam-configuration), che concede `bedrock:InvokeModel`, `bedrock:InvokeModelWithResponseStream`, `bedrock:ListInferenceProfiles`, e `bedrock:GetInferenceProfile`, insieme a due azioni di sottoscrizione `aws-marketplace`67> * Crea un ruolo IAM di cui il provider si fida come identità web, e allega la politica di invocazione con ambito dalla [configurazione IAM](https://code.claude.com/docs/it/amazon-bedrock.md#iam-configuration), che concede `bedrock:InvokeModel`, `bedrock:InvokeModelWithResponseStream`, `bedrock:ListInferenceProfiles`, e `bedrock:GetInferenceProfile`, insieme a due azioni di sottoscrizione `aws-marketplace`

68* Limita la politica di fiducia del ruolo al tuo repository con una condizione di soggetto come `repo:your-org/your-repo:*`. Vedi la [guida di hardening OIDC di GitHub](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect) per il formato del claim68> * Limita la politica di fiducia del ruolo al tuo repository con una condizione di soggetto come `repo:your-org/your-repo:*`. Vedi la [guida di hardening OIDC di GitHub](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect) per il formato del claim

69 69>

70Annota l'ARN del ruolo. Lo aggiungerai come segreto nel passaggio successivo.70> Annota l'ARN del ruolo. Lo aggiungerai come segreto nel passaggio successivo.

71 

72**Google Cloud's Agent Platform**

73 

74Crea le risorse di federazione nel tuo progetto Google Cloud, seguendo la [documentazione di Workload Identity Federation](https://cloud.google.com/iam/docs/workload-identity-federation):

75 

76* Abilita tre API: IAM Credentials, Security Token Service (STS), e l'API Agent Platform, il cui nome del servizio è `aiplatform.googleapis.com`

77* Crea un Workload Identity Pool con un provider OIDC GitHub il cui emittente è `https://token.actions.githubusercontent.com`, e aggiungi una condizione di attributo che limita il pool al tuo repository

78* Crea un account di servizio dedicato con solo il ruolo `Vertex AI User`, che è `roles/aiplatform.user`, e consenti al pool di rappresentarlo

79 

80Annota il nome della risorsa completa del provider e l'indirizzo email dell'account di servizio. Li aggiungerai come segreti nel passaggio successivo.

81 

82**Microsoft Foundry**

83 

84Crea un'applicazione Microsoft Entra con una credenziale federata per il tuo repository, seguendo [la guida di Microsoft per l'autenticazione da GitHub Actions](https://learn.microsoft.com/en-us/azure/developer/github/connect-from-azure-openid-connect):

85 71 

86* Registra un'applicazione Microsoft Entra e aggiungi una credenziale di identità federata che si fida dei token che GitHub emette al tuo repository. Un'identità gestita assegnata dall'utente funziona al posto di un'applicazione. Entrambe hanno l'ID client che annoti di seguito72> [tab] Google Cloud's Agent Platform

87* Assegna all'applicazione il ruolo `Azure AI User` sulla tua risorsa Foundry. Vedi [configurazione RBAC di Azure](https://code.claude.com/docs/it/microsoft-foundry.md#azure-rbac-configuration) per un ruolo personalizzato più ristretto73>

74> Crea le risorse di federazione nel tuo progetto Google Cloud, seguendo la [documentazione di Workload Identity Federation](https://cloud.google.com/iam/docs/workload-identity-federation):

75>

76> * Abilita tre API: IAM Credentials, Security Token Service (STS), e l'API Agent Platform, il cui nome del servizio è `aiplatform.googleapis.com`

77> * Crea un Workload Identity Pool con un provider OIDC GitHub il cui emittente è `https://token.actions.githubusercontent.com`, e aggiungi una condizione di attributo che limita il pool al tuo repository

78> * Crea un account di servizio dedicato con solo il ruolo `Vertex AI User`, che è `roles/aiplatform.user`, e consenti al pool di rappresentarlo

79>

80> Annota il nome della risorsa completa del provider e l'indirizzo email dell'account di servizio. Li aggiungerai come segreti nel passaggio successivo.

88 81 

89Annota l'ID client dell'applicazione, il tuo ID tenant e il tuo ID sottoscrizione. Li aggiungerai come segreti nel passaggio successivo.82> [tab] Microsoft Foundry

83>

84> Crea un'applicazione Microsoft Entra con una credenziale federata per il tuo repository, seguendo [la guida di Microsoft per l'autenticazione da GitHub Actions](https://learn.microsoft.com/en-us/azure/developer/github/connect-from-azure-openid-connect):

85>

86> * Registra un'applicazione Microsoft Entra e aggiungi una credenziale di identità federata che si fida dei token che GitHub emette al tuo repository. Un'identità gestita assegnata dall'utente funziona al posto di un'applicazione. Entrambe hanno l'ID client che annoti di seguito

87> * Assegna all'applicazione il ruolo `Azure AI User` sulla tua risorsa Foundry. Vedi [configurazione RBAC di Azure](https://code.claude.com/docs/it/microsoft-foundry.md#azure-rbac-configuration) per un ruolo personalizzato più ristretto

88>

89> Annota l'ID client dell'applicazione, il tuo ID tenant e il tuo ID sottoscrizione. Li aggiungerai come segreti nel passaggio successivo.

90 90 

91**3. Aggiungere i segreti del repository**91**3. Aggiungere i segreti del repository**

92 92 

116>116>

117> Nei repository pubblici, un commento contenente la frase di attivazione da qualsiasi utente avvia questo workflow. I passaggi delle credenziali vengono eseguiti prima che l'azione GitHub di Claude Code verifichi l'accesso in scrittura del commentatore, quindi l'azione rifiuta gli utenti non autorizzati solo dopo che il workflow ha generato un token dell'app e ha effettuato l'accesso al tuo provider cloud, il che lascia voci nel registro di audit e consuma minuti di Actions. Per evitare queste esecuzioni, aggiungi un passaggio che verifica l'accesso in scrittura del commentatore prima dei passaggi delle credenziali.117> Nei repository pubblici, un commento contenente la frase di attivazione da qualsiasi utente avvia questo workflow. I passaggi delle credenziali vengono eseguiti prima che l'azione GitHub di Claude Code verifichi l'accesso in scrittura del commentatore, quindi l'azione rifiuta gli utenti non autorizzati solo dopo che il workflow ha generato un token dell'app e ha effettuato l'accesso al tuo provider cloud, il che lascia voci nel registro di audit e consuma minuti di Actions. Per evitare queste esecuzioni, aggiungi un passaggio che verifica l'accesso in scrittura del commentatore prima dei passaggi delle credenziali.

118 118 

119**Amazon Bedrock**119> [tab] Amazon Bedrock

120 120>

121Sostituisci il valore `aws-region` con il tuo. Il passaggio delle credenziali lo esporta come `AWS_REGION` per il resto del job.121> Sostituisci il valore `aws-region` con il tuo. Il passaggio delle credenziali lo esporta come `AWS_REGION` per il resto del job.

122 122>

123```yaml theme={null}123> ```yaml theme={null}

124name: Claude PR Action124> name: Claude PR Action

125 125>

126permissions:126> permissions:

127 contents: write127> contents: write

128 pull-requests: write128> pull-requests: write

129 issues: write129> issues: write

130 id-token: write130> id-token: write

131 131>

132on:132> on:

133 issue_comment:133> issue_comment:

134 types: [created]134> types: [created]

135 pull_request_review_comment:135> pull_request_review_comment:

136 types: [created]136> types: [created]

137 issues:137> issues:

138 types: [opened]138> types: [opened]

139 139>

140jobs:140> jobs:

141 claude-pr:141> claude-pr:

142 if: |142> if: |

143 (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||143> (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||

144 (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||144> (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||

145 (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))145> (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))

146 runs-on: ubuntu-latest146> runs-on: ubuntu-latest

147 steps:147> steps:

148 - name: Checkout repository148> - name: Checkout repository

149 uses: actions/checkout@v6149> uses: actions/checkout@v6

150 150>

151 - name: Generate GitHub App token151> - name: Generate GitHub App token

152 id: app-token152> id: app-token

153 uses: actions/create-github-app-token@v2153> uses: actions/create-github-app-token@v2

154 with:154> with:

155 app-id: ${{ secrets.APP_ID }}155> app-id: ${{ secrets.APP_ID }}

156 private-key: ${{ secrets.APP_PRIVATE_KEY }}156> private-key: ${{ secrets.APP_PRIVATE_KEY }}

157 157>

158 - name: Configure AWS Credentials (OIDC)158> - name: Configure AWS Credentials (OIDC)

159 uses: aws-actions/configure-aws-credentials@v4159> uses: aws-actions/configure-aws-credentials@v4

160 with:160> with:

161 role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}161> role-to-assume: ${{ secrets.AWS_ROLE_TO_ASSUME }}

162 aws-region: us-west-2162> aws-region: us-west-2

163 163>

164 - uses: anthropics/claude-code-action@v1164> - uses: anthropics/claude-code-action@v1

165 with:165> with:

166 github_token: ${{ steps.app-token.outputs.token }}166> github_token: ${{ steps.app-token.outputs.token }}

167 use_bedrock: "true"167> use_bedrock: "true"

168 claude_args: '--model us.anthropic.claude-sonnet-4-6'168> claude_args: '--model us.anthropic.claude-sonnet-4-6'

169```169> ```

170 170>

171> [!TIP]171> > [!TIP]

172>172> >

173> Gli ID dei modelli Bedrock includono un prefisso del profilo di inferenza tra regioni come `us.`. Usa il prefisso per il gruppo di regioni dove hai concesso l'accesso al modello.173> > Gli ID dei modelli Bedrock includono un prefisso del profilo di inferenza tra regioni come `us.`. Usa il prefisso per il gruppo di regioni dove hai concesso l'accesso al modello.

174 174 

175**Google Cloud's Agent Platform**175> [tab] Google Cloud's Agent Platform

176 176>

177Sostituisci il valore `CLOUD_ML_REGION` con il tuo. Non è necessario codificare l'ID del progetto, perché il workflow lo legge dall'output del passaggio `auth`.177> Sostituisci il valore `CLOUD_ML_REGION` con il tuo. Non è necessario codificare l'ID del progetto, perché il workflow lo legge dall'output del passaggio `auth`.

178 178>

179```yaml theme={null}179> ```yaml theme={null}

180name: Claude PR Action180> name: Claude PR Action

181 181>

182permissions:182> permissions:

183 contents: write183> contents: write

184 pull-requests: write184> pull-requests: write

185 issues: write185> issues: write

186 id-token: write186> id-token: write

187 187>

188on:188> on:

189 issue_comment:189> issue_comment:

190 types: [created]190> types: [created]

191 pull_request_review_comment:191> pull_request_review_comment:

192 types: [created]192> types: [created]

193 issues:193> issues:

194 types: [opened]194> types: [opened]

195 195>

196jobs:196> jobs:

197 claude-pr:197> claude-pr:

198 if: |198> if: |

199 (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||199> (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||

200 (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||200> (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||

201 (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))201> (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))

202 runs-on: ubuntu-latest202> runs-on: ubuntu-latest

203 steps:203> steps:

204 - name: Checkout repository204> - name: Checkout repository

205 uses: actions/checkout@v6205> uses: actions/checkout@v6

206 206>

207 - name: Generate GitHub App token207> - name: Generate GitHub App token

208 id: app-token208> id: app-token

209 uses: actions/create-github-app-token@v2209> uses: actions/create-github-app-token@v2

210 with:210> with:

211 app-id: ${{ secrets.APP_ID }}211> app-id: ${{ secrets.APP_ID }}

212 private-key: ${{ secrets.APP_PRIVATE_KEY }}212> private-key: ${{ secrets.APP_PRIVATE_KEY }}

213 213>

214 - name: Authenticate to Google Cloud214> - name: Authenticate to Google Cloud

215 id: auth215> id: auth

216 uses: google-github-actions/auth@v2216> uses: google-github-actions/auth@v2

217 with:217> with:

218 workload_identity_provider: ${{ secrets.GCP_WORKLOAD_IDENTITY_PROVIDER }}218> workload_identity_provider: ${{ secrets.GCP_WORKLOAD_IDENTITY_PROVIDER }}

219 service_account: ${{ secrets.GCP_SERVICE_ACCOUNT }}219> service_account: ${{ secrets.GCP_SERVICE_ACCOUNT }}

220 220>

221 - uses: anthropics/claude-code-action@v1221> - uses: anthropics/claude-code-action@v1

222 with:222> with:

223 github_token: ${{ steps.app-token.outputs.token }}223> github_token: ${{ steps.app-token.outputs.token }}

224 use_vertex: "true"224> use_vertex: "true"

225 claude_args: '--model claude-sonnet-5'225> claude_args: '--model claude-sonnet-5'

226 env:226> env:

227 ANTHROPIC_VERTEX_PROJECT_ID: ${{ steps.auth.outputs.project_id }}227> ANTHROPIC_VERTEX_PROJECT_ID: ${{ steps.auth.outputs.project_id }}

228 CLOUD_ML_REGION: us-east5228> CLOUD_ML_REGION: us-east5

229```229> ```

230 230 

231**Microsoft Foundry**231> [tab] Microsoft Foundry

232 232>

233Sostituisci `your-resource-name` con il nome della tua risorsa Foundry. Claude Code costruisce l'URL dell'endpoint da esso. Il passaggio `azure/login` effettua l'accesso con il token OIDC del workflow, e Claude Code raccoglie le credenziali attraverso la [catena di credenziali predefinita](https://learn.microsoft.com/en-us/azure/developer/javascript/sdk/authentication/credential-chains#defaultazurecredential-overview) di Azure.233> Sostituisci `your-resource-name` con il nome della tua risorsa Foundry. Claude Code costruisce l'URL dell'endpoint da esso. Il passaggio `azure/login` effettua l'accesso con il token OIDC del workflow, e Claude Code raccoglie le credenziali attraverso la [catena di credenziali predefinita](https://learn.microsoft.com/en-us/azure/developer/javascript/sdk/authentication/credential-chains#defaultazurecredential-overview) di Azure.

234 234>

235```yaml theme={null}235> ```yaml theme={null}

236name: Claude PR Action236> name: Claude PR Action

237 237>

238permissions:238> permissions:

239 contents: write239> contents: write

240 pull-requests: write240> pull-requests: write

241 issues: write241> issues: write

242 id-token: write242> id-token: write

243 243>

244on:244> on:

245 issue_comment:245> issue_comment:

246 types: [created]246> types: [created]

247 pull_request_review_comment:247> pull_request_review_comment:

248 types: [created]248> types: [created]

249 issues:249> issues:

250 types: [opened]250> types: [opened]

251 251>

252jobs:252> jobs:

253 claude-pr:253> claude-pr:

254 if: |254> if: |

255 (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||255> (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||

256 (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||256> (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||

257 (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))257> (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))

258 runs-on: ubuntu-latest258> runs-on: ubuntu-latest

259 steps:259> steps:

260 - name: Checkout repository260> - name: Checkout repository

261 uses: actions/checkout@v6261> uses: actions/checkout@v6

262 262>

263 - name: Generate GitHub App token263> - name: Generate GitHub App token

264 id: app-token264> id: app-token

265 uses: actions/create-github-app-token@v2265> uses: actions/create-github-app-token@v2

266 with:266> with:

267 app-id: ${{ secrets.APP_ID }}267> app-id: ${{ secrets.APP_ID }}

268 private-key: ${{ secrets.APP_PRIVATE_KEY }}268> private-key: ${{ secrets.APP_PRIVATE_KEY }}

269 269>

270 - name: Authenticate to Azure270> - name: Authenticate to Azure

271 uses: azure/login@v2271> uses: azure/login@v2

272 with:272> with:

273 client-id: ${{ secrets.AZURE_CLIENT_ID }}273> client-id: ${{ secrets.AZURE_CLIENT_ID }}

274 tenant-id: ${{ secrets.AZURE_TENANT_ID }}274> tenant-id: ${{ secrets.AZURE_TENANT_ID }}

275 subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}275> subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

276 276>

277 - uses: anthropics/claude-code-action@v1277> - uses: anthropics/claude-code-action@v1

278 with:278> with:

279 github_token: ${{ steps.app-token.outputs.token }}279> github_token: ${{ steps.app-token.outputs.token }}

280 use_foundry: "true"280> use_foundry: "true"

281 claude_args: '--model claude-sonnet-5'281> claude_args: '--model claude-sonnet-5'

282 env:282> env:

283 ANTHROPIC_FOUNDRY_RESOURCE: your-resource-name283> ANTHROPIC_FOUNDRY_RESOURCE: your-resource-name

284```284> ```

285 285>

286> [!TIP]286> > [!TIP]

287>287> >

288> Usa un ID modello che corrisponda a un deployment di Claude nella tua risorsa Foundry. Vedi [Claude Code su Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md) per la configurazione del modello e il pinning della versione.288> > Usa un ID modello che corrisponda a un deployment di Claude nella tua risorsa Foundry. Vedi [Claude Code su Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md) per la configurazione del modello e il pinning della versione.

289 289 

290Con qualsiasi provider, puoi limitare la durata dell'esecuzione e il costo aggiungendo `--max-turns` a `claude_args`. Vedi [Gestire i costi](https://code.claude.com/docs/it/github-actions.md#manage-costs).290Con qualsiasi provider, puoi limitare la durata dell'esecuzione e il costo aggiungendo `--max-turns` a `claude_args`. Vedi [Gestire i costi](https://code.claude.com/docs/it/github-actions.md#manage-costs).

291 291 

gitlab-ci-cd.md +52 −52

Details

158 158 

159Per gli ambienti aziendali, è possibile eseguire Claude Code interamente sull'infrastruttura cloud con la stessa esperienza di sviluppo.159Per gli ambienti aziendali, è possibile eseguire Claude Code interamente sull'infrastruttura cloud con la stessa esperienza di sviluppo.

160 160 

161**Amazon Bedrock**161> [tab] Amazon Bedrock

162 162>

163### Prerequisiti163> ### Prerequisiti

164 164>

165Prima di configurare Claude Code con Amazon Bedrock, è necessario disporre di:165> Prima di configurare Claude Code con Amazon Bedrock, è necessario disporre di:

166 166>

1671. Un account AWS con accesso ad Amazon Bedrock per i modelli Claude desiderati167> 1. Un account AWS con accesso ad Amazon Bedrock per i modelli Claude desiderati

1682. GitLab configurato come provider di identità OIDC in AWS IAM168> 2. GitLab configurato come provider di identità OIDC in AWS IAM

1693. Un ruolo IAM con autorizzazioni Amazon Bedrock e una politica di trust limitata al progetto/refs di GitLab169> 3. Un ruolo IAM con autorizzazioni Amazon Bedrock e una politica di trust limitata al progetto/refs di GitLab

1704. Variabili CI/CD di GitLab per l'assunzione del ruolo:170> 4. Variabili CI/CD di GitLab per l'assunzione del ruolo:

171 * `AWS_ROLE_TO_ASSUME` (ARN del ruolo)171> * `AWS_ROLE_TO_ASSUME` (ARN del ruolo)

172 * `AWS_REGION` (regione Amazon Bedrock)172> * `AWS_REGION` (regione Amazon Bedrock)

173 173>

174### Istruzioni di configurazione174> ### Istruzioni di configurazione

175 175>

176Configurare AWS per consentire ai job CI di GitLab di assumere un ruolo IAM tramite OIDC (senza chiavi statiche).176> Configurare AWS per consentire ai job CI di GitLab di assumere un ruolo IAM tramite OIDC (senza chiavi statiche).

177 177>

178**Configurazione richiesta:**178> **Configurazione richiesta:**

179 179>

1801. Abilitare Amazon Bedrock e richiedere l'accesso ai modelli Claude di destinazione180> 1. Abilitare Amazon Bedrock e richiedere l'accesso ai modelli Claude di destinazione

1812. Creare un provider OIDC IAM per GitLab se non già presente181> 2. Creare un provider OIDC IAM per GitLab se non già presente

1823. Creare un ruolo IAM considerato attendibile dal provider OIDC di GitLab, limitato al progetto e ai refs protetti182> 3. Creare un ruolo IAM considerato attendibile dal provider OIDC di GitLab, limitato al progetto e ai refs protetti

1834. Allegare autorizzazioni con privilegi minimi per le API di invocazione di Amazon Bedrock183> 4. Allegare autorizzazioni con privilegi minimi per le API di invocazione di Amazon Bedrock

184 184>

185Utilizzare l'[esempio di job Amazon Bedrock](#configuration-examples) per scambiare il token OIDC del job con credenziali AWS temporanee in fase di esecuzione.185> Utilizzare l'[esempio di job Amazon Bedrock](#configuration-examples) per scambiare il token OIDC del job con credenziali AWS temporanee in fase di esecuzione.

186 

187**Google Cloud's Agent Platform**

188 

189### Prerequisiti

190 

191Prima di configurare Claude Code con Google Cloud's Agent Platform, è necessario disporre di:

192 

1931. Un progetto Google Cloud con:

194 * API di Google Cloud's Agent Platform abilitata

195 * Workload Identity Federation configurata per considerare attendibile OIDC di GitLab

1962. Un account di servizio dedicato con solo i ruoli Google Cloud's Agent Platform richiesti

1973. Variabili CI/CD di GitLab:

198 * `GCP_WORKLOAD_IDENTITY_PROVIDER` (nome della risorsa provider senza il prefisso `//iam.googleapis.com/`, ad esempio `projects/123456789/locations/global/workloadIdentityPools/my-pool/providers/my-provider`)

199 * `GCP_SERVICE_ACCOUNT` (email dell'account di servizio)

200 * `GCP_PROJECT_ID` (ID del progetto Google Cloud)

201 

202### Istruzioni di configurazione

203 

204Configurare Google Cloud per consentire ai job CI di GitLab di rappresentare un account di servizio tramite Workload Identity Federation.

205 

206**Configurazione richiesta:**

207 

2081. Abilitare l'API IAM Credentials, l'API STS e l'API di Google Cloud's Agent Platform

2092. Creare un Workload Identity Pool e un provider per OIDC di GitLab

2103. Creare un account di servizio dedicato con i ruoli di Google Cloud's Agent Platform

2114. Concedere al principale WIF l'autorizzazione per rappresentare l'account di servizio

212 186 

213Utilizzare l'[esempio di job Agent Platform](#configuration-examples) per autenticarsi senza archiviare le chiavi.187> [tab] Google Cloud's Agent Platform

188>

189> ### Prerequisiti

190>

191> Prima di configurare Claude Code con Google Cloud's Agent Platform, è necessario disporre di:

192>

193> 1. Un progetto Google Cloud con:

194> * API di Google Cloud's Agent Platform abilitata

195> * Workload Identity Federation configurata per considerare attendibile OIDC di GitLab

196> 2. Un account di servizio dedicato con solo i ruoli Google Cloud's Agent Platform richiesti

197> 3. Variabili CI/CD di GitLab:

198> * `GCP_WORKLOAD_IDENTITY_PROVIDER` (nome della risorsa provider senza il prefisso `//iam.googleapis.com/`, ad esempio `projects/123456789/locations/global/workloadIdentityPools/my-pool/providers/my-provider`)

199> * `GCP_SERVICE_ACCOUNT` (email dell'account di servizio)

200> * `GCP_PROJECT_ID` (ID del progetto Google Cloud)

201>

202> ### Istruzioni di configurazione

203>

204> Configurare Google Cloud per consentire ai job CI di GitLab di rappresentare un account di servizio tramite Workload Identity Federation.

205>

206> **Configurazione richiesta:**

207>

208> 1. Abilitare l'API IAM Credentials, l'API STS e l'API di Google Cloud's Agent Platform

209> 2. Creare un Workload Identity Pool e un provider per OIDC di GitLab

210> 3. Creare un account di servizio dedicato con i ruoli di Google Cloud's Agent Platform

211> 4. Concedere al principale WIF l'autorizzazione per rappresentare l'account di servizio

212>

213> Utilizzare l'[esempio di job Agent Platform](#configuration-examples) per autenticarsi senza archiviare le chiavi.

214 214 

215## Esempi di configurazione215## Esempi di configurazione

216 216 

glossary.md +5 −2

Details

54 54 

55### Auto mode55### Auto mode

56 56 

57Una [permission mode](#permission-mode) in cui un modello classificatore separato esamina le azioni invece di te, così Claude Code esegue la maggior parte di esse senza chiederti. Claude Code ti chiede comunque prima delle azioni che corrispondono alle tue regole di richiesta esplicita. Con Claude Code v2.1.283 o successivo, auto mode è la [permission mode di avvio integrata](https://code.claude.com/docs/it/permission-modes.md#which-mode-a-session-starts-in) per le sessioni di terminale interattivo e VS Code, e nelle versioni precedenti solo su piani Pro, Max e Team. Il classificatore blocca l'escalation dell'ambito, l'infrastruttura non attendibile e l'[prompt injection](#prompt-injection). I risultati degli strumenti vengono rimossi da ciò che vede, quindi il contenuto ostile in un file o una pagina web non può manipolarlo direttamente.57Una [modalità di permesso](#permission-mode) in cui un modello classificatore separato esamina le azioni invece di te, così Claude Code esegue la maggior parte di esse senza chiederti. Claude Code ti chiede comunque prima delle azioni che corrispondono alle tue regole di richiesta esplicita. Il classificatore blocca l'escalation dell'ambito, l'infrastruttura non attendibile e la [prompt injection](#prompt-injection). I risultati degli strumenti vengono rimossi da ciò che vede, quindi il contenuto ostile in un file o una pagina web non può manipolarlo direttamente.

58 

59* **Claude Code v2.1.283 o successivo**: la modalità auto è la [modalità di permesso di avvio integrata](https://code.claude.com/docs/it/permission-modes.md#which-mode-a-session-starts-in) per le sessioni di terminale interattivo e VS Code

60* **Versioni precedenti**: la modalità auto è la modalità di permesso di avvio integrata solo sui piani Pro, Max, Ultra e Team

58 61 

59Scopri di più: [Eliminate prompts with auto mode](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode)62Scopri di più: [Eliminate prompts with auto mode](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode)

60 63 

140 143 

141### Dispatch144### Dispatch

142 145 

143Un router di attività avviato da telefono che genera una sessione di Claude Code nell'app Desktop quando invii un'attività di codifica dall'app mobile Claude. Il tuo prompt viene instradato automaticamente allo strumento giusto. Disponibile su piani Pro e Max.146Un router di attività avviato da telefono che genera una sessione di Claude Code nell'app Desktop quando invii un'attività di codifica dall'app mobile Claude. Il tuo prompt viene instradato automaticamente allo strumento giusto. Disponibile sui piani Pro, Max e Ultra.

144 147 

145Scopri di più: [Sessions from Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch)148Scopri di più: [Sessions from Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch)

146 149 

hooks.md +411 −411

Details

68 68 

69Per vedere come l'evento, il matcher e il gestore si combinano insieme, considerare questo hook `PreToolUse` che blocca i comandi shell distruttivi.69Per vedere come l'evento, il matcher e il gestore si combinano insieme, considerare questo hook `PreToolUse` che blocca i comandi shell distruttivi.

70 70 

71**macOS/Linux**71> [tab] macOS/Linux

72 72>

73Il `matcher` si restringe alle chiamate dello strumento Bash e la condizione `if` si restringe ulteriormente ai sottocomandi Bash che corrispondono a `rm *`, quindi `block-rm.sh` viene eseguito solo quando entrambi i filtri corrispondono:73> Il `matcher` si restringe alle chiamate dello strumento Bash e la condizione `if` si restringe ulteriormente ai sottocomandi Bash che corrispondono a `rm *`, quindi `block-rm.sh` viene eseguito solo quando entrambi i filtri corrispondono:

74 74>

75```json theme={null}75> ```json theme={null}

76{76> {

77 "hooks": {77> "hooks": {

78 "PreToolUse": [78> "PreToolUse": [

79 {79> {

80 "matcher": "Bash",80> "matcher": "Bash",

81 "hooks": [81> "hooks": [

82 {82> {

83 "type": "command",83> "type": "command",

84 "if": "Bash(rm *)",84> "if": "Bash(rm *)",

85 "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh",85> "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh",

86 "args": []86> "args": []

87 }87> }

88 ]88> ]

89 }89> }

90 ]90> ]

91 }91> }

92}92> }

93```93> ```

94 94>

95Lo script legge l'input JSON da stdin, estrae il comando e restituisce una `permissionDecision` di `"deny"` se contiene `rm -rf`. Salvarlo in `.claude/hooks/block-rm.sh` nel progetto e renderlo eseguibile con `chmod +x .claude/hooks/block-rm.sh` in modo che Claude Code possa eseguirlo:95> Lo script legge l'input JSON da stdin, estrae il comando e restituisce una `permissionDecision` di `"deny"` se contiene `rm -rf`. Salvarlo in `.claude/hooks/block-rm.sh` nel progetto e renderlo eseguibile con `chmod +x .claude/hooks/block-rm.sh` in modo che Claude Code possa eseguirlo:

96 96>

97```bash theme={null}97> ```bash theme={null}

98#!/bin/bash98> #!/bin/bash

99# .claude/hooks/block-rm.sh99> # .claude/hooks/block-rm.sh

100COMMAND=$(jq -r '.tool_input.command')100> COMMAND=$(jq -r '.tool_input.command')

101 101>

102if echo "$COMMAND" | grep -q 'rm -rf'; then102> if echo "$COMMAND" | grep -q 'rm -rf'; then

103 jq -n '{103> jq -n '{

104 hookSpecificOutput: {104> hookSpecificOutput: {

105 hookEventName: "PreToolUse",105> hookEventName: "PreToolUse",

106 permissionDecision: "deny",106> permissionDecision: "deny",

107 permissionDecisionReason: "Destructive command blocked by hook"107> permissionDecisionReason: "Destructive command blocked by hook"

108 }108> }

109 }'109> }'

110else110> else

111 exit 0 # nessuna decisione; il flusso di autorizzazione normale si applica111> exit 0 # nessuna decisione; il flusso di autorizzazione normale si applica

112fi112> fi

113```113> ```

114 114>

115Questo script, come gli altri esempi Bash su questa pagina che analizzano l'input JSON, utilizza `jq`, quindi installare `jq` e assicurarsi che sia nel `PATH` prima di provarli.115> Questo script, come gli altri esempi Bash su questa pagina che analizzano l'input JSON, utilizza `jq`, quindi installare `jq` e assicurarsi che sia nel `PATH` prima di provarli.

116 

117**Windows (PowerShell)**

118 

119Il matcher `Bash|PowerShell` copre lo [strumento PowerShell](#powershell) così come Bash. Una singola regola `if` corrisponde solo alle chiamate di uno strumento, quindi ogni strumento ottiene il suo gestore: il primo si restringe ai sottocomandi Bash che corrispondono a `rm *`, il secondo ai comandi PowerShell che corrispondono a `Remove-Item *`. Entrambi eseguono lo stesso script tramite `powershell.exe`:

120 

121```json theme={null}

122{

123 "hooks": {

124 "PreToolUse": [

125 {

126 "matcher": "Bash|PowerShell",

127 "hooks": [

128 {

129 "type": "command",

130 "if": "Bash(rm *)",

131 "command": "powershell.exe",

132 "args": [

133 "-NoProfile",

134 "-ExecutionPolicy",

135 "Bypass",

136 "-File",

137 "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.ps1"

138 ]

139 },

140 {

141 "type": "command",

142 "if": "PowerShell(Remove-Item *)",

143 "command": "powershell.exe",

144 "args": [

145 "-NoProfile",

146 "-ExecutionPolicy",

147 "Bypass",

148 "-File",

149 "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.ps1"

150 ]

151 }

152 ]

153 }

154 ]

155 }

156}

157```

158 

159Il flag `-NoProfile` salta il caricamento del profilo PowerShell in modo che l'hook si avvii rapidamente, e `-ExecutionPolicy Bypass` consente a PowerShell di eseguire il file di script locale.

160 

161Lo script legge l'input JSON da stdin, estrae il comando e restituisce una `permissionDecision` di `"deny"` se contiene `rm -rf` o `Remove-Item` seguito da `-Recurse`. Salvarlo in `.claude/hooks/block-rm.ps1` nel progetto:

162 

163```powershell theme={null}

164# .claude/hooks/block-rm.ps1

165$callInput = [Console]::In.ReadToEnd() | ConvertFrom-Json

166$command = $callInput.tool_input.command

167 116 

168if ($command -match 'rm -rf|Remove-Item.*-Recurse') {117> [tab] Windows (PowerShell)

169 @{118>

170 hookSpecificOutput = @{119> Il matcher `Bash|PowerShell` copre lo [strumento PowerShell](#powershell) così come Bash. Una singola regola `if` corrisponde solo alle chiamate di uno strumento, quindi ogni strumento ottiene il suo gestore: il primo si restringe ai sottocomandi Bash che corrispondono a `rm *`, il secondo ai comandi PowerShell che corrispondono a `Remove-Item *`. Entrambi eseguono lo stesso script tramite `powershell.exe`:

171 hookEventName = "PreToolUse"120>

172 permissionDecision = "deny"121> ```json theme={null}

173 permissionDecisionReason = "Destructive command blocked by hook"122> {

174 }123> "hooks": {

175 } | ConvertTo-Json124> "PreToolUse": [

176} else {125> {

177 exit 0 # nessuna decisione; il flusso di autorizzazione normale si applica126> "matcher": "Bash|PowerShell",

178}127> "hooks": [

179```128> {

129> "type": "command",

130> "if": "Bash(rm *)",

131> "command": "powershell.exe",

132> "args": [

133> "-NoProfile",

134> "-ExecutionPolicy",

135> "Bypass",

136> "-File",

137> "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.ps1"

138> ]

139> },

140> {

141> "type": "command",

142> "if": "PowerShell(Remove-Item *)",

143> "command": "powershell.exe",

144> "args": [

145> "-NoProfile",

146> "-ExecutionPolicy",

147> "Bypass",

148> "-File",

149> "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.ps1"

150> ]

151> }

152> ]

153> }

154> ]

155> }

156> }

157> ```

158>

159> Il flag `-NoProfile` salta il caricamento del profilo PowerShell in modo che l'hook si avvii rapidamente, e `-ExecutionPolicy Bypass` consente a PowerShell di eseguire il file di script locale.

160>

161> Lo script legge l'input JSON da stdin, estrae il comando e restituisce una `permissionDecision` di `"deny"` se contiene `rm -rf` o `Remove-Item` seguito da `-Recurse`. Salvarlo in `.claude/hooks/block-rm.ps1` nel progetto:

162>

163> ```powershell theme={null}

164> # .claude/hooks/block-rm.ps1

165> $callInput = [Console]::In.ReadToEnd() | ConvertFrom-Json

166> $command = $callInput.tool_input.command

167>

168> if ($command -match 'rm -rf|Remove-Item.*-Recurse') {

169> @{

170> hookSpecificOutput = @{

171> hookEventName = "PreToolUse"

172> permissionDecision = "deny"

173> permissionDecisionReason = "Destructive command blocked by hook"

174> }

175> } | ConvertTo-Json

176> } else {

177> exit 0 # nessuna decisione; il flusso di autorizzazione normale si applica

178> }

179> ```

180 180 

181Supponiamo che Claude Code decida di eseguire `Bash "rm -rf /tmp/build"` rispetto alla configurazione macOS/Linux. Ecco cosa accade:181Supponiamo che Claude Code decida di eseguire `Bash "rm -rf /tmp/build"` rispetto alla configurazione macOS/Linux. Ecco cosa accade:

182 182 

601 601 

602Preferisci [exec form](#exec-form-and-shell-form) per qualsiasi hook che faccia riferimento a un placeholder di percorso. In shell form, racchiudi ogni placeholder tra virgolette doppie.602Preferisci [exec form](#exec-form-and-shell-form) per qualsiasi hook che faccia riferimento a un placeholder di percorso. In shell form, racchiudi ogni placeholder tra virgolette doppie.

603 603 

604**Project scripts**604> [tab] Project scripts

605 605>

606Questo esempio utilizza `${CLAUDE_PROJECT_DIR}` per eseguire un verificatore di stile dalla directory `.claude/hooks/` del progetto dopo qualsiasi chiamata dello strumento `Write` o `Edit`:606> Questo esempio utilizza `${CLAUDE_PROJECT_DIR}` per eseguire un verificatore di stile dalla directory `.claude/hooks/` del progetto dopo qualsiasi chiamata dello strumento `Write` o `Edit`:

607 607>

608```json theme={null}608> ```json theme={null}

609{609> {

610 "hooks": {610> "hooks": {

611 "PostToolUse": [611> "PostToolUse": [

612 {612> {

613 "matcher": "Write|Edit",613> "matcher": "Write|Edit",

614 "hooks": [614> "hooks": [

615 {615> {

616 "type": "command",616> "type": "command",

617 "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/check-style.sh",617> "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/check-style.sh",

618 "args": []618> "args": []

619 }619> }

620 ]620> ]

621 }621> }

622 ]622> ]

623 }623> }

624}624> }

625```625> ```

626 626 

627**Plugin scripts**627> [tab] Plugin scripts

628 628>

629Definisci gli hook del plugin in `hooks/hooks.json` con un campo `description` opzionale di livello superiore. Quando un plugin è abilitato, i suoi hook si uniscono ai tuoi hook utente e progetto.629> Definisci gli hook del plugin in `hooks/hooks.json` con un campo `description` opzionale di livello superiore. Quando un plugin è abilitato, i suoi hook si uniscono ai tuoi hook utente e progetto.

630 630>

631Questo esempio esegue uno script di formattazione raggruppato con il plugin:631> Questo esempio esegue uno script di formattazione raggruppato con il plugin:

632 632>

633```json theme={null}633> ```json theme={null}

634{634> {

635 "description": "Automatic code formatting",635> "description": "Automatic code formatting",

636 "hooks": {636> "hooks": {

637 "PostToolUse": [637> "PostToolUse": [

638 {638> {

639 "matcher": "Write|Edit",639> "matcher": "Write|Edit",

640 "hooks": [640> "hooks": [

641 {641> {

642 "type": "command",642> "type": "command",

643 "command": "${CLAUDE_PLUGIN_ROOT}/scripts/format.sh",643> "command": "${CLAUDE_PLUGIN_ROOT}/scripts/format.sh",

644 "args": [],644> "args": [],

645 "timeout": 30645> "timeout": 30

646 }646> }

647 ]647> ]

648 }648> }

649 ]649> ]

650 }650> }

651}651> }

652```652> ```

653 653>

654Vedi il [riferimento dei componenti del plugin](https://code.claude.com/docs/it/plugins/components.md#hooks) per i dettagli sulla creazione degli hook del plugin.654> Vedi il [riferimento dei componenti del plugin](https://code.claude.com/docs/it/plugins/components.md#hooks) per i dettagli sulla creazione degli hook del plugin.

655 655 

656### Hook in skill e agenti656### Hook in skill e agenti

657 657 

1180 1180 

1181Ecco esempi di ogni modello in azione:1181Ecco esempi di ogni modello in azione:

1182 1182 

1183**Decisione di livello superiore**1183> [tab] Decisione di livello superiore

1184 1184>

1185L'unico valore per `decision` è `"block"`. Per consentire all'azione di procedere, ometti `decision` dal JSON, oppure esci con 0 senza alcun JSON:1185> L'unico valore per `decision` è `"block"`. Per consentire all'azione di procedere, ometti `decision` dal JSON, oppure esci con 0 senza alcun JSON:

1186 1186>

1187```json theme={null}1187> ```json theme={null}

1188{1188> {

1189 "decision": "block",1189> "decision": "block",

1190 "reason": "Test suite must pass before proceeding"1190> "reason": "Test suite must pass before proceeding"

1191}1191> }

1192```1192> ```

1193 1193 

1194**PreToolUse**1194> [tab] PreToolUse

1195 1195>

1196Usa `hookSpecificOutput` per un controllo più ricco: consentire, negare o inoltrare la decisione all'utente. Puoi anche modificare l'input dello strumento prima che venga eseguito o iniettare contesto aggiuntivo per Claude. Consulta [PreToolUse decision control](#pretooluse-decision-control) per l'insieme completo di opzioni.1196> Usa `hookSpecificOutput` per un controllo più ricco: consentire, negare o inoltrare la decisione all'utente. Puoi anche modificare l'input dello strumento prima che venga eseguito o iniettare contesto aggiuntivo per Claude. Consulta [PreToolUse decision control](#pretooluse-decision-control) per l'insieme completo di opzioni.

1197 1197>

1198```json theme={null}1198> ```json theme={null}

1199{1199> {

1200 "hookSpecificOutput": {1200> "hookSpecificOutput": {

1201 "hookEventName": "PreToolUse",1201> "hookEventName": "PreToolUse",

1202 "permissionDecision": "deny",1202> "permissionDecision": "deny",

1203 "permissionDecisionReason": "Database writes are not allowed"1203> "permissionDecisionReason": "Database writes are not allowed"

1204 }1204> }

1205}1205> }

1206```1206> ```

1207 1207 

1208**PermissionRequest**1208> [tab] PermissionRequest

1209 1209>

1210Usa `hookSpecificOutput` per consentire o negare una richiesta di permesso per conto dell'utente. Quando consenti, puoi anche modificare l'input dello strumento o applicare regole di permesso in modo che all'utente non venga chiesto di nuovo. Consulta [PermissionRequest decision control](#permissionrequest-decision-control) per l'insieme completo di opzioni.1210> Usa `hookSpecificOutput` per consentire o negare una richiesta di permesso per conto dell'utente. Quando consenti, puoi anche modificare l'input dello strumento o applicare regole di permesso in modo che all'utente non venga chiesto di nuovo. Consulta [PermissionRequest decision control](#permissionrequest-decision-control) per l'insieme completo di opzioni.

1211 1211>

1212```json theme={null}1212> ```json theme={null}

1213{1213> {

1214 "hookSpecificOutput": {1214> "hookSpecificOutput": {

1215 "hookEventName": "PermissionRequest",1215> "hookEventName": "PermissionRequest",

1216 "decision": {1216> "decision": {

1217 "behavior": "allow",1217> "behavior": "allow",

1218 "updatedInput": {1218> "updatedInput": {

1219 "command": "npm run lint"1219> "command": "npm run lint"

1220 }1220> }

1221 }1221> }

1222 }1222> }

1223}1223> }

1224```1224> ```

1225 1225 

1226Per esempi estesi, tra cui la convalida dei comandi Bash, il filtraggio dei prompt e gli script di approvazione automatica, consulta [What you can automate](https://code.claude.com/docs/it/hooks-guide.md#what-you-can-automate) nella guida e l'[implementazione di riferimento del validatore di comandi Bash](https://github.com/anthropics/claude-code/blob/main/examples/hooks/bash_command_validator_example.py).1226Per esempi estesi, tra cui la convalida dei comandi Bash, il filtraggio dei prompt e gli script di approvazione automatica, consulta [What you can automate](https://code.claude.com/docs/it/hooks-guide.md#what-you-can-automate) nella guida e l'[implementazione di riferimento del validatore di comandi Bash](https://github.com/anthropics/claude-code/blob/main/examples/hooks/bash_command_validator_example.py).

1227 1227 

1656 1656 

1657Questo esempio rimuove la formattazione markdown dalle risposte di Claude per una visualizzazione in testo semplice. Lo script legge ogni gruppo da stdin, rimuove i marcatori del grassetto e i backtick del codice inline da `delta` e restituisce il risultato come `displayContent`.1657Questo esempio rimuove la formattazione markdown dalle risposte di Claude per una visualizzazione in testo semplice. Lo script legge ogni gruppo da stdin, rimuove i marcatori del grassetto e i backtick del codice inline da `delta` e restituisce il risultato come `displayContent`.

1658 1658 

1659**macOS/Linux**1659> [tab] macOS/Linux

1660 1660>

1661Registra un hook di comando per l'evento nel tuo file di impostazioni:1661> Registra un hook di comando per l'evento nel tuo file di impostazioni:

1662 1662>

1663```json theme={null}1663> ```json theme={null}

1664{1664> {

1665 "hooks": {1665> "hooks": {

1666 "MessageDisplay": [1666> "MessageDisplay": [

1667 {1667> {

1668 "hooks": [1668> "hooks": [

1669 {1669> {

1670 "type": "command",1670> "type": "command",

1671 "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/plain-display.sh",1671> "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/plain-display.sh",

1672 "args": []1672> "args": []

1673 }1673> }

1674 ]1674> ]

1675 }1675> }

1676 ]1676> ]

1677 }1677> }

1678}1678> }

1679```1679> ```

1680 1680>

1681Salva questo script in `.claude/hooks/plain-display.sh` nel tuo progetto e rendilo eseguibile con `chmod +x`:1681> Salva questo script in `.claude/hooks/plain-display.sh` nel tuo progetto e rendilo eseguibile con `chmod +x`:

1682 1682>

1683```bash theme={null}1683> ```bash theme={null}

1684#!/bin/bash1684> #!/bin/bash

1685jq '{hookSpecificOutput: {hookEventName: "MessageDisplay", displayContent: (.delta | gsub("\\*\\*"; "") | gsub("`"; ""))}}'1685> jq '{hookSpecificOutput: {hookEventName: "MessageDisplay", displayContent: (.delta | gsub("\\*\\*"; "") | gsub("`"; ""))}}'

1686```1686> ```

1687 

1688**Windows (PowerShell)**

1689 

1690Registra un hook di comando che esegue lo script tramite PowerShell:

1691 

1692```json theme={null}

1693{

1694 "hooks": {

1695 "MessageDisplay": [

1696 {

1697 "hooks": [

1698 {

1699 "type": "command",

1700 "command": "powershell.exe",

1701 "args": [

1702 "-NoProfile",

1703 "-ExecutionPolicy",

1704 "Bypass",

1705 "-File",

1706 "${CLAUDE_PROJECT_DIR}/.claude/hooks/plain-display.ps1"

1707 ]

1708 }

1709 ]

1710 }

1711 ]

1712 }

1713}

1714```

1715 

1716Il flag `-NoProfile` salta il caricamento del tuo profilo PowerShell così l'hook si avvia rapidamente, e `-ExecutionPolicy Bypass` consente a PowerShell di eseguire il file di script locale.

1717 

1718Salva questo script in `.claude/hooks/plain-display.ps1` nel tuo progetto:

1719 1687 

1720```powershell theme={null}1688> [tab] Windows (PowerShell)

1721$batch = [Console]::In.ReadToEnd() | ConvertFrom-Json1689>

1722$text = $batch.delta -replace '\*\*', '' -replace '`', ''1690> Registra un hook di comando che esegue lo script tramite PowerShell:

1723@{1691>

1724 hookSpecificOutput = @{1692> ```json theme={null}

1725 hookEventName = "MessageDisplay"1693> {

1726 displayContent = $text1694> "hooks": {

1727 }1695> "MessageDisplay": [

1728} | ConvertTo-Json1696> {

1729```1697> "hooks": [

1698> {

1699> "type": "command",

1700> "command": "powershell.exe",

1701> "args": [

1702> "-NoProfile",

1703> "-ExecutionPolicy",

1704> "Bypass",

1705> "-File",

1706> "${CLAUDE_PROJECT_DIR}/.claude/hooks/plain-display.ps1"

1707> ]

1708> }

1709> ]

1710> }

1711> ]

1712> }

1713> }

1714> ```

1715>

1716> Il flag `-NoProfile` salta il caricamento del tuo profilo PowerShell così l'hook si avvia rapidamente, e `-ExecutionPolicy Bypass` consente a PowerShell di eseguire il file di script locale.

1717>

1718> Salva questo script in `.claude/hooks/plain-display.ps1` nel tuo progetto:

1719>

1720> ```powershell theme={null}

1721> $batch = [Console]::In.ReadToEnd() | ConvertFrom-Json

1722> $text = $batch.delta -replace '\*\*', '' -replace '`', ''

1723> @{

1724> hookSpecificOutput = @{

1725> hookEventName = "MessageDisplay"

1726> displayContent = $text

1727> }

1728> } | ConvertTo-Json

1729> ```

1730 1730 

1731I gruppi senza markdown passano senza modifiche. Se lo script fallisce, ad esempio perché manca `jq`, Claude Code visualizza il testo originale e segnala il fallimento solo nell'[output di debug](#debug-hooks), non nella sessione.1731I gruppi senza markdown passano senza modifiche. Se lo script fallisce, ad esempio perché manca `jq`, Claude Code visualizza il testo originale e segnala il fallimento solo nell'[output di debug](#debug-hooks), non nella sessione.

1732 1732 

3357 3357 

3358Scrivi il matcher come nome esatto, come elenco separato da `|` come `claude-opus-4-6|claude-opus-5`, o come espressione regolare come `.*opus.*`. Questo esempio usa un matcher con nome esatto e controlla anche `to_model` dall'input dell'hook, quindi rifiuta un passaggio a Opus 4.6 uscendo con codice 2 e lascia passare qualsiasi altra destinazione:3358Scrivi il matcher come nome esatto, come elenco separato da `|` come `claude-opus-4-6|claude-opus-5`, o come espressione regolare come `.*opus.*`. Questo esempio usa un matcher con nome esatto e controlla anche `to_model` dall'input dell'hook, quindi rifiuta un passaggio a Opus 4.6 uscendo con codice 2 e lascia passare qualsiasi altra destinazione:

3359 3359 

3360**macOS/Linux**3360> [tab] macOS/Linux

3361 3361>

3362Il comando controlla `to_model` con `jq`:3362> Il comando controlla `to_model` con `jq`:

3363 3363>

3364```json theme={null}3364> ```json theme={null}

3365{3365> {

3366 "hooks": {3366> "hooks": {

3367 "PreModelSwitch": [3367> "PreModelSwitch": [

3368 {3368> {

3369 "matcher": "claude-opus-4-6",3369> "matcher": "claude-opus-4-6",

3370 "hooks": [3370> "hooks": [

3371 {3371> {

3372 "type": "command",3372> "type": "command",

3373 "command": "jq -e '.to_model | test(\"opus-4-6\")' > /dev/null && { echo 'Opus 4.6 is retired for this project. Use a newer model.' >&2; exit 2; }; exit 0"3373> "command": "jq -e '.to_model | test(\"opus-4-6\")' > /dev/null && { echo 'Opus 4.6 is retired for this project. Use a newer model.' >&2; exit 2; }; exit 0"

3374 }3374> }

3375 ]3375> ]

3376 }3376> }

3377 ]3377> ]

3378 }3378> }

3379}3379> }

3380```3380> ```

3381 3381 

3382**Windows (PowerShell)**3382> [tab] Windows (PowerShell)

3383 3383>

3384Registra un hook di tipo command che esegue uno script tramite PowerShell:3384> Registra un hook di tipo command che esegue uno script tramite PowerShell:

3385 3385>

3386```json theme={null}3386> ```json theme={null}

3387{3387> {

3388 "hooks": {3388> "hooks": {

3389 "PreModelSwitch": [3389> "PreModelSwitch": [

3390 {3390> {

3391 "matcher": "claude-opus-4-6",3391> "matcher": "claude-opus-4-6",

3392 "hooks": [3392> "hooks": [

3393 {3393> {

3394 "type": "command",3394> "type": "command",

3395 "command": "powershell.exe",3395> "command": "powershell.exe",

3396 "args": [3396> "args": [

3397 "-NoProfile",3397> "-NoProfile",

3398 "-ExecutionPolicy",3398> "-ExecutionPolicy",

3399 "Bypass",3399> "Bypass",

3400 "-File",3400> "-File",

3401 "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-opus-46.ps1"3401> "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-opus-46.ps1"

3402 ]3402> ]

3403 }3403> }

3404 ]3404> ]

3405 }3405> }

3406 ]3406> ]

3407 }3407> }

3408}3408> }

3409```3409> ```

3410 3410>

3411Salva questo script in `.claude/hooks/block-opus-46.ps1` nel tuo progetto:3411> Salva questo script in `.claude/hooks/block-opus-46.ps1` nel tuo progetto:

3412 3412>

3413```powershell theme={null}3413> ```powershell theme={null}

3414$hookInput = [Console]::In.ReadToEnd() | ConvertFrom-Json3414> $hookInput = [Console]::In.ReadToEnd() | ConvertFrom-Json

3415if ($hookInput.to_model -match 'opus-4-6') {3415> if ($hookInput.to_model -match 'opus-4-6') {

3416 [Console]::Error.WriteLine('Opus 4.6 is retired for this project. Use a newer model.')3416> [Console]::Error.WriteLine('Opus 4.6 is retired for this project. Use a newer model.')

3417 exit 23417> exit 2

3418}3418> }

3419exit 03419> exit 0

3420```3420> ```

3421 3421 

3422Per verificare che l'hook funzioni, esegui `/model claude-opus-4-6` da una sessione che usa un modello diverso. Claude Code mantiene il modello corrente e segnala che un hook PreModelSwitch ha bloccato il cambio, con il tuo messaggio come motivo.3422Per verificare che l'hook funzioni, esegui `/model claude-opus-4-6` da una sessione che usa un modello diverso. Claude Code mantiene il modello corrente e segnala che un hook PreModelSwitch ha bloccato il cambio, con il tuo messaggio come motivo.

3423 3423 

3705 3705 

3706Questo esempio risponde a una domanda ricorrente al posto dell'utente. Un server MCP chiamato `issue-tracker` chiede una chiave di progetto in un modulo, e l'hook inserisce `DOCS`. Lo script accetta quando `project_key` è l'unico campo del modulo. Per qualsiasi altra richiesta non stampa nulla, quindi appare la finestra di dialogo.3706Questo esempio risponde a una domanda ricorrente al posto dell'utente. Un server MCP chiamato `issue-tracker` chiede una chiave di progetto in un modulo, e l'hook inserisce `DOCS`. Lo script accetta quando `project_key` è l'unico campo del modulo. Per qualsiasi altra richiesta non stampa nulla, quindi appare la finestra di dialogo.

3707 3707 

3708**macOS/Linux**3708> [tab] macOS/Linux

3709 3709>

3710Registra un hook di tipo command per l'evento nel tuo file di impostazioni, con il nome del server come matcher:3710> Registra un hook di tipo command per l'evento nel tuo file di impostazioni, con il nome del server come matcher:

3711 3711>

3712```json theme={null}3712> ```json theme={null}

3713{3713> {

3714 "hooks": {3714> "hooks": {

3715 "Elicitation": [3715> "Elicitation": [

3716 {3716> {

3717 "matcher": "issue-tracker",3717> "matcher": "issue-tracker",

3718 "hooks": [3718> "hooks": [

3719 {3719> {

3720 "type": "command",3720> "type": "command",

3721 "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/answer-project-key.sh",3721> "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/answer-project-key.sh",

3722 "args": []3722> "args": []

3723 }3723> }

3724 ]3724> ]

3725 }3725> }

3726 ]3726> ]

3727 }3727> }

3728}3728> }

3729```3729> ```

3730 3730>

3731Salva questo script in `.claude/hooks/answer-project-key.sh` nel tuo progetto e rendilo eseguibile con `chmod +x`:3731> Salva questo script in `.claude/hooks/answer-project-key.sh` nel tuo progetto e rendilo eseguibile con `chmod +x`:

3732 3732>

3733```bash theme={null}3733> ```bash theme={null}

3734#!/bin/bash3734> #!/bin/bash

3735input=$(cat)3735> input=$(cat)

3736fields=$(jq -c '.requested_schema.properties // {} | keys' <<<"$input")3736> fields=$(jq -c '.requested_schema.properties // {} | keys' <<<"$input")

3737 3737>

3738if [ "$fields" = '["project_key"]' ]; then3738> if [ "$fields" = '["project_key"]' ]; then

3739 jq -n '{hookSpecificOutput: {hookEventName: "Elicitation", action: "accept", content: {project_key: "DOCS"}}}'3739> jq -n '{hookSpecificOutput: {hookEventName: "Elicitation", action: "accept", content: {project_key: "DOCS"}}}'

3740fi3740> fi

3741```3741> ```

3742 

3743**Windows (PowerShell)**

3744 

3745Registra un hook di tipo command che esegue lo script tramite PowerShell, con il nome del server come matcher:

3746 

3747```json theme={null}

3748{

3749 "hooks": {

3750 "Elicitation": [

3751 {

3752 "matcher": "issue-tracker",

3753 "hooks": [

3754 {

3755 "type": "command",

3756 "command": "powershell.exe",

3757 "args": [

3758 "-NoProfile",

3759 "-ExecutionPolicy",

3760 "Bypass",

3761 "-File",

3762 "${CLAUDE_PROJECT_DIR}/.claude/hooks/answer-project-key.ps1"

3763 ]

3764 }

3765 ]

3766 }

3767 ]

3768 }

3769}

3770```

3771 

3772Salva questo script in `.claude/hooks/answer-project-key.ps1` nel tuo progetto:

3773 

3774```powershell theme={null}

3775$request = [Console]::In.ReadToEnd() | ConvertFrom-Json

3776$fields = @($request.requested_schema.properties.PSObject.Properties.Name)

3777 3742 

3778if ($fields.Count -eq 1 -and $fields[0] -eq 'project_key') {3743> [tab] Windows (PowerShell)

3779 @{3744>

3780 hookSpecificOutput = @{3745> Registra un hook di tipo command che esegue lo script tramite PowerShell, con il nome del server come matcher:

3781 hookEventName = "Elicitation"3746>

3782 action = "accept"3747> ```json theme={null}

3783 content = @{ project_key = "DOCS" }3748> {

3784 }3749> "hooks": {

3785 } | ConvertTo-Json -Depth 33750> "Elicitation": [

3786}3751> {

3787```3752> "matcher": "issue-tracker",

3753> "hooks": [

3754> {

3755> "type": "command",

3756> "command": "powershell.exe",

3757> "args": [

3758> "-NoProfile",

3759> "-ExecutionPolicy",

3760> "Bypass",

3761> "-File",

3762> "${CLAUDE_PROJECT_DIR}/.claude/hooks/answer-project-key.ps1"

3763> ]

3764> }

3765> ]

3766> }

3767> ]

3768> }

3769> }

3770> ```

3771>

3772> Salva questo script in `.claude/hooks/answer-project-key.ps1` nel tuo progetto:

3773>

3774> ```powershell theme={null}

3775> $request = [Console]::In.ReadToEnd() | ConvertFrom-Json

3776> $fields = @($request.requested_schema.properties.PSObject.Properties.Name)

3777>

3778> if ($fields.Count -eq 1 -and $fields[0] -eq 'project_key') {

3779> @{

3780> hookSpecificOutput = @{

3781> hookEventName = "Elicitation"

3782> action = "accept"

3783> content = @{ project_key = "DOCS" }

3784> }

3785> } | ConvertTo-Json -Depth 3

3786> }

3787> ```

3788 3788 

3789Per verificare che l'hook funzioni, avvia Claude Code con `claude --debug` e dai a Claude un'attività che porti il server a chiedere la chiave di progetto. Non appare alcuna finestra di dialogo, e il [log di debug](#debug-hooks) contiene una riga che termina con `Elicitation resolved by hook: {"action":"accept","content":{"project_key":"DOCS"}}`.3789Per verificare che l'hook funzioni, avvia Claude Code con `claude --debug` e dai a Claude un'attività che porti il server a chiedere la chiave di progetto. Non appare alcuna finestra di dialogo, e il [log di debug](#debug-hooks) contiene una riga che termina con `Elicitation resolved by hook: {"action":"accept","content":{"project_key":"DOCS"}}`.

3790 3790 

hooks-guide.md +144 −144

Details

89 89 

90Ogni scheda qui sotto utilizza il comando di notifica nativo della piattaforma. Aggiungi questo a `~/.claude/settings.json`:90Ogni scheda qui sotto utilizza il comando di notifica nativo della piattaforma. Aggiungi questo a `~/.claude/settings.json`:

91 91 

92**macOS**92> [tab] macOS

93 

94```json theme={null}

95{

96 "hooks": {

97 "Notification": [

98 {

99 "matcher": "",

100 "hooks": [

101 {

102 "type": "command",

103 "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"

104 }

105 ]

106 }

107 ]

108 }

109}

110```

111 

112> **Se non appare nessuna notifica**

113>

114> `osascript` instrada le notifiche attraverso l'app Script Editor integrata. Se Script Editor non ha il permesso di inviare notifiche, il comando fallisce silenziosamente e macOS non ti chiederà di concederlo.

115>93>

116> Esegui questo comando una volta in Terminal per far apparire Script Editor nelle impostazioni delle notifiche:94> ```json theme={null}

117>95> {

118> ```bash theme={null}96> "hooks": {

119> osascript -e 'display notification "test"'97> "Notification": [

98> {

99> "matcher": "",

100> "hooks": [

101> {

102> "type": "command",

103> "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"

104> }

105> ]

106> }

107> ]

108> }

109> }

120> ```110> ```

121>111>

122> Nulla apparirà ancora. Aprite **System Settings > Notifications**, trovate **Script Editor** nell'elenco e attivate **Allow Notifications**. Eseguite il comando di nuovo per confermare che la notifica di test appare.112> > [accordion] Se non appare nessuna notifica

123 113> >

124**Linux**114> > `osascript` instrada le notifiche attraverso l'app Script Editor integrata. Se Script Editor non ha il permesso di inviare notifiche, il comando fallisce silenziosamente e macOS non ti chiederà di concederlo.

125 115> >

126```json theme={null}116> > Esegui questo comando una volta in Terminal per far apparire Script Editor nelle impostazioni delle notifiche:

127{117> >

128 "hooks": {118> > ```bash theme={null}

129 "Notification": [119> > osascript -e 'display notification "test"'

130 {120> > ```

131 "matcher": "",121> >

132 "hooks": [122> > Nulla apparirà ancora. Aprite **System Settings > Notifications**, trovate **Script Editor** nell'elenco e attivate **Allow Notifications**. Eseguite il comando di nuovo per confermare che la notifica di test appare.

133 {123 

134 "type": "command",124> [tab] Linux

135 "command": "notify-send 'Claude Code' 'Claude Code needs your attention'"

136 }

137 ]

138 }

139 ]

140 }

141}

142```

143 

144> **Se nessuna notifica appare**

145>

146> `notify-send` ha bisogno di un daemon di notifica desktop, che i server headless, le sessioni SSH e la maggior parte dei container non hanno. Testate il comando direttamente per primo:

147>125>

148> ```bash theme={null}126> ```json theme={null}

149> notify-send 'Claude Code' 'test'127> {

128> "hooks": {

129> "Notification": [

130> {

131> "matcher": "",

132> "hooks": [

133> {

134> "type": "command",

135> "command": "notify-send 'Claude Code' 'Claude Code needs your attention'"

136> }

137> ]

138> }

139> ]

140> }

141> }

150> ```142> ```

151>143>

152> Se il comando non viene trovato, installate il pacchetto `libnotify-bin` su Debian e Ubuntu, o l'equivalente della vostra distribuzione.144> > [accordion] Se nessuna notifica appare

153 145> >

154**Windows (PowerShell)**146> > `notify-send` ha bisogno di un daemon di notifica desktop, che i server headless, le sessioni SSH e la maggior parte dei container non hanno. Testate il comando direttamente per primo:

155 147> >

156```json theme={null}148> > ```bash theme={null}

157{149> > notify-send 'Claude Code' 'test'

158 "hooks": {150> > ```

159 "Notification": [151> >

160 {152> > Se il comando non viene trovato, installate il pacchetto `libnotify-bin` su Debian e Ubuntu, o l'equivalente della vostra distribuzione.

161 "matcher": "",153 

162 "hooks": [154> [tab] Windows (PowerShell)

163 {

164 "type": "command",

165 "command": "powershell.exe -Command \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('Claude Code needs your attention', 'Claude Code')\""

166 }

167 ]

168 }

169 ]

170 }

171}

172```

173 

174> **Se non appare nessuna finestra di dialogo**

175>155>

176> Questo comando apre una finestra di dialogo anziché una notifica nell'angolo dello schermo, quindi la finestra di dialogo può aprirsi dietro la finestra del terminale. Prova prima il comando direttamente in PowerShell.156> ```json theme={null}

157> {

158> "hooks": {

159> "Notification": [

160> {

161> "matcher": "",

162> "hooks": [

163> {

164> "type": "command",

165> "command": "powershell.exe -Command \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('Claude Code needs your attention', 'Claude Code')\""

166> }

167> ]

168> }

169> ]

170> }

171> }

172> ```

177>173>

178> Se esegui Claude Code all'interno di WSL, `powershell.exe` deve essere disponibile nel tuo `PATH` tramite l'interoperabilità di Windows.174> > [accordion] Se non appare nessuna finestra di dialogo

175> >

176> > Questo comando apre una finestra di dialogo anziché una notifica nell'angolo dello schermo, quindi la finestra di dialogo può aprirsi dietro la finestra del terminale. Prova prima il comando direttamente in PowerShell.

177> >

178> > Se esegui Claude Code all'interno di WSL, `powershell.exe` deve essere disponibile nel tuo `PATH` tramite l'interoperabilità di Windows.

179 179 

180Il `matcher` vuoto si attiva su tutti i tipi di notifica. Per attivarlo solo su eventi specifici, impostalo su uno di questi valori:180Il `matcher` vuoto si attiva su tutti i tipi di notifica. Per attivarlo solo su eventi specifici, impostalo su uno di questi valori:

181 181 

705 705 

706Le schede sottostanti mostrano alcuni altri matcher su diversi tipi di evento.706Le schede sottostanti mostrano alcuni altri matcher su diversi tipi di evento.

707 707 

708**Registrare ogni comando Bash**708> [tab] Registrare ogni comando Bash

709 709>

710Corrispondere solo alle chiamate dello strumento `Bash` e registrare ogni comando in un file. L'evento `PostToolUse` si attiva dopo che il comando è completato, quindi `tool_input.command` contiene quello che è stato eseguito. L'hook riceve i dati dell'evento come JSON su stdin, e `jq -r '.tool_input.command'` estrae solo la stringa del comando, che `>>` aggiunge al file di log:710> Corrispondere solo alle chiamate dello strumento `Bash` e registrare ogni comando in un file. L'evento `PostToolUse` si attiva dopo che il comando è completato, quindi `tool_input.command` contiene quello che è stato eseguito. L'hook riceve i dati dell'evento come JSON su stdin, e `jq -r '.tool_input.command'` estrae solo la stringa del comando, che `>>` aggiunge al file di log:

711 711>

712```json theme={null}712> ```json theme={null}

713{713> {

714 "hooks": {714> "hooks": {

715 "PostToolUse": [715> "PostToolUse": [

716 {716> {

717 "matcher": "Bash",717> "matcher": "Bash",

718 "hooks": [718> "hooks": [

719 {719> {

720 "type": "command",720> "type": "command",

721 "command": "jq -r '.tool_input.command' >> ~/.claude/command-log.txt"721> "command": "jq -r '.tool_input.command' >> ~/.claude/command-log.txt"

722 }722> }

723 ]723> ]

724 }724> }

725 ]725> ]

726 }726> }

727}727> }

728```728> ```

729 

730**Corrispondere agli strumenti MCP**

731 

732Gli strumenti MCP utilizzano una convenzione di denominazione diversa rispetto agli strumenti integrati: `mcp__<server>__<tool>`, dove `<server>` è il nome del server MCP e `<tool>` è lo strumento che fornisce. Ad esempio, `mcp__github__search_repositories` o `mcp__filesystem__read_file`. Gli strumenti da un [server MCP fornito da plugin](https://code.claude.com/docs/it/mcp.md#plugin-provided-mcp-servers) utilizzano un segmento di server con ambito invece, come `mcp__plugin_my-plugin_db__query`. Utilizzate un matcher regex per indirizzare tutti gli strumenti da un server specifico, o corrispondere tra i server con un modello come `mcp__.*__write.*`. Consultate [Match MCP tools](https://code.claude.com/docs/it/hooks.md#match-mcp-tools) nel riferimento per l'elenco completo degli esempi.

733 

734Il comando sottostante estrae il nome dello strumento dall'input JSON dell'hook con `jq` e lo scrive su stderr. Scrivere su stderr mantiene stdout pulito per l'output JSON e invia il messaggio al [debug log](https://code.claude.com/docs/it/hooks.md#debug-hooks):

735 

736```json theme={null}

737{

738 "hooks": {

739 "PreToolUse": [

740 {

741 "matcher": "mcp__github__.*",

742 "hooks": [

743 {

744 "type": "command",

745 "command": "echo \"GitHub tool called: $(jq -r '.tool_name')\" >&2"

746 }

747 ]

748 }

749 ]

750 }

751}

752```

753 

754**Pulire alla fine della sessione**

755 729 

756L'evento `SessionEnd` supporta i matcher sul motivo per cui la sessione è terminata. Questo hook si attiva solo sul motivo `clear`, impostato quando eseguite `/clear`, non su uscite normali:730> [tab] Corrispondere agli strumenti MCP

731>

732> Gli strumenti MCP utilizzano una convenzione di denominazione diversa rispetto agli strumenti integrati: `mcp__<server>__<tool>`, dove `<server>` è il nome del server MCP e `<tool>` è lo strumento che fornisce. Ad esempio, `mcp__github__search_repositories` o `mcp__filesystem__read_file`. Gli strumenti da un [server MCP fornito da plugin](https://code.claude.com/docs/it/mcp.md#plugin-provided-mcp-servers) utilizzano un segmento di server con ambito invece, come `mcp__plugin_my-plugin_db__query`. Utilizzate un matcher regex per indirizzare tutti gli strumenti da un server specifico, o corrispondere tra i server con un modello come `mcp__.*__write.*`. Consultate [Match MCP tools](https://code.claude.com/docs/it/hooks.md#match-mcp-tools) nel riferimento per l'elenco completo degli esempi.

733>

734> Il comando sottostante estrae il nome dello strumento dall'input JSON dell'hook con `jq` e lo scrive su stderr. Scrivere su stderr mantiene stdout pulito per l'output JSON e invia il messaggio al [debug log](https://code.claude.com/docs/it/hooks.md#debug-hooks):

735>

736> ```json theme={null}

737> {

738> "hooks": {

739> "PreToolUse": [

740> {

741> "matcher": "mcp__github__.*",

742> "hooks": [

743> {

744> "type": "command",

745> "command": "echo \"GitHub tool called: $(jq -r '.tool_name')\" >&2"

746> }

747> ]

748> }

749> ]

750> }

751> }

752> ```

757 753 

758```json theme={null}754> [tab] Pulire alla fine della sessione

759{755>

760 "hooks": {756> L'evento `SessionEnd` supporta i matcher sul motivo per cui la sessione è terminata. Questo hook si attiva solo sul motivo `clear`, impostato quando eseguite `/clear`, non su uscite normali:

761 "SessionEnd": [757>

762 {758> ```json theme={null}

763 "matcher": "clear",759> {

764 "hooks": [760> "hooks": {

765 {761> "SessionEnd": [

766 "type": "command",762> {

767 "command": "rm -f /tmp/claude-scratch-*.txt"763> "matcher": "clear",

768 }764> "hooks": [

769 ]765> {

770 }766> "type": "command",

771 ]767> "command": "rm -f /tmp/claude-scratch-*.txt"

772 }768> }

773}769> ]

774```770> }

771> ]

772> }

773> }

774> ```

775 775 

776#### Filtrare per nome dello strumento e argomenti con il campo `if`776#### Filtrare per nome dello strumento e argomenti con il campo `if`

777 777 

Details

163 163 

164Scegli una modalità di permesso per impostare cosa Claude può fare senza chiedere. Premi `Shift+Tab` per scorrere le modalità di permesso:164Scegli una modalità di permesso per impostare cosa Claude può fare senza chiedere. Premi `Shift+Tab` per scorrere le modalità di permesso:

165 165 

166* **Auto**: un classificatore esamina la maggior parte delle azioni in background e blocca quelle rischiose invece di chiedere. Con Claude Code v2.1.283 o successivo, è la [modalità di permesso iniziale integrata](https://code.claude.com/docs/it/permission-modes.md#which-mode-a-session-starts-in) per le sessioni interattive di terminale e VS Code, e nelle versioni precedenti solo nei piani Pro, Max e Team166* **Auto**: un classificatore esamina la maggior parte delle azioni in background e blocca quelle rischiose invece di chiederti. Con Claude Code v2.1.283 o successivo, è la [modalità di permesso iniziale integrata](https://code.claude.com/docs/it/permission-modes.md#which-mode-a-session-starts-in) per le sessioni interattive di terminale e VS Code. Nelle versioni precedenti, è la modalità di permesso iniziale integrata solo nei piani Pro, Max, Ultra e Team.

167* **Manual**: Claude chiede prima delle modifiche ai file e dei comandi shell167* **Manual**: Claude chiede prima delle modifiche ai file e dei comandi shell

168* **Accept edits**: Claude modifica i file ed esegue comandi comuni del file system come `mkdir` e `mv` senza chiedere, chiede ancora per altri comandi168* **Accept edits**: Claude modifica i file ed esegue comandi comuni del file system come `mkdir` e `mv` senza chiedere, chiede ancora per altri comandi

169* **Plan**: Claude esplora e propone un piano senza modificare i tuoi file sorgente169* **Plan**: Claude esplora e propone un piano senza modificare i tuoi file sorgente

223 223 

224## Cosa c'è dopo224## Cosa c'è dopo

225 225 

226> **[Estendi con funzionalità](https://code.claude.com/docs/it/features-overview.md)**226> [card] [Estendi con funzionalità](https://code.claude.com/docs/it/features-overview.md)

227>227>

228> Aggiungi skills e connessioni MCP228> Aggiungi skills e connessioni MCP

229 229 

230> **[Flussi di lavoro comuni](https://code.claude.com/docs/it/common-workflows.md)**230> [card] [Flussi di lavoro comuni](https://code.claude.com/docs/it/common-workflows.md)

231>231>

232> Guide passo dopo passo per compiti tipici232> Guide passo dopo passo per compiti tipici

Details

537 537 

538Claude Code legge l'impostazione [`spellcheck`](https://code.claude.com/docs/it/settings-reference#spellcheck) da tre posizioni e la ignora nel file `.claude/settings.json` e `.claude/settings.local.json` di un progetto. Attivala da quella che utilizzi:538Claude Code legge l'impostazione [`spellcheck`](https://code.claude.com/docs/it/settings-reference#spellcheck) da tre posizioni e la ignora nel file `.claude/settings.json` e `.claude/settings.local.json` di un progetto. Attivala da quella che utilizzi:

539 539 

540**Impostazioni utente**540> [tab] Impostazioni utente

541 541>

542Aggiungi `spellcheck` a `~/.claude/settings.json`. Si applica in ogni progetto che apri, come il resto delle tue [impostazioni utente](https://code.claude.com/docs/it/settings.md#where-settings-live):542> Aggiungi `spellcheck` a `~/.claude/settings.json`. Si applica in ogni progetto che apri, come il resto delle tue [impostazioni utente](https://code.claude.com/docs/it/settings.md#where-settings-live):

543 543>

544```json theme={null}544> ```json theme={null}

545{545> {

546 "spellcheck": { "enabled": true }546> "spellcheck": { "enabled": true }

547}547> }

548```548> ```

549 

550**Riga di comando**

551 

552Salva `spellcheck` in un file JSON, come `spellcheck.json`:

553 

554```json theme={null}

555{

556 "spellcheck": { "enabled": true }

557}

558```

559 

560Quindi passa il file a `--settings`. Si applica solo a quella sessione:

561 

562```bash theme={null}

563claude --settings spellcheck.json

564```

565 

566**Impostazioni gestite**

567 549 

568Aggiungi `spellcheck` a una delle [fonti di impostazioni gestite](https://code.claude.com/docs/it/permissions.md#managed-settings) della tua organizzazione. Si applica a ogni utente che riceve quelle impostazioni e non può disattivarle:550> [tab] Riga di comando

551>

552> Salva `spellcheck` in un file JSON, come `spellcheck.json`:

553>

554> ```json theme={null}

555> {

556> "spellcheck": { "enabled": true }

557> }

558> ```

559>

560> Quindi passa il file a `--settings`. Si applica solo a quella sessione:

561>

562> ```bash theme={null}

563> claude --settings spellcheck.json

564> ```

569 565 

570```json theme={null}566> [tab] Impostazioni gestite

571{567>

572 "spellcheck": { "enabled": true }568> Aggiungi `spellcheck` a una delle [fonti di impostazioni gestite](https://code.claude.com/docs/it/permissions.md#managed-settings) della tua organizzazione. Si applica a ogni utente che riceve quelle impostazioni e non può disattivarle:

573}569>

574```570> ```json theme={null}

571> {

572> "spellcheck": { "enabled": true }

573> }

574> ```

575 575 

576Per verificare che il controllo ortografico sia attivo, digita una parola scritta male e uno spazio. Claude Code sottolinea la parola. Se non lo fa, vedi [Quando Claude Code non sottolinea nulla](#when-claude-code-underlines-nothing). Per disattivare di nuovo il controllo ortografico, imposta `enabled` a `false` nello stesso posto, o rimuovi `spellcheck`.576Per verificare che il controllo ortografico sia attivo, digita una parola scritta male e uno spazio. Claude Code sottolinea la parola. Se non lo fa, vedi [Quando Claude Code non sottolinea nulla](#when-claude-code-underlines-nothing). Per disattivare di nuovo il controllo ortografico, imposta `enabled` a `false` nello stesso posto, o rimuovi `spellcheck`.

577 577 

jetbrains.md +1 −1

Details

41 41 

42Se `claude` è installato in un percorso che il tuo IDE non riesce a trovare, imposta il percorso completo nell'impostazione [Claude command](#general-settings) del plugin.42Se `claude` è installato in un percorso che il tuo IDE non riesce a trovare, imposta il percorso completo nell'impostazione [Claude command](#general-settings) del plugin.

43 43 

44Claude Code funziona con qualsiasi abbonamento Claude a pagamento (Pro, Max, Team o Enterprise) o un account Claude Console, e non è richiesta alcuna chiave API. Ti verrà chiesto di [accedere](https://code.claude.com/docs/it/authentication.md#log-in-to-claude-code) la prima volta che esegui `claude`.44Claude Code funziona con qualsiasi abbonamento Claude a pagamento (Pro, Max, Ultra, Team o Enterprise) o un account Claude Console, e non è richiesta alcuna chiave API. Ti verrà chiesto di [accedere](https://code.claude.com/docs/it/authentication.md#log-in-to-claude-code) la prima volta che esegui `claude`.

45 45 

46## Utilizzo46## Utilizzo

47 47 

Details

73 73 

74Sostituisci i valori con quelli che il tuo team del gateway ti ha dato:74Sostituisci i valori con quelli che il tuo team del gateway ti ha dato:

75 75 

76**Bash o Zsh**76> [tab] Bash o Zsh

77 77>

78```bash theme={null}78> ```bash theme={null}

79export ANTHROPIC_BASE_URL=https://llm-gateway.example.com79> export ANTHROPIC_BASE_URL=https://llm-gateway.example.com

80export ANTHROPIC_AUTH_TOKEN=sk-gateway-key80> export ANTHROPIC_AUTH_TOKEN=sk-gateway-key

81```81> ```

82 

83**PowerShell**

84 82 

85```powershell theme={null}83> [tab] PowerShell

86$env:ANTHROPIC_BASE_URL = "https://llm-gateway.example.com"84>

87$env:ANTHROPIC_AUTH_TOKEN = "sk-gateway-key"85> ```powershell theme={null}

88```86> $env:ANTHROPIC_BASE_URL = "https://llm-gateway.example.com"

87> $env:ANTHROPIC_AUTH_TOKEN = "sk-gateway-key"

88> ```

89 89 

90Le esportazioni di shell si applicano solo a quella sessione di terminale e ai programmi avviati da essa. Un editor lanciato dal dock o dal menu Start non le vedrà. Per farle persistere tra i nuovi terminali, aggiungi le stesse righe al tuo profilo di shell, come `~/.zshrc`, `~/.bashrc`, o il tuo `$PROFILE` di PowerShell.90Le esportazioni di shell si applicano solo a quella sessione di terminale e ai programmi avviati da essa. Un editor lanciato dal dock o dal menu Start non le vedrà. Per farle persistere tra i nuovi terminali, aggiungi le stesse righe al tuo profilo di shell, come `~/.zshrc`, `~/.bashrc`, o il tuo `$PROFILE` di PowerShell.

91 91 

119 119 

120Con le variabili esportate nella tua shell, invia una richiesta di un token al gateway direttamente. Questo conferma che l'URL e la credenziale funzionano prima di aprire Claude Code, quindi un fallimento punta al gateway piuttosto che alla tua configurazione. I comandi di seguito leggono le variabili di shell, quindi hanno bisogno delle [esportazioni di shell](#set-as-shell-environment-variables) anche se metti anche i valori in un file di impostazioni.120Con le variabili esportate nella tua shell, invia una richiesta di un token al gateway direttamente. Questo conferma che l'URL e la credenziale funzionano prima di aprire Claude Code, quindi un fallimento punta al gateway piuttosto che alla tua configurazione. I comandi di seguito leggono le variabili di shell, quindi hanno bisogno delle [esportazioni di shell](#set-as-shell-environment-variables) anche se metti anche i valori in un file di impostazioni.

121 121 

122**Bash o Zsh**122> [tab] Bash o Zsh

123 123>

124```bash theme={null}124> ```bash theme={null}

125curl -sS -w '\n%{http_code}\n' -X POST "$ANTHROPIC_BASE_URL/v1/messages" \125> curl -sS -w '\n%{http_code}\n' -X POST "$ANTHROPIC_BASE_URL/v1/messages" \

126 -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \126> -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \

127 -H "anthropic-version: 2023-06-01" \127> -H "anthropic-version: 2023-06-01" \

128 -H "content-type: application/json" \128> -H "content-type: application/json" \

129 -d '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'129> -d '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'

130```130> ```

131 131 

132**PowerShell**132> [tab] PowerShell

133 133>

134```powershell theme={null}134> ```powershell theme={null}

135Invoke-RestMethod -Method Post -Uri "$env:ANTHROPIC_BASE_URL/v1/messages" `135> Invoke-RestMethod -Method Post -Uri "$env:ANTHROPIC_BASE_URL/v1/messages" `

136 -Headers @{ "Authorization" = "Bearer $env:ANTHROPIC_AUTH_TOKEN"; "anthropic-version" = "2023-06-01" } `136> -Headers @{ "Authorization" = "Bearer $env:ANTHROPIC_AUTH_TOKEN"; "anthropic-version" = "2023-06-01" } `

137 -ContentType "application/json" `137> -ContentType "application/json" `

138 -Body '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'138> -Body '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'

139```139> ```

140 140 

141Se il tuo gateway si aspetta chiavi nell'intestazione `x-api-key`, sostituisci l'intestazione `Authorization` con `x-api-key: $ANTHROPIC_API_KEY` nel comando Bash, o la voce della tabella hash `"Authorization"` con `"x-api-key" = "$env:ANTHROPIC_API_KEY"` nel comando PowerShell.141Se il tuo gateway si aspetta chiavi nell'intestazione `x-api-key`, sostituisci l'intestazione `Authorization` con `x-api-key: $ANTHROPIC_API_KEY` nel comando Bash, o la voce della tabella hash `"Authorization"` con `"x-api-key" = "$env:ANTHROPIC_API_KEY"` nel comando PowerShell.

142 142 

274 274 

275Alcuni gateway instradano o taggano le richieste utilizzando un'intestazione personalizzata oltre alle credenziali, ad esempio un identificatore di tenant o una chiave di instradamento. Per inviarne una, impostare [`ANTHROPIC_CUSTOM_HEADERS`](https://code.claude.com/docs/it/env-vars) con una coppia `Name: Value` per riga. L'esempio seguente aggiunge un'intestazione di instradamento denominata `X-Org-Route`:275Alcuni gateway instradano o taggano le richieste utilizzando un'intestazione personalizzata oltre alle credenziali, ad esempio un identificatore di tenant o una chiave di instradamento. Per inviarne una, impostare [`ANTHROPIC_CUSTOM_HEADERS`](https://code.claude.com/docs/it/env-vars) con una coppia `Name: Value` per riga. L'esempio seguente aggiunge un'intestazione di instradamento denominata `X-Org-Route`:

276 276 

277**Bash o Zsh**277> [tab] Bash o Zsh

278 278>

279```bash theme={null}279> ```bash theme={null}

280export ANTHROPIC_CUSTOM_HEADERS="X-Org-Route: prod"280> export ANTHROPIC_CUSTOM_HEADERS="X-Org-Route: prod"

281```281> ```

282 

283**PowerShell**

284 282 

285```powershell theme={null}283> [tab] PowerShell

286$env:ANTHROPIC_CUSTOM_HEADERS = "X-Org-Route: prod"284>

287```285> ```powershell theme={null}

286> $env:ANTHROPIC_CUSTOM_HEADERS = "X-Org-Route: prod"

287> ```

288 288 

289È possibile impostare anche `ANTHROPIC_CUSTOM_HEADERS` nel blocco `env` di un file di impostazioni. Utilizzare `\n` tra le coppie lì, poiché le stringhe JSON non possono estendersi su più righe:289È possibile impostare anche `ANTHROPIC_CUSTOM_HEADERS` nel blocco `env` di un file di impostazioni. Utilizzare `\n` tra le coppie lì, poiché le stringhe JSON non possono estendersi su più righe:

290 290 

318 318 

319L'helper è qualsiasi comando shell che stampa la credenziale corrente su stdout. Claude Code lo esegue attraverso la shell di sistema, quindi su Windows può essere un eseguibile o una chiamata PowerShell. Fare in modo che il comando stampi solo la credenziale. Su Claude Code v2.1.227 o successivo, un banner o una riga di log stampata insieme alla chiave fa [fallire l'helper](https://code.claude.com/docs/it/errors.md#your-apikeyhelper-script-is-failing). Scrivere lo script, renderlo eseguibile e farvi riferimento da `apiKeyHelper` nel [file di impostazioni](https://code.claude.com/docs/it/settings.md):319L'helper è qualsiasi comando shell che stampa la credenziale corrente su stdout. Claude Code lo esegue attraverso la shell di sistema, quindi su Windows può essere un eseguibile o una chiamata PowerShell. Fare in modo che il comando stampi solo la credenziale. Su Claude Code v2.1.227 o successivo, un banner o una riga di log stampata insieme alla chiave fa [fallire l'helper](https://code.claude.com/docs/it/errors.md#your-apikeyhelper-script-is-failing). Scrivere lo script, renderlo eseguibile e farvi riferimento da `apiKeyHelper` nel [file di impostazioni](https://code.claude.com/docs/it/settings.md):

320 320 

321**Bash o Zsh**321> [tab] Bash o Zsh

322 322>

323Ad esempio, uno script che legge da un vault:323> Ad esempio, uno script che legge da un vault:

324 324>

325```bash theme={null}325> ```bash theme={null}

326#!/bin/bash326> #!/bin/bash

327vault kv get -field=api_key secret/llm-gateway/claude-code327> vault kv get -field=api_key secret/llm-gateway/claude-code

328```328> ```

329 329>

330Farvi riferimento nel percorso in `~/.claude/settings.json`:330> Farvi riferimento nel percorso in `~/.claude/settings.json`:

331 331>

332```json theme={null}332> ```json theme={null}

333{333> {

334 "apiKeyHelper": "~/bin/get-gateway-key.sh"334> "apiKeyHelper": "~/bin/get-gateway-key.sh"

335}335> }

336```336> ```

337 

338**PowerShell**

339 

340Ad esempio, uno script che legge da un vault:

341 

342```powershell theme={null}

343vault kv get -field=api_key secret/llm-gateway/claude-code

344```

345 

346Farvi riferimento dall'invocazione PowerShell in `%USERPROFILE%\.claude\settings.json`, sfuggendo ai backslash nella stringa JSON:

347 337 

348```json theme={null}338> [tab] PowerShell

349{339>

350 "apiKeyHelper": "powershell -NoProfile -File C:\\scripts\\get-gateway-key.ps1"340> Ad esempio, uno script che legge da un vault:

351}341>

352```342> ```powershell theme={null}

343> vault kv get -field=api_key secret/llm-gateway/claude-code

344> ```

345>

346> Farvi riferimento dall'invocazione PowerShell in `%USERPROFILE%\.claude\settings.json`, sfuggendo ai backslash nella stringa JSON:

347>

348> ```json theme={null}

349> {

350> "apiKeyHelper": "powershell -NoProfile -File C:\\scripts\\get-gateway-key.ps1"

351> }

352> ```

353 353 

354Claude Code memorizza nella cache l'output dell'helper per cinque minuti per impostazione predefinita e riesegue l'helper dopo che la durata della cache scade. Per modificare la durata, impostare `CLAUDE_CODE_API_KEY_HELPER_TTL_MS` in millisecondi, ad esempio `CLAUDE_CODE_API_KEY_HELPER_TTL_MS=900000` per 15 minuti.354Claude Code memorizza nella cache l'output dell'helper per cinque minuti per impostazione predefinita e riesegue l'helper dopo che la durata della cache scade. Per modificare la durata, impostare `CLAUDE_CODE_API_KEY_HELPER_TTL_MS` in millisecondi, ad esempio `CLAUDE_CODE_API_KEY_HELPER_TTL_MS=900000` per 15 minuti.

355 355 

363 363 

364Per disattivare quel traffico, impostare `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1` insieme alle variabili del gateway, nello stesso blocco di esportazioni shell o `env` del file di impostazioni:364Per disattivare quel traffico, impostare `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1` insieme alle variabili del gateway, nello stesso blocco di esportazioni shell o `env` del file di impostazioni:

365 365 

366**Bash o Zsh**366> [tab] Bash o Zsh

367 367>

368```bash theme={null}368> ```bash theme={null}

369export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1369> export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1

370```370> ```

371 

372**PowerShell**

373 371 

374```powershell theme={null}372> [tab] PowerShell

375$env:CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1"373>

376```374> ```powershell theme={null}

375> $env:CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1"

376> ```

377 377 

378L'impostazione della variabile ha questi effetti e limiti:378L'impostazione della variabile ha questi effetti e limiti:

379 379 

398 398 

399Lasciare `AWS_BEARER_TOKEN_BEDROCK` non impostato quando il gateway emette la sua credenziale. Se lo si imposta, Claude Code invia quella [chiave API Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md#2-configure-aws-credentials) come intestazione `Authorization` invece del token del gateway, anche con `CLAUDE_CODE_SKIP_BEDROCK_AUTH` impostato.399Lasciare `AWS_BEARER_TOKEN_BEDROCK` non impostato quando il gateway emette la sua credenziale. Se lo si imposta, Claude Code invia quella [chiave API Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md#2-configure-aws-credentials) come intestazione `Authorization` invece del token del gateway, anche con `CLAUDE_CODE_SKIP_BEDROCK_AUTH` impostato.

400 400 

401**Bash o Zsh**401> [tab] Bash o Zsh

402 402>

403```bash theme={null}403> ```bash theme={null}

404export ANTHROPIC_BEDROCK_BASE_URL=https://llm-gateway.example.com/bedrock404> export ANTHROPIC_BEDROCK_BASE_URL=https://llm-gateway.example.com/bedrock

405export CLAUDE_CODE_SKIP_BEDROCK_AUTH=1405> export CLAUDE_CODE_SKIP_BEDROCK_AUTH=1

406export CLAUDE_CODE_USE_BEDROCK=1406> export CLAUDE_CODE_USE_BEDROCK=1

407```407> ```

408 

409**PowerShell**

410 408 

411```powershell theme={null}409> [tab] PowerShell

412$env:ANTHROPIC_BEDROCK_BASE_URL = "https://llm-gateway.example.com/bedrock"410>

413$env:CLAUDE_CODE_SKIP_BEDROCK_AUTH = "1"411> ```powershell theme={null}

414$env:CLAUDE_CODE_USE_BEDROCK = "1"412> $env:ANTHROPIC_BEDROCK_BASE_URL = "https://llm-gateway.example.com/bedrock"

415```413> $env:CLAUDE_CODE_SKIP_BEDROCK_AUTH = "1"

414> $env:CLAUDE_CODE_USE_BEDROCK = "1"

415> ```

416 416 

417#### Google Cloud's Agent Platform417#### Google Cloud's Agent Platform

418 418 

419Sostituire l'ID del progetto e la regione con i propri valori. Claude Code include entrambi nel percorso di ogni richiesta che invia al gateway:419Sostituire l'ID del progetto e la regione con i propri valori. Claude Code include entrambi nel percorso di ogni richiesta che invia al gateway:

420 420 

421**Bash o Zsh**421> [tab] Bash o Zsh

422 422>

423```bash theme={null}423> ```bash theme={null}

424export ANTHROPIC_VERTEX_BASE_URL=https://llm-gateway.example.com/vertex424> export ANTHROPIC_VERTEX_BASE_URL=https://llm-gateway.example.com/vertex

425export ANTHROPIC_VERTEX_PROJECT_ID=your-gcp-project-id425> export ANTHROPIC_VERTEX_PROJECT_ID=your-gcp-project-id

426export CLAUDE_CODE_SKIP_VERTEX_AUTH=1426> export CLAUDE_CODE_SKIP_VERTEX_AUTH=1

427export CLAUDE_CODE_USE_VERTEX=1427> export CLAUDE_CODE_USE_VERTEX=1

428export CLOUD_ML_REGION=us-east5428> export CLOUD_ML_REGION=us-east5

429```429> ```

430 430 

431**PowerShell**431> [tab] PowerShell

432 432>

433```powershell theme={null}433> ```powershell theme={null}

434$env:ANTHROPIC_VERTEX_BASE_URL = "https://llm-gateway.example.com/vertex"434> $env:ANTHROPIC_VERTEX_BASE_URL = "https://llm-gateway.example.com/vertex"

435$env:ANTHROPIC_VERTEX_PROJECT_ID = "your-gcp-project-id"435> $env:ANTHROPIC_VERTEX_PROJECT_ID = "your-gcp-project-id"

436$env:CLAUDE_CODE_SKIP_VERTEX_AUTH = "1"436> $env:CLAUDE_CODE_SKIP_VERTEX_AUTH = "1"

437$env:CLAUDE_CODE_USE_VERTEX = "1"437> $env:CLAUDE_CODE_USE_VERTEX = "1"

438$env:CLOUD_ML_REGION = "us-east5"438> $env:CLOUD_ML_REGION = "us-east5"

439```439> ```

440 440 

441Il blocco copre l'instradamento e l'autenticazione. Gli override di regione e i pin di modello dalla [configurazione di Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md#4-configure-claude-code) si applicano anche attraverso un gateway:441Il blocco copre l'instradamento e l'autenticazione. Gli override di regione e i pin di modello dalla [configurazione di Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md#4-configure-claude-code) si applicano anche attraverso un gateway:

442 442 

450 450 

451Per un gateway che inietta una propria intestazione `Authorization`, imposta `CLAUDE_CODE_SKIP_FOUNDRY_AUTH=1` e lascia entrambe le variabili di credenziale non impostate. Claude Code invia quindi le richieste senza una credenziale Azure e preserva l'intestazione `Authorization` che fornisci, ad esempio tramite `ANTHROPIC_CUSTOM_HEADERS`.451Per un gateway che inietta una propria intestazione `Authorization`, imposta `CLAUDE_CODE_SKIP_FOUNDRY_AUTH=1` e lascia entrambe le variabili di credenziale non impostate. Claude Code invia quindi le richieste senza una credenziale Azure e preserva l'intestazione `Authorization` che fornisci, ad esempio tramite `ANTHROPIC_CUSTOM_HEADERS`.

452 452 

453**Bash o Zsh**453> [tab] Bash o Zsh

454 454>

455```bash theme={null}455> ```bash theme={null}

456export ANTHROPIC_FOUNDRY_BASE_URL=https://llm-gateway.example.com/foundry456> export ANTHROPIC_FOUNDRY_BASE_URL=https://llm-gateway.example.com/foundry

457export ANTHROPIC_FOUNDRY_API_KEY=sk-gateway-key457> export ANTHROPIC_FOUNDRY_API_KEY=sk-gateway-key

458export CLAUDE_CODE_USE_FOUNDRY=1458> export CLAUDE_CODE_USE_FOUNDRY=1

459```459> ```

460 

461**PowerShell**

462 460 

463```powershell theme={null}461> [tab] PowerShell

464$env:ANTHROPIC_FOUNDRY_BASE_URL = "https://llm-gateway.example.com/foundry"462>

465$env:ANTHROPIC_FOUNDRY_API_KEY = "sk-gateway-key"463> ```powershell theme={null}

466$env:CLAUDE_CODE_USE_FOUNDRY = "1"464> $env:ANTHROPIC_FOUNDRY_BASE_URL = "https://llm-gateway.example.com/foundry"

467```465> $env:ANTHROPIC_FOUNDRY_API_KEY = "sk-gateway-key"

466> $env:CLAUDE_CODE_USE_FOUNDRY = "1"

467> ```

468 468 

469#### Claude Platform on AWS469#### Claude Platform on AWS

470 470 

471Vedere [Claude Platform on AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md) per l'ID dell'area di lavoro.471Vedere [Claude Platform on AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md) per l'ID dell'area di lavoro.

472 472 

473**Bash o Zsh**473> [tab] Bash o Zsh

474 474>

475```bash theme={null}475> ```bash theme={null}

476export ANTHROPIC_AWS_BASE_URL=https://llm-gateway.example.com/anthropic-aws476> export ANTHROPIC_AWS_BASE_URL=https://llm-gateway.example.com/anthropic-aws

477export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN477> export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

478export CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH=1478> export CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH=1

479export CLAUDE_CODE_USE_ANTHROPIC_AWS=1479> export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

480```480> ```

481 481 

482**PowerShell**482> [tab] PowerShell

483 483>

484```powershell theme={null}484> ```powershell theme={null}

485$env:ANTHROPIC_AWS_BASE_URL = "https://llm-gateway.example.com/anthropic-aws"485> $env:ANTHROPIC_AWS_BASE_URL = "https://llm-gateway.example.com/anthropic-aws"

486$env:ANTHROPIC_AWS_WORKSPACE_ID = "wrkspc_01ABCDEFGHIJKLMN"486> $env:ANTHROPIC_AWS_WORKSPACE_ID = "wrkspc_01ABCDEFGHIJKLMN"

487$env:CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH = "1"487> $env:CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH = "1"

488$env:CLAUDE_CODE_USE_ANTHROPIC_AWS = "1"488> $env:CLAUDE_CODE_USE_ANTHROPIC_AWS = "1"

489```489> ```

490 490 

491#### Confermare l'instradamento del provider491#### Confermare l'instradamento del provider

492 492 

Details

62* `<gateway-key>` è qualunque credenziale vi consenta di chiamare il gateway in questo momento: una chiave amministrativa, una chiave di test o la vostra chiave sviluppatore personale se ne avete già emessa una. Non tutti i prodotti gateway hanno una credenziale amministrativa separata; se il vostro non ne ha una, emettete prima una chiave sviluppatore per voi stessi in [Emettere credenziali per sviluppatori](#issue-developer-credentials)62* `<gateway-key>` è qualunque credenziale vi consenta di chiamare il gateway in questo momento: una chiave amministrativa, una chiave di test o la vostra chiave sviluppatore personale se ne avete già emessa una. Non tutti i prodotti gateway hanno una credenziale amministrativa separata; se il vostro non ne ha una, emettete prima una chiave sviluppatore per voi stessi in [Emettere credenziali per sviluppatori](#issue-developer-credentials)

63* `model` è un nome di modello Claude che il vostro gateway è configurato per instradare. L'esempio usa `claude-sonnet-4-6`; sostituite un nome che avete configurato63* `model` è un nome di modello Claude che il vostro gateway è configurato per instradare. L'esempio usa `claude-sonnet-4-6`; sostituite un nome che avete configurato

64 64 

65**Bash o Zsh**65> [tab] Bash o Zsh

66 66>

67```bash theme={null}67> ```bash theme={null}

68curl -X POST "https://llm-gateway.example.com/v1/messages" \68> curl -X POST "https://llm-gateway.example.com/v1/messages" \

69 -H "Authorization: Bearer <gateway-key>" \69> -H "Authorization: Bearer <gateway-key>" \

70 -H "anthropic-version: 2023-06-01" \70> -H "anthropic-version: 2023-06-01" \

71 -H "content-type: application/json" \71> -H "content-type: application/json" \

72 -d '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'72> -d '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'

73```73> ```

74 74 

75**PowerShell**75> [tab] PowerShell

76 76>

77```powershell theme={null}77> ```powershell theme={null}

78Invoke-RestMethod -Method Post -Uri "https://llm-gateway.example.com/v1/messages" `78> Invoke-RestMethod -Method Post -Uri "https://llm-gateway.example.com/v1/messages" `

79 -Headers @{ "Authorization" = "Bearer <gateway-key>"; "anthropic-version" = "2023-06-01" } `79> -Headers @{ "Authorization" = "Bearer <gateway-key>"; "anthropic-version" = "2023-06-01" } `

80 -ContentType "application/json" `80> -ContentType "application/json" `

81 -Body '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'81> -Body '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'

82```82> ```

83 83 

84**Checkpoint**: un `200` con un campo `content` significa che il gateway ha raggiunto il provider con quel nome di modello. Un `404` significa che quel nome non è instradato al gateway; un `401` dal provider significa che la credenziale del provider del gateway è sbagliata.84**Checkpoint**: un `200` con un campo `content` significa che il gateway ha raggiunto il provider con quel nome di modello. Un `404` significa che quel nome non è instradato al gateway; un `401` dal provider significa che la credenziale del provider del gateway è sbagliata.

85 85 

95 95 

96Confermate che una chiave appena emessa funzioni rispetto al gateway con la stessa richiesta di [Confermare che il gateway instrada i vostri modelli](#confirm-the-gateway-routes-your-models), sostituendo `<gateway-key>` con la nuova `<developer-key>`:96Confermate che una chiave appena emessa funzioni rispetto al gateway con la stessa richiesta di [Confermare che il gateway instrada i vostri modelli](#confirm-the-gateway-routes-your-models), sostituendo `<gateway-key>` con la nuova `<developer-key>`:

97 97 

98**Bash o Zsh**98> [tab] Bash o Zsh

99 99>

100```bash theme={null}100> ```bash theme={null}

101curl -X POST "https://llm-gateway.example.com/v1/messages" \101> curl -X POST "https://llm-gateway.example.com/v1/messages" \

102 -H "Authorization: Bearer <developer-key>" \102> -H "Authorization: Bearer <developer-key>" \

103 -H "anthropic-version: 2023-06-01" \103> -H "anthropic-version: 2023-06-01" \

104 -H "content-type: application/json" \104> -H "content-type: application/json" \

105 -d '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'105> -d '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'

106```106> ```

107 107 

108**PowerShell**108> [tab] PowerShell

109 109>

110```powershell theme={null}110> ```powershell theme={null}

111Invoke-RestMethod -Method Post -Uri "https://llm-gateway.example.com/v1/messages" `111> Invoke-RestMethod -Method Post -Uri "https://llm-gateway.example.com/v1/messages" `

112 -Headers @{ "Authorization" = "Bearer <developer-key>"; "anthropic-version" = "2023-06-01" } `112> -Headers @{ "Authorization" = "Bearer <developer-key>"; "anthropic-version" = "2023-06-01" } `

113 -ContentType "application/json" `113> -ContentType "application/json" `

114 -Body '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'114> -Body '{"model": "claude-sonnet-4-6", "max_tokens": 1, "messages": [{"role": "user", "content": "."}]}'

115```115> ```

116 116 

117**Checkpoint**: un `200` con un campo `content` significa che la chiave dello sviluppatore raggiunge il gateway e il gateway la inoltra. Un `401` qui, quando [il passaggio precedente](#confirm-the-gateway-routes-your-models) ha avuto successo, significa che la chiave dello sviluppatore è sbagliata o non ha ancora avuto effetto al gateway.117**Checkpoint**: un `200` con un campo `content` significa che la chiave dello sviluppatore raggiunge il gateway e il gateway la inoltra. Un `401` qui, quando [il passaggio precedente](#confirm-the-gateway-routes-your-models) ha avuto successo, significa che la chiave dello sviluppatore è sbagliata o non ha ancora avuto effetto al gateway.

118 118 

122 122 

123Eseguite Claude Code attraverso il gateway voi stessi prima di distribuire qualcosa, usando la stessa configurazione che la distribuzione consegnerà a livello di flotta. Digitate questi direttamente in un terminale, non in un file `.env` o di impostazioni; durano solo per questa sessione di terminale, quindi chiuderla restituisce la vostra macchina alla sua configurazione normale. Usate `ANTHROPIC_API_KEY` invece di `ANTHROPIC_AUTH_TOKEN` se il vostro gateway legge l'intestazione `x-api-key`:123Eseguite Claude Code attraverso il gateway voi stessi prima di distribuire qualcosa, usando la stessa configurazione che la distribuzione consegnerà a livello di flotta. Digitate questi direttamente in un terminale, non in un file `.env` o di impostazioni; durano solo per questa sessione di terminale, quindi chiuderla restituisce la vostra macchina alla sua configurazione normale. Usate `ANTHROPIC_API_KEY` invece di `ANTHROPIC_AUTH_TOKEN` se il vostro gateway legge l'intestazione `x-api-key`:

124 124 

125**Bash o Zsh**125> [tab] Bash o Zsh

126 126>

127```bash theme={null}127> ```bash theme={null}

128export ANTHROPIC_BASE_URL=https://llm-gateway.example.com128> export ANTHROPIC_BASE_URL=https://llm-gateway.example.com

129export ANTHROPIC_AUTH_TOKEN="<developer-key>"129> export ANTHROPIC_AUTH_TOKEN="<developer-key>"

130```130> ```

131 

132**PowerShell**

133 131 

134```powershell theme={null}132> [tab] PowerShell

135$env:ANTHROPIC_BASE_URL = "https://llm-gateway.example.com"133>

136$env:ANTHROPIC_AUTH_TOKEN = "<developer-key>"134> ```powershell theme={null}

137```135> $env:ANTHROPIC_BASE_URL = "https://llm-gateway.example.com"

136> $env:ANTHROPIC_AUTH_TOKEN = "<developer-key>"

137> ```

138 138 

139Quindi inviate un prompt una tantum attraverso il gateway:139Quindi inviate un prompt una tantum attraverso il gateway:

140 140 

224 224 

225Confermate che tutto funzioni da una macchina sviluppatore, non dall'host del gateway, in modo che il test copra il percorso di rete che gli sviluppatori usano. Inviate una richiesta in streaming, che controlla l'endpoint, il pass-through dello streaming e l'instradamento del modello in una volta:225Confermate che tutto funzioni da una macchina sviluppatore, non dall'host del gateway, in modo che il test copra il percorso di rete che gli sviluppatori usano. Inviate una richiesta in streaming, che controlla l'endpoint, il pass-through dello streaming e l'instradamento del modello in una volta:

226 226 

227**Bash o Zsh**227> [tab] Bash o Zsh

228 228>

229```bash theme={null}229> ```bash theme={null}

230curl -N -X POST "https://llm-gateway.example.com/v1/messages" \230> curl -N -X POST "https://llm-gateway.example.com/v1/messages" \

231 -H "Authorization: Bearer <developer-key>" \231> -H "Authorization: Bearer <developer-key>" \

232 -H "anthropic-version: 2023-06-01" \232> -H "anthropic-version: 2023-06-01" \

233 -H "content-type: application/json" \233> -H "content-type: application/json" \

234 -d '{"model": "claude-sonnet-4-6", "max_tokens": 16, "stream": true, "messages": [{"role": "user", "content": "count to 3"}]}'234> -d '{"model": "claude-sonnet-4-6", "max_tokens": 16, "stream": true, "messages": [{"role": "user", "content": "count to 3"}]}'

235```235> ```

236 236 

237**PowerShell**237> [tab] PowerShell

238 238>

239```powershell theme={null}239> ```powershell theme={null}

240$body = '{"model": "claude-sonnet-4-6", "max_tokens": 16, "stream": true, "messages": [{"role": "user", "content": "count to 3"}]}'240> $body = '{"model": "claude-sonnet-4-6", "max_tokens": 16, "stream": true, "messages": [{"role": "user", "content": "count to 3"}]}'

241$body | curl.exe -N -X POST "https://llm-gateway.example.com/v1/messages" `241> $body | curl.exe -N -X POST "https://llm-gateway.example.com/v1/messages" `

242 -H "Authorization: Bearer <developer-key>" `242> -H "Authorization: Bearer <developer-key>" `

243 -H "anthropic-version: 2023-06-01" `243> -H "anthropic-version: 2023-06-01" `

244 -H "content-type: application/json" `244> -H "content-type: application/json" `

245 --data-binary '@-'245> --data-binary '@-'

246```246> ```

247 247 

248Dovreste vedere le righe `data:` arrivare in modo incrementale. L'intera risposta che arriva in una volta dopo una pausa significa che il gateway sta memorizzando nel buffer, il che blocca Claude Code; un `404` significa che il nome del modello non è instradato. Ripetete per nome di modello.248Dovreste vedere le righe `data:` arrivare in modo incrementale. L'intera risposta che arriva in una volta dopo una pausa significa che il gateway sta memorizzando nel buffer, il che blocca Claude Code; un `404` significa che il nome del modello non è instradato. Ripetete per nome di modello.

249 249 

managed-mcp.md +5 −5

Details

403 403 

404Gli accordion di seguito illustrano come un server viene valutato rispetto ad altre combinazioni di allowlist e denylist.404Gli accordion di seguito illustrano come un server viene valutato rispetto ad altre combinazioni di allowlist e denylist.

405 405 

406> **Allowlist solo URL**406> [accordion] Allowlist solo URL

407>407>

408> ```json theme={null}408> ```json theme={null}

409> {409> {

421> | Server HTTP a `https://external.example.com/mcp` | Bloccato: non corrisponde a nessun modello di URL |421> | Server HTTP a `https://external.example.com/mcp` | Bloccato: non corrisponde a nessun modello di URL |

422> | Server stdio con qualsiasi comando | Bloccato: nessuna voce di nome o comando a cui corrispondere |422> | Server stdio con qualsiasi comando | Bloccato: nessuna voce di nome o comando a cui corrispondere |

423 423 

424> **Allowlist solo comando**424> [accordion] Allowlist solo comando

425>425>

426> ```json theme={null}426> ```json theme={null}

427> {427> {

437> | Server stdio con `["node", "server.js"]` | Bloccato: non corrisponde al comando |437> | Server stdio con `["node", "server.js"]` | Bloccato: non corrisponde al comando |

438> | Server HTTP denominato `my-api` | Bloccato: nessuna voce di nome a cui corrispondere |438> | Server HTTP denominato `my-api` | Bloccato: nessuna voce di nome a cui corrispondere |

439 439 

440> **Allowlist misto di nome e comando**440> [accordion] Allowlist misto di nome e comando

441>441>

442> ```json theme={null}442> ```json theme={null}

443> {443> {

456> | Server HTTP denominato `github` | Consentito: corrisponde al nome |456> | Server HTTP denominato `github` | Consentito: corrisponde al nome |

457> | Server HTTP denominato `other-api` | Bloccato: il nome non corrisponde |457> | Server HTTP denominato `other-api` | Bloccato: il nome non corrisponde |

458 458 

459> **Allowlist solo nome**459> [accordion] Allowlist solo nome

460>460>

461> ```json theme={null}461> ```json theme={null}

462> {462> {

474> | Server HTTP denominato `github` | Consentito: corrisponde al nome |474> | Server HTTP denominato `github` | Consentito: corrisponde al nome |

475> | Qualsiasi server denominato `other` | Bloccato: il nome non corrisponde |475> | Qualsiasi server denominato `other` | Bloccato: il nome non corrisponde |

476 476 

477> **Allowlist con override del denylist**477> [accordion] Allowlist con override del denylist

478>478>

479> ```json theme={null}479> ```json theme={null}

480> {480> {

mcp.md +35 −35

Details

1039 1039 

1040Le schede coprono entrambi i comandi: `claude mcp add` accetta il tuo ID client e la porta di callback come flag, e `claude mcp add-json` li accetta in un oggetto `oauth`. Se hai registrato un URI di reindirizzamento, imposta la porta di callback sulla porta in quell'URI.1040Le schede coprono entrambi i comandi: `claude mcp add` accetta il tuo ID client e la porta di callback come flag, e `claude mcp add-json` li accetta in un oggetto `oauth`. Se hai registrato un URI di reindirizzamento, imposta la porta di callback sulla porta in quell'URI.

1041 1041 

1042**claude mcp add**1042> [tab] claude mcp add

1043 1043>

1044Utilizza `--client-id` per passare l'ID client della tua app. Il flag `--client-secret` richiede il segreto con input mascherato:1044> Utilizza `--client-id` per passare l'ID client della tua app. Il flag `--client-secret` richiede il segreto con input mascherato:

1045 1045>

1046```bash theme={null}1046> ```bash theme={null}

1047claude mcp add --transport http \1047> claude mcp add --transport http \

1048 --client-id your-client-id --client-secret --callback-port 8080 \1048> --client-id your-client-id --client-secret --callback-port 8080 \

1049 my-server https://mcp.example.com/mcp1049> my-server https://mcp.example.com/mcp

1050```1050> ```

1051 

1052**claude mcp add-json**

1053 

1054Includi l'oggetto `oauth` nella configurazione JSON e passa `--client-secret` come flag separato:

1055 

1056```bash theme={null}

1057claude mcp add-json my-server \

1058 '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"clientId":"your-client-id","callbackPort":8080}}' \

1059 --client-secret

1060```

1061 

1062**claude mcp add-json (solo porta di callback)**

1063 

1064Per fissare solo la porta di callback e consentire a Claude Code di registrare il client automaticamente, imposta `callbackPort` da solo:

1065 

1066```bash theme={null}

1067claude mcp add-json my-server \

1068 '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"callbackPort":8080}}'

1069```

1070 1051 

1071**CI / env var**1052> [tab] claude mcp add-json

1053>

1054> Includi l'oggetto `oauth` nella configurazione JSON e passa `--client-secret` come flag separato:

1055>

1056> ```bash theme={null}

1057> claude mcp add-json my-server \

1058> '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"clientId":"your-client-id","callbackPort":8080}}' \

1059> --client-secret

1060> ```

1072 1061 

1073Imposta il segreto tramite variabile d'ambiente per saltare il prompt interattivo:1062> [tab] claude mcp add-json (solo porta di callback)

1063>

1064> Per fissare solo la porta di callback e consentire a Claude Code di registrare il client automaticamente, imposta `callbackPort` da solo:

1065>

1066> ```bash theme={null}

1067> claude mcp add-json my-server \

1068> '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"callbackPort":8080}}'

1069> ```

1074 1070 

1075```bash theme={null}1071> [tab] CI / env var

1076MCP_CLIENT_SECRET=your-secret claude mcp add --transport http \1072>

1077 --client-id your-client-id --client-secret --callback-port 8080 \1073> Imposta il segreto tramite variabile d'ambiente per saltare il prompt interattivo:

1078 my-server https://mcp.example.com/mcp1074>

1079```1075> ```bash theme={null}

1076> MCP_CLIENT_SECRET=your-secret claude mcp add --transport http \

1077> --client-id your-client-id --client-secret --callback-port 8080 \

1078> my-server https://mcp.example.com/mcp

1079> ```

1080 1080 

1081**3. Autenticati in Claude Code**1081**3. Autenticati in Claude Code**

1082 1082 

Details

286 286 

287Se un server non si connette, controllare il suo stato con `/mcp` all'interno di una sessione o `claude mcp list` dal vostro shell, quindi abbinare il sintomo seguente. Il pannello `/mcp` vi consente anche di riconnettervi o autenticarvi senza lasciare la sessione.287Se un server non si connette, controllare il suo stato con `/mcp` all'interno di una sessione o `claude mcp list` dal vostro shell, quindi abbinare il sintomo seguente. Il pannello `/mcp` vi consente anche di riconnettervi o autenticarvi senza lasciare la sessione.

288 288 

289> **/mcp shows No MCP servers configured**289> [accordion] /mcp shows No MCP servers configured

290>290>

291> Claude Code non ha trovato alcun server per la directory corrente. Le cause più comuni:291> Claude Code non ha trovato alcun server per la directory corrente. Le cause più comuni:

292>292>

294> * Avete modificato un file di configurazione al percorso sbagliato. I file corretti sono `~/.claude.json` e `<project>/.mcp.json`. Claude Code non legge percorsi come `~/.claude/.mcp.json`, `~/.claude/config/mcp.json`, `~/.claude/mcp.json`, o `%APPDATA%\Claude\mcp.json`. Per i server con ambito utente, eseguire `claude mcp add --scope user`, che scrive nella chiave `mcpServers` in `~/.claude.json`; per i server con ambito progetto, modificare `.mcp.json` nella radice del progetto.294> * Avete modificato un file di configurazione al percorso sbagliato. I file corretti sono `~/.claude.json` e `<project>/.mcp.json`. Claude Code non legge percorsi come `~/.claude/.mcp.json`, `~/.claude/config/mcp.json`, `~/.claude/mcp.json`, o `%APPDATA%\Claude\mcp.json`. Per i server con ambito utente, eseguire `claude mcp add --scope user`, che scrive nella chiave `mcpServers` in `~/.claude.json`; per i server con ambito progetto, modificare `.mcp.json` nella radice del progetto.

295> * Avete scritto una voce malformata in `.mcp.json`. Claude Code salta quella voce e carica comunque le altre. Eseguire `claude mcp list` dal vostro shell e cercare l'avviso di analisi, che nomina il campo offensivo.295> * Avete scritto una voce malformata in `.mcp.json`. Claude Code salta quella voce e carica comunque le altre. Eseguire `claude mcp list` dal vostro shell e cercare l'avviso di analisi, che nomina il campo offensivo.

296 296 

297> **Status shows Failed to connect or Connection error**297> [accordion] Status shows Failed to connect or Connection error

298>298>

299> Entrambi gli stati significano che il server non è stato avviato o l'URL non ha risposto. Possono anche apparire per i server HTTP che rifiutano il token configurato in `headers.Authorization`; un server che vuole un token che non avete configurato mostra `! Needs authentication` invece, coperto in [Connettere un server che richiede l'accesso](#connect-a-server-that-requires-sign-in).299> Entrambi gli stati significano che il server non è stato avviato o l'URL non ha risposto. Possono anche apparire per i server HTTP che rifiutano il token configurato in `headers.Authorization`; un server che vuole un token che non avete configurato mostra `! Needs authentication` invece, coperto in [Connettere un server che richiede l'accesso](#connect-a-server-that-requires-sign-in).

300>300>

334> Eseguire `claude mcp get <name>` e confermare che il comando mostrato lì corrisponda a quello che avete appena eseguito. Se il comando mostrato differisce da quello che avete digitato, probabilmente avete omesso il separatore `--` prima del comando del server. Rimuovere il server e riaggiungerlo con `--` al suo posto. Se avete scritto `.mcp.json` a mano, controllare la sua sintassi e posizione. Prima della v2.1.285, `claude mcp get` non stampava alcuna riga `Command` per una voce stdio salvata senza un campo `type`, come una voce `.mcp.json` scritta a mano. Su quelle versioni, eseguire `claude mcp list` invece, che stampa la riga di comando in entrambi i casi.334> Eseguire `claude mcp get <name>` e confermare che il comando mostrato lì corrisponda a quello che avete appena eseguito. Se il comando mostrato differisce da quello che avete digitato, probabilmente avete omesso il separatore `--` prima del comando del server. Rimuovere il server e riaggiungerlo con `--` al suo posto. Se avete scritto `.mcp.json` a mano, controllare la sua sintassi e posizione. Prima della v2.1.285, `claude mcp get` non stampava alcuna riga `Command` per una voce stdio salvata senza un campo `type`, come una voce `.mcp.json` scritta a mano. Su quelle versioni, eseguire `claude mcp list` invece, che stampa la riga di comando in entrambi i casi.

335> * Il comando genera un errore: il messaggio nomina cosa manca, come Node.js o un browser.335> * Il comando genera un errore: il messaggio nomina cosa manca, come Node.js o un browser.

336 336 

337> **Connection timed out at startup**337> [accordion] Connection timed out at startup

338>338>

339> Il server ha impiegato più del timeout di avvio predefinito di 30 secondi. La prima esecuzione di un server stdio può essere lenta mentre `npx` scarica il pacchetto. Aumentare il limite con la variabile di ambiente [`MCP_TIMEOUT`](https://code.claude.com/docs/it/env-vars), in millisecondi:339> Il server ha impiegato più del timeout di avvio predefinito di 30 secondi. La prima esecuzione di un server stdio può essere lenta mentre `npx` scarica il pacchetto. Aumentare il limite con la variabile di ambiente [`MCP_TIMEOUT`](https://code.claude.com/docs/it/env-vars), in millisecondi:

340>340>

350>350>

351> Prima della v2.1.299, alcune connessioni a server HTTP attivi andavano in timeout all'avvio indipendentemente da `MCP_TIMEOUT`. Se usi una di quelle versioni e un server HTTP attivo va ancora in timeout dopo che hai aumentato il limite, [aggiorna Claude Code](https://code.claude.com/docs/it/setup.md#update-claude-code).351> Prima della v2.1.299, alcune connessioni a server HTTP attivi andavano in timeout all'avvio indipendentemente da `MCP_TIMEOUT`. Se usi una di quelle versioni e un server HTTP attivo va ancora in timeout dopo che hai aumentato il limite, [aggiorna Claude Code](https://code.claude.com/docs/it/setup.md#update-claude-code).

352 352 

353> **Server already exists**353> [accordion] Server already exists

354>354>

355> Avete già aggiunto un server con quel nome allo stesso ambito. O rimuovete l'entry esistente per primo o scegliete un nome diverso:355> Avete già aggiunto un server con quel nome allo stesso ambito. O rimuovete l'entry esistente per primo o scegliete un nome diverso:

356>356>

360>360>

361> Se il nome esiste in più di un ambito, `remove` segnala `exists in multiple scopes`. Passare `--scope` per scegliere quale copia eliminare, ad esempio `claude mcp remove claude-code-docs --scope local`.361> Se il nome esiste in più di un ambito, `remove` segnala `exists in multiple scopes`. Passare `--scope` per scegliere quale copia eliminare, ad esempio `claude mcp remove claude-code-docs --scope local`.

362 362 

363> **Server connects but no tools appear**363> [accordion] Server connects but no tools appear

364>364>

365> Eseguire `/mcp` all'interno di una sessione e selezionare il server per vedere il suo elenco di strumenti. Se l'elenco è vuoto, il server è stato avviato ma non ha registrato alcuno strumento, il che di solito significa che manca una variabile di ambiente richiesta come una chiave API.365> Eseguire `/mcp` all'interno di una sessione e selezionare il server per vedere il suo elenco di strumenti. Se l'elenco è vuoto, il server è stato avviato ma non ha registrato alcuno strumento, il che di solito significa che manca una variabile di ambiente richiesta come una chiave API.

366>366>

368>368>

369> Prima della v2.1.302, `/mcp` mostrava lo stato `tools fetch failed` per un server che usava la [revisione del protocollo 2026-07-28](https://code.claude.com/docs/it/mcp.md#mcp-client-runtimes) e ometteva `resultType`, `ttlMs` o `cacheScope` dalle sue risposte. Se usi una di quelle versioni e un server mostra quello stato, [aggiorna Claude Code](https://code.claude.com/docs/it/setup.md#update-claude-code).369> Prima della v2.1.302, `/mcp` mostrava lo stato `tools fetch failed` per un server che usava la [revisione del protocollo 2026-07-28](https://code.claude.com/docs/it/mcp.md#mcp-client-runtimes) e ometteva `resultType`, `ttlMs` o `cacheScope` dalle sue risposte. Se usi una di quelle versioni e un server mostra quello stato, [aggiorna Claude Code](https://code.claude.com/docs/it/setup.md#update-claude-code).

370 370 

371> **Changes to .mcp.json don't take effect**371> [accordion] Changes to .mcp.json don't take effect

372>372>

373> Claude Code legge `.mcp.json` all'avvio della sessione. Uscire e riavviare la sessione dopo aver modificato il file.373> Claude Code legge `.mcp.json` all'avvio della sessione. Uscire e riavviare la sessione dopo aver modificato il file.

374>374>

380> claude mcp reset-project-choices380> claude mcp reset-project-choices

381> ```381> ```

382 382 

383> **OAuth sign-in fails or browser doesn't open**383> [accordion] OAuth sign-in fails or browser doesn't open

384>384>

385> Eseguire `/mcp`, selezionare il server e scegliere `Authenticate` di nuovo. Se il browser non si apre automaticamente, copiare l'URL mostrato nel terminale e aprirlo manualmente. Vedere [Autenticarsi con server MCP remoti](https://code.claude.com/docs/it/mcp.md#authenticate-with-remote-mcp-servers) per porte di callback fisse e credenziali preconfigurate.385> Eseguire `/mcp`, selezionare il server e scegliere `Authenticate` di nuovo. Se il browser non si apre automaticamente, copiare l'URL mostrato nel terminale e aprirlo manualmente. Vedere [Autenticarsi con server MCP remoti](https://code.claude.com/docs/it/mcp.md#authenticate-with-remote-mcp-servers) per porte di callback fisse e credenziali preconfigurate.

386 386 

mobile.md +2 −2

Details

39| [Cloud sessions](https://code.claude.com/docs/it/claude-code-on-the-web.md) | Una sessione su infrastruttura cloud, gestita da Anthropic per impostazione predefinita | Il tuo repository è su GitHub e il task dovrebbe continuare a essere eseguito dopo aver messo il telefono via. Vedi la [guida rapida cloud](https://code.claude.com/docs/it/web-quickstart.md) per configurare. |39| [Cloud sessions](https://code.claude.com/docs/it/claude-code-on-the-web.md) | Una sessione su infrastruttura cloud, gestita da Anthropic per impostazione predefinita | Il tuo repository è su GitHub e il task dovrebbe continuare a essere eseguito dopo aver messo il telefono via. Vedi la [guida rapida cloud](https://code.claude.com/docs/it/web-quickstart.md) per configurare. |

40| [Projects](https://code.claude.com/docs/it/claude-projects.md) | Una conversazione dove Claude coordina thread paralleli di lavoro e riferisce i risultati | Hai un flusso di lavoro correlato piuttosto che un singolo task e vuoi vedere quali thread sono terminati o hanno bisogno di te. |40| [Projects](https://code.claude.com/docs/it/claude-projects.md) | Una conversazione dove Claude coordina thread paralleli di lavoro e riferisce i risultati | Hai un flusso di lavoro correlato piuttosto che un singolo task e vuoi vedere quali thread sono terminati o hanno bisogno di te. |

41| [Remote Control](https://code.claude.com/docs/it/remote-control.md) | Una sessione di Claude Code in esecuzione sul tuo computer | Il lavoro ha bisogno del tuo filesystem locale, strumenti o server MCP. |41| [Remote Control](https://code.claude.com/docs/it/remote-control.md) | Una sessione di Claude Code in esecuzione sul tuo computer | Il lavoro ha bisogno del tuo filesystem locale, strumenti o server MCP. |

42| [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) | L'app Desktop sul tuo computer | Vuoi inviare un task tramite messaggio e lasciare che Dispatch decida come eseguirlo. Richiede un piano Pro o Max. |42| [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) | L'app Desktop sul tuo computer | Vuoi inviare un task tramite messaggio e lasciare che Dispatch decida come eseguirlo. Richiede un piano Pro, Max o Ultra. |

43 43 

44Se il tuo computer sarà spento, usa le sessioni cloud o un progetto, che vengono eseguiti nel cloud e continuano con il tuo laptop chiuso. Remote Control e Dispatch guidano la tua macchina, quindi deve rimanere accesa con Claude Code o l'app Desktop in esecuzione. Se la tua macchina va in sospensione durante una sessione Remote Control, Claude Code si riconnette quando la macchina torna online.44Se il tuo computer sarà spento, usa le sessioni cloud o un progetto, che vengono eseguiti nel cloud e continuano con il tuo laptop chiuso. Remote Control e Dispatch guidano la tua macchina, quindi deve rimanere accesa con Claude Code o l'app Desktop in esecuzione. Se la tua macchina va in sospensione durante una sessione Remote Control, Claude Code si riconnette quando la macchina torna online.

45 45 

76 76 

77* **Comandi solo locali**: comandi che vengono eseguiti solo nell'interfaccia del terminale, come `/plugin` e `/resume`, non funzionano dall'app. Le [limitazioni di Remote Control](https://code.claude.com/docs/it/remote-control.md#limitations) elencano i comandi che funzionano da mobile e come il loro comportamento differisce.77* **Comandi solo locali**: comandi che vengono eseguiti solo nell'interfaccia del terminale, come `/plugin` e `/resume`, non funzionano dall'app. Le [limitazioni di Remote Control](https://code.claude.com/docs/it/remote-control.md#limitations) elencano i comandi che funzionano da mobile e come il loro comportamento differisce.

78* **Modalità di permesso**: le sessioni cloud offrono Accept edits, Plan e Auto, e le sessioni Remote Control offrono Manual, Accept edits, Plan e Auto. Non puoi selezionare Bypass permissions dall'app in nessuno dei due casi. Consulta [cambiare modalità di permesso](https://code.claude.com/docs/it/permission-modes.md#switch-permission-modes) per sapere quando Auto è disponibile.78* **Modalità di permesso**: le sessioni cloud offrono Accept edits, Plan e Auto, e le sessioni Remote Control offrono Manual, Accept edits, Plan e Auto. Non puoi selezionare Bypass permissions dall'app in nessuno dei due casi. Consulta [cambiare modalità di permesso](https://code.claude.com/docs/it/permission-modes.md#switch-permission-modes) per sapere quando Auto è disponibile.

79* **Piani Dispatch**: Dispatch richiede un piano Pro o Max e non è disponibile su Team o Enterprise.79* **Piani Dispatch**: Dispatch richiede un piano Pro, Max o Ultra e non è disponibile su Team o Enterprise.

80 80 

81## Risorse correlate81## Risorse correlate

82 82 

model-config.md +4 −4

Details

455 455 

456Il comportamento di `default` dipende dal tipo di account:456Il comportamento di `default` dipende dal tipo di account:

457 457 

458* **Pro, Max, Team, Enterprise e Anthropic API**: predefinito su Opus 5.5458* **Pro, Max, Ultra, Team, Enterprise e Anthropic API**: predefinito su Opus 5.5

459* **Claude Platform su AWS, Amazon Bedrock e Google Cloud's Agent Platform**: predefinito su Opus 5.5459* **Claude Platform su AWS, Amazon Bedrock e Google Cloud's Agent Platform**: predefinito su Opus 5.5

460* **Microsoft Foundry**: predefinito su Sonnet 4.5460* **Microsoft Foundry**: predefinito su Sonnet 4.5

461 461 

462Prima della v2.1.280, `default` si risolveva in Sonnet 5 su Pro e Team Standard, e in Opus 5 su Max, Team Premium, Enterprise, Anthropic API, Claude Platform su AWS, Amazon Bedrock e Google Cloud's Agent Platform da v2.1.219. Prima della v2.1.219, `default` si risolveva in Opus 4.8 su Anthropic API, Max, Team Premium e Enterprise con pagamento a consumo da v2.1.154, e su Claude Platform su AWS, Amazon Bedrock e Google Cloud's Agent Platform da v2.1.207. Prima della v2.1.207, `default` si risolveva in Opus 4.7 su Claude Platform su AWS e in Sonnet 4.5 su Amazon Bedrock e Google Cloud's Agent Platform.462Prima della v2.1.280, `default` si risolveva in Sonnet 5 su Pro e Team Standard, e in Opus 5 su Max, Ultra, Team Premium, Enterprise, Anthropic API, Claude Platform su AWS, Amazon Bedrock e Google Cloud's Agent Platform da v2.1.219. Prima della v2.1.219, `default` si risolveva in Opus 4.8 su Anthropic API, Max, Ultra, Team Premium e Enterprise con pagamento a consumo da v2.1.154, e su Claude Platform su AWS, Amazon Bedrock e Google Cloud's Agent Platform da v2.1.207. Prima della v2.1.207, `default` si risolveva in Opus 4.7 su Claude Platform su AWS e in Sonnet 4.5 su Amazon Bedrock e Google Cloud's Agent Platform.

463 463 

464Quando un amministratore ha impostato un [modello predefinito dell'organizzazione](#organization-default-model), `default` si risolve in quel modello invece del valore predefinito del tipo di account sopra indicato. Richiede Claude Code v2.1.196 o successiva. `default` può anche risolversi nel modello impostato con [`ANTHROPIC_DEFAULT_MODEL`](#set-a-default-model-for-new-sessions), secondo le condizioni elencate nella relativa sezione, o nel modello [registrato sul tuo account](#setting-your-model).464Quando un amministratore ha impostato un [modello predefinito dell'organizzazione](#organization-default-model), `default` si risolve in quel modello invece del valore predefinito del tipo di account sopra indicato. Richiede Claude Code v2.1.196 o successiva. `default` può anche risolversi nel modello impostato con [`ANTHROPIC_DEFAULT_MODEL`](#set-a-default-model-for-new-sessions), secondo le condizioni elencate nella relativa sezione, o nel modello [registrato sul tuo account](#setting-your-model).

465 465 

758 758 

759Fable 5.1, Fable 5, Sonnet 5 e successivi, Haiku 5.5, e Opus 4.7 e successivi vengono eseguiti con la finestra 1M per impostazione predefinita, senza bisogno del suffisso `[1m]`. Ciò include le sessioni su Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry, e le sessioni tramite [Claude apps gateway](https://code.claude.com/docs/it/claude-apps-gateway). Per eseguirli invece con una finestra di 200K, consulta [Disattiva il contesto 1M](#turn-off-1m-context).759Fable 5.1, Fable 5, Sonnet 5 e successivi, Haiku 5.5, e Opus 4.7 e successivi vengono eseguiti con la finestra 1M per impostazione predefinita, senza bisogno del suffisso `[1m]`. Ciò include le sessioni su Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry, e le sessioni tramite [Claude apps gateway](https://code.claude.com/docs/it/claude-apps-gateway). Per eseguirli invece con una finestra di 200K, consulta [Disattiva il contesto 1M](#turn-off-1m-context).

760 760 

761Opus 4.6 e Sonnet 4.6 raggiungono 1M solo attraverso la loro variante `[1m]`, e l'accesso a quella variante dipende dal tuo piano. Sui piani Max, Team ed Enterprise, inclusi sia i posti Team Standard che Team Premium, Opus 4.6 con contesto 1M è incluso nel tuo abbonamento. Sonnet 4.6 con contesto 1M richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) su ogni piano di abbonamento, incluso Max.761Opus 4.6 e Sonnet 4.6 raggiungono 1M solo attraverso la loro variante `[1m]`, e l'accesso a quella variante dipende dal tuo piano. Sui piani Max, Ultra, Team ed Enterprise, inclusi sia i posti Team Standard che Team Premium, Opus 4.6 con contesto 1M è incluso nel tuo abbonamento. Sonnet 4.6 con contesto 1M richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) su ogni piano di abbonamento, inclusi Max e Ultra.

762 762 

763| Piano | Opus 4.6 con contesto 1M | Sonnet 4.6 con contesto 1M |763| Piano | Opus 4.6 con contesto 1M | Sonnet 4.6 con contesto 1M |

764| - | - | - |764| - | - | - |

765| Max, Team e Enterprise | Incluso nell'abbonamento | Richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) |765| Max, Ultra, Team e Enterprise | Incluso nell'abbonamento | Richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) |

766| Pro | Richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) | Richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) |766| Pro | Richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) | Richiede [crediti di utilizzo](https://support.claude.com/en/articles/12429409-extra-usage-for-paid-claude-plans) |

767| API e pagamento a consumo | Accesso completo | Accesso completo |767| API e pagamento a consumo | Accesso completo | Accesso completo |

768 768 

overview.md +119 −119

Details

12 12 

13Claude Code funziona su diverse superfici: il terminale, le estensioni IDE, un'app desktop e il web. Scegli una dalle schede sottostanti per iniziare. La maggior parte delle superfici richiede un [abbonamento a Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) o un account [Anthropic Console](https://platform.claude.com/). Il Terminal CLI, VS Code e JetBrains supportano anche [provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md).13Claude Code funziona su diverse superfici: il terminale, le estensioni IDE, un'app desktop e il web. Scegli una dalle schede sottostanti per iniziare. La maggior parte delle superfici richiede un [abbonamento a Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) o un account [Anthropic Console](https://platform.claude.com/). Il Terminal CLI, VS Code e JetBrains supportano anche [provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md).

14 14 

15**Terminal**15> [tab] Terminal

16 16>

17Il CLI completo per lavorare con Claude Code direttamente nel tuo terminale. Modifica file, esegui comandi e gestisci l'intero progetto dalla riga di comando.17> Il CLI completo per lavorare con Claude Code direttamente nel tuo terminale. Modifica file, esegui comandi e gestisci l'intero progetto dalla riga di comando.

18 18>

19Per installare Claude Code, apri un terminale ed esegui il comando per il tuo sistema. Se non hai mai utilizzato un terminale prima, la [guida al terminale](https://code.claude.com/docs/it/terminal-guide) mostra come aprirne uno e incollare il comando.19> Per installare Claude Code, apri un terminale ed esegui il comando per il tuo sistema. Se non hai mai utilizzato un terminale prima, la [guida al terminale](https://code.claude.com/docs/it/terminal-guide) mostra come aprirne uno e incollare il comando.

20 20>

21**Installazione nativa (consigliata)**21> > [tab] Installazione nativa (consigliata)

22 22> >

23**macOS, Linux, WSL:**23> > **macOS, Linux, WSL:**

24 24> >

25```bash theme={null}25> > ```bash theme={null}

26curl -fsSL https://claude.ai/install.sh | bash26> > curl -fsSL https://claude.ai/install.sh | bash

27```27> > ```

28 28> >

29Su Windows, il tuo prompt mostra `PS C:\` quando sei in PowerShell e `C:\` senza il `PS` quando sei in CMD.29> > Su Windows, il tuo prompt mostra `PS C:\` quando sei in PowerShell e `C:\` senza il `PS` quando sei in CMD.

30 30> >

31**Windows PowerShell:**31> > **Windows PowerShell:**

32 32> >

33```powershell theme={null}33> > ```powershell theme={null}

34irm https://claude.ai/install.ps1 | iex34> > irm https://claude.ai/install.ps1 | iex

35```35> > ```

36 36> >

37**Windows CMD:**37> > **Windows CMD:**

38 38> >

39```batch theme={null}39> > ```batch theme={null}

40curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd40> > curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

41```41> > ```

42 42> >

43Il comando di installazione non mostra alcun avanzamento mentre scarica Claude Code. Quando il programma di installazione termina, apri una nuova finestra del terminale ed esegui `claude --version`. Un'installazione funzionante stampa un numero di versione. Se la tua shell dice che `claude` non è trovato o non è riconosciuto, la directory di installazione non è ancora nel tuo PATH: vedi [Correggi il tuo PATH](https://code.claude.com/docs/it/troubleshoot-install.md#command-not-found-claude-after-installation).43> > Il comando di installazione non mostra alcun avanzamento mentre scarica Claude Code. Quando il programma di installazione termina, apri una nuova finestra del terminale ed esegui `claude --version`. Un'installazione funzionante stampa un numero di versione. Se la tua shell dice che `claude` non è trovato o non è riconosciuto, la directory di installazione non è ancora nel tuo PATH: vedi [Correggi il tuo PATH](https://code.claude.com/docs/it/troubleshoot-install.md#command-not-found-claude-after-installation).

44 44> >

45Se vedi `The token '&&' is not a valid statement separator`, sei in PowerShell, non in CMD. Se vedi `'irm' is not recognized as an internal or external command`, sei in CMD, non in PowerShell.45> > Se vedi `The token '&&' is not a valid statement separator`, sei in PowerShell, non in CMD. Se vedi `'irm' is not recognized as an internal or external command`, sei in CMD, non in PowerShell.

46 46> >

47Se il comando di installazione non riesce con `syntax error near unexpected token '<'`, un `403` o qualsiasi altro errore, consulta [Risoluzione dei problemi di installazione](https://code.claude.com/docs/it/troubleshoot-install.md#find-your-error) per abbinare l'errore a una soluzione e per metodi di installazione alternativi.47> > Se il comando di installazione non riesce con `syntax error near unexpected token '<'`, un `403` o qualsiasi altro errore, consulta [Risoluzione dei problemi di installazione](https://code.claude.com/docs/it/troubleshoot-install.md#find-your-error) per abbinare l'errore a una soluzione e per metodi di installazione alternativi.

48 48> >

49[Git for Windows](https://git-scm.com/downloads/win) è consigliato su Windows nativo in modo che Claude Code possa utilizzare lo strumento Bash. Se Git for Windows non è installato, Claude Code utilizza PowerShell come strumento shell. Le configurazioni WSL non necessitano di Git for Windows.49> > [Git for Windows](https://git-scm.com/downloads/win) è consigliato su Windows nativo in modo che Claude Code possa utilizzare lo strumento Bash. Se Git for Windows non è installato, Claude Code utilizza PowerShell come strumento shell. Le configurazioni WSL non necessitano di Git for Windows.

50 50> >

51> [!NOTE]51> > > [!NOTE]

52> > >

53> > > Le installazioni native si aggiornano automaticamente in background per mantenerti sulla versione più recente.

54>

55> > [tab] Homebrew

56> >

57> > ```bash theme={null}

58> > brew install --cask claude-code

59> > ```

60> >

61> > Homebrew offre due cask. `claude-code` traccia il canale di rilascio stabile, che in genere è circa una settimana indietro e salta i rilasci con regressioni importanti. `claude-code@latest` traccia il canale più recente e riceve nuove versioni non appena vengono rilasciate.

62> >

63> > > [!NOTE]

64> > >

65> > > Le installazioni Homebrew non si aggiornano automaticamente. Esegui `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask hai installato, per ottenere le funzionalità più recenti e le correzioni di sicurezza.

66>

67> > [tab] WinGet

68> >

69> > ```powershell theme={null}

70> > winget install Anthropic.ClaudeCode

71> > ```

72> >

73> > > [!NOTE]

74> > >

75> > > Le installazioni WinGet non si aggiornano automaticamente. Esegui `winget upgrade Anthropic.ClaudeCode` periodicamente per ottenere le funzionalità più recenti e le correzioni di sicurezza.

76>

77> Puoi anche installare con [apt, dnf, o apk](https://code.claude.com/docs/it/setup.md#install-with-linux-package-managers) su Debian, Fedora, RHEL e Alpine.

78>

79> Quindi avvia Claude Code in qualsiasi progetto. Sostituisci `your-project` con il percorso di una directory di progetto sulla tua macchina:

52>80>

53> Le installazioni native si aggiornano automaticamente in background per mantenerti sulla versione più recente.81> ```bash theme={null}

54 82> cd your-project

55**Homebrew**83> claude

56 84> ```

57```bash theme={null}

58brew install --cask claude-code

59```

60 

61Homebrew offre due cask. `claude-code` traccia il canale di rilascio stabile, che in genere è circa una settimana indietro e salta i rilasci con regressioni importanti. `claude-code@latest` traccia il canale più recente e riceve nuove versioni non appena vengono rilasciate.

62 

63> [!NOTE]

64>85>

65> Le installazioni Homebrew non si aggiornano automaticamente. Esegui `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask hai installato, per ottenere le funzionalità più recenti e le correzioni di sicurezza.86> Claude Code ti chiede di accedere al primo utilizzo. Se hai impostato la variabile d'ambiente `ANTHROPIC_API_KEY` e approvi la chiave quando Claude Code ti chiede se usarla, Claude Code salta il prompt di accesso. [Continua con la Guida rapida →](https://code.claude.com/docs/it/quickstart.md)

66 

67**WinGet**

68 

69```powershell theme={null}

70winget install Anthropic.ClaudeCode

71```

72 

73> [!NOTE]

74>87>

75> Le installazioni WinGet non si aggiornano automaticamente. Esegui `winget upgrade Anthropic.ClaudeCode` periodicamente per ottenere le funzionalità più recenti e le correzioni di sicurezza.88> > [!TIP]

76 89> >

77Puoi anche installare con [apt, dnf, o apk](https://code.claude.com/docs/it/setup.md#install-with-linux-package-managers) su Debian, Fedora, RHEL e Alpine.90> > Vedi [configurazione avanzata](https://code.claude.com/docs/it/setup.md) per le opzioni di installazione, gli aggiornamenti manuali o le istruzioni di disinstallazione. Visita [risoluzione dei problemi di installazione](https://code.claude.com/docs/it/troubleshoot-install.md) se riscontri problemi.

78 

79Quindi avvia Claude Code in qualsiasi progetto. Sostituisci `your-project` con il percorso di una directory di progetto sulla tua macchina:

80 91 

81```bash theme={null}92> [tab] VS Code

82cd your-project

83claude

84```

85 

86Claude Code ti chiede di accedere al primo utilizzo. Se hai impostato la variabile d'ambiente `ANTHROPIC_API_KEY` e approvi la chiave quando Claude Code ti chiede se usarla, Claude Code salta il prompt di accesso. [Continua con la Guida rapida →](https://code.claude.com/docs/it/quickstart.md)

87 

88> [!TIP]

89>93>

90> Vedi [configurazione avanzata](https://code.claude.com/docs/it/setup.md) per le opzioni di installazione, gli aggiornamenti manuali o le istruzioni di disinstallazione. Visita [risoluzione dei problemi di installazione](https://code.claude.com/docs/it/troubleshoot-install.md) se riscontri problemi.94> L'estensione VS Code fornisce diff inline, @-mentions, revisione del piano e cronologia delle conversazioni direttamente nel tuo editor.

91 95>

92**VS Code**96> * [Installa per VS Code](vscode:extension/anthropic.claude-code)

93 97> * [Installa per Cursor](cursor:extension/anthropic.claude-code)

94L'estensione VS Code fornisce diff inline, @-mentions, revisione del piano e cronologia delle conversazioni direttamente nel tuo editor.98>

95 99> Oppure cerca "Claude Code" nella visualizzazione Estensioni (`Cmd+Shift+X` su Mac, `Ctrl+Shift+X` su Windows/Linux). Dopo l'installazione, apri il Palette dei comandi (`Cmd+Shift+P` / `Ctrl+Shift+P`), digita "Claude Code" e seleziona **Apri in Nuova Scheda**.

96* [Installa per VS Code](vscode:extension/anthropic.claude-code)100>

97* [Installa per Cursor](cursor:extension/anthropic.claude-code)101> [Inizia con VS Code →](https://code.claude.com/docs/it/vs-code.md#get-started)

98 

99Oppure cerca "Claude Code" nella visualizzazione Estensioni (`Cmd+Shift+X` su Mac, `Ctrl+Shift+X` su Windows/Linux). Dopo l'installazione, apri il Palette dei comandi (`Cmd+Shift+P` / `Ctrl+Shift+P`), digita "Claude Code" e seleziona **Apri in Nuova Scheda**.

100 

101[Inizia con VS Code →](https://code.claude.com/docs/it/vs-code.md#get-started)

102 

103**App desktop**

104 

105Un'app standalone per eseguire Claude Code al di fuori del tuo IDE o terminale. Rivedi i diff visivamente, esegui più sessioni affiancate, pianifica attività ricorrenti e avvia sessioni cloud.

106 

107Scarica e installa:

108 

109* [macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect?utm_source=claude_code\&utm_medium=docs) (Intel e Apple Silicon)

110* [Windows](https://claude.ai/api/desktop/win32/x64/setup/latest/redirect?utm_source=claude_code\&utm_medium=docs) (x64)

111* [Windows ARM64](https://claude.ai/api/desktop/win32/arm64/setup/latest/redirect?utm_source=claude_code\&utm_medium=docs)

112* Su Ubuntu o Debian, dove l'app è in beta, installala con apt seguendo le [istruzioni di installazione per Linux](https://code.claude.com/docs/it/desktop-linux.md)

113 

114Dopo l'installazione, avvia Claude, accedi e fai clic sulla scheda **Code** per iniziare a codificare. L'app include Claude Code, quindi non è necessario installare il CLI separatamente. È richiesto un [abbonamento a pagamento](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_desktop_pricing).

115 

116[Scopri di più sull'app desktop →](https://code.claude.com/docs/it/desktop-quickstart.md)

117 

118**Web**

119 

120Esegui Claude Code nel tuo browser senza configurazione locale. Avvia attività a lunga esecuzione e controlla quando sono completate, lavora su repository che non hai localmente o esegui più attività in parallelo. Per un corpo di lavoro più lungo, crea un [progetto](https://code.claude.com/docs/it/claude-projects.md) e lascia che Claude coordini le sessioni parallele per te. Disponibile su browser desktop e [l'app Claude per iOS e Android](https://code.claude.com/docs/it/mobile.md).

121 

122Inizia a codificare su [claude.ai/code](https://claude.ai/code).

123 

124[Inizia →](https://code.claude.com/docs/it/web-quickstart.md)

125 

126**JetBrains**

127 102 

128Un plugin per IntelliJ IDEA, PyCharm, WebStorm e altri IDE JetBrains con visualizzazione diff interattiva e condivisione del contesto di selezione.103> [tab] App desktop

104>

105> Un'app standalone per eseguire Claude Code al di fuori del tuo IDE o terminale. Rivedi i diff visivamente, esegui più sessioni affiancate, pianifica attività ricorrenti e avvia sessioni cloud.

106>

107> Scarica e installa:

108>

109> * [macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect?utm_source=claude_code\&utm_medium=docs) (Intel e Apple Silicon)

110> * [Windows](https://claude.ai/api/desktop/win32/x64/setup/latest/redirect?utm_source=claude_code\&utm_medium=docs) (x64)

111> * [Windows ARM64](https://claude.ai/api/desktop/win32/arm64/setup/latest/redirect?utm_source=claude_code\&utm_medium=docs)

112> * Su Ubuntu o Debian, dove l'app è in beta, installala con apt seguendo le [istruzioni di installazione per Linux](https://code.claude.com/docs/it/desktop-linux.md)

113>

114> Dopo l'installazione, avvia Claude, accedi e fai clic sulla scheda **Code** per iniziare a codificare. L'app include Claude Code, quindi non è necessario installare il CLI separatamente. È richiesto un [abbonamento a pagamento](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_desktop_pricing).

115>

116> [Scopri di più sull'app desktop →](https://code.claude.com/docs/it/desktop-quickstart.md)

129 117 

130Installa il [plugin Claude Code](https://plugins.jetbrains.com/plugin/27310-claude-code-beta-) dal JetBrains Marketplace e riavvia il tuo IDE. Il plugin richiede il CLI Claude Code, installato separatamente; vedi i [passaggi di configurazione JetBrains](https://code.claude.com/docs/it/jetbrains.md#installation).118> [tab] Web

119>

120> Esegui Claude Code nel tuo browser senza configurazione locale. Avvia attività a lunga esecuzione e controlla quando sono completate, lavora su repository che non hai localmente o esegui più attività in parallelo. Per un corpo di lavoro più lungo, crea un [progetto](https://code.claude.com/docs/it/claude-projects.md) e lascia che Claude coordini le sessioni parallele per te. Disponibile su browser desktop e [l'app Claude per iOS e Android](https://code.claude.com/docs/it/mobile.md).

121>

122> Inizia a codificare su [claude.ai/code](https://claude.ai/code).

123>

124> [Inizia →](https://code.claude.com/docs/it/web-quickstart.md)

131 125 

132[Inizia con JetBrains →](https://code.claude.com/docs/it/jetbrains.md)126> [tab] JetBrains

127>

128> Un plugin per IntelliJ IDEA, PyCharm, WebStorm e altri IDE JetBrains con visualizzazione diff interattiva e condivisione del contesto di selezione.

129>

130> Installa il [plugin Claude Code](https://plugins.jetbrains.com/plugin/27310-claude-code-beta-) dal JetBrains Marketplace e riavvia il tuo IDE. Il plugin richiede il CLI Claude Code, installato separatamente; vedi i [passaggi di configurazione JetBrains](https://code.claude.com/docs/it/jetbrains.md#installation).

131>

132> [Inizia con JetBrains →](https://code.claude.com/docs/it/jetbrains.md)

133 133 

134## Cosa puoi fare134## Cosa puoi fare

135 135 

136Ecco alcuni dei modi in cui puoi utilizzare Claude Code:136Ecco alcuni dei modi in cui puoi utilizzare Claude Code:

137 137 

138> **Automatizza il lavoro che continui a rimandare**138> [accordion] Automatizza il lavoro che continui a rimandare

139>139>

140> Claude Code gestisce i compiti noiosi che consumano la tua giornata: scrivere test per il codice non testato, correggere errori di lint in un progetto, risolvere conflitti di merge, aggiornare dipendenze e scrivere note di rilascio.140> Claude Code gestisce i compiti noiosi che consumano la tua giornata: scrivere test per il codice non testato, correggere errori di lint in un progetto, risolvere conflitti di merge, aggiornare dipendenze e scrivere note di rilascio.

141>141>

143> claude "write tests for the auth module, run them, and fix any failures"143> claude "write tests for the auth module, run them, and fix any failures"

144> ```144> ```

145 145 

146> **Crea funzionalità e correggi bug**146> [accordion] Crea funzionalità e correggi bug

147>147>

148> Descrivi quello che vuoi in linguaggio naturale. Claude Code pianifica l'approccio, scrive il codice su più file e verifica che funzioni.148> Descrivi quello che vuoi in linguaggio naturale. Claude Code pianifica l'approccio, scrive il codice su più file e verifica che funzioni.

149>149>

150> Per i bug, incolla un messaggio di errore o descrivi il sintomo. Claude Code traccia il problema attraverso la tua base di codice, identifica la causa principale e implementa una correzione. Vedi [flussi di lavoro comuni](https://code.claude.com/docs/it/common-workflows.md) per altri esempi.150> Per i bug, incolla un messaggio di errore o descrivi il sintomo. Claude Code traccia il problema attraverso la tua base di codice, identifica la causa principale e implementa una correzione. Vedi [flussi di lavoro comuni](https://code.claude.com/docs/it/common-workflows.md) per altri esempi.

151 151 

152> **Crea commit e pull request**152> [accordion] Crea commit e pull request

153>153>

154> Claude Code funziona direttamente con git. Mette in stage le modifiche, scrive messaggi di commit, crea branch e apre pull request.154> Claude Code funziona direttamente con git. Mette in stage le modifiche, scrive messaggi di commit, crea branch e apre pull request.

155>155>

159>159>

160> In CI, puoi automatizzare la revisione del codice e il triage dei problemi con [GitHub Actions](https://code.claude.com/docs/it/github-actions.md) o [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md).160> In CI, puoi automatizzare la revisione del codice e il triage dei problemi con [GitHub Actions](https://code.claude.com/docs/it/github-actions.md) o [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md).

161 161 

162> **Connetti i tuoi strumenti con MCP**162> [accordion] Connetti i tuoi strumenti con MCP

163>163>

164> Il [Model Context Protocol (MCP)](https://code.claude.com/docs/it/mcp.md) è uno standard aperto per connettere gli strumenti di IA alle fonti di dati esterne. Con MCP, Claude Code può leggere i tuoi documenti di progettazione in Google Drive, aggiornare i ticket in Jira, estrarre dati da Slack o utilizzare i tuoi strumenti personalizzati. La [guida rapida MCP](https://code.claude.com/docs/it/mcp-quickstart.md) connette il tuo primo server da capo a fondo.164> Il [Model Context Protocol (MCP)](https://code.claude.com/docs/it/mcp.md) è uno standard aperto per connettere gli strumenti di IA alle fonti di dati esterne. Con MCP, Claude Code può leggere i tuoi documenti di progettazione in Google Drive, aggiornare i ticket in Jira, estrarre dati da Slack o utilizzare i tuoi strumenti personalizzati. La [guida rapida MCP](https://code.claude.com/docs/it/mcp-quickstart.md) connette il tuo primo server da capo a fondo.

165 165 

166> **Personalizza con istruzioni, skill e hook**166> [accordion] Personalizza con istruzioni, skill e hook

167>167>

168> [`CLAUDE.md`](https://code.claude.com/docs/it/memory) è un file markdown che aggiungi alla radice del tuo progetto che Claude Code legge all'inizio di ogni sessione. Usalo per impostare standard di codifica, decisioni architettoniche, librerie preferite e checklist di revisione. Se il tuo repository ha già un `AGENTS.md` per altri agenti di codifica, Claude Code [può leggerlo](https://code.claude.com/docs/it/memory.md#agents-md) al posto di un `CLAUDE.md`. Claude costruisce anche [memoria automatica](https://code.claude.com/docs/it/memory.md#auto-memory) mentre lavora, salvando insegnamenti tra le sessioni senza che tu debba scrivere nulla.168> [`CLAUDE.md`](https://code.claude.com/docs/it/memory) è un file markdown che aggiungi alla radice del tuo progetto che Claude Code legge all'inizio di ogni sessione. Usalo per impostare standard di codifica, decisioni architettoniche, librerie preferite e checklist di revisione. Se il tuo repository ha già un `AGENTS.md` per altri agenti di codifica, Claude Code [può leggerlo](https://code.claude.com/docs/it/memory.md#agents-md) al posto di un `CLAUDE.md`. Claude costruisce anche [memoria automatica](https://code.claude.com/docs/it/memory.md#auto-memory) mentre lavora, salvando insegnamenti tra le sessioni senza che tu debba scrivere nulla.

169>169>

171>171>

172> [Hooks](https://code.claude.com/docs/it/hooks.md) ti permettono di eseguire comandi shell prima o dopo le azioni di Claude Code, come la formattazione automatica dopo ogni modifica di file o l'esecuzione di lint prima di un commit.172> [Hooks](https://code.claude.com/docs/it/hooks.md) ti permettono di eseguire comandi shell prima o dopo le azioni di Claude Code, come la formattazione automatica dopo ogni modifica di file o l'esecuzione di lint prima di un commit.

173 173 

174> **Esegui agenti in parallelo e crea agenti personalizzati**174> [accordion] Esegui agenti in parallelo e crea agenti personalizzati

175>175>

176> Genera [più agenti Claude Code](https://code.claude.com/docs/it/sub-agents.md) che lavorano su diverse parti di un'attività contemporaneamente. Un agente principale coordina il lavoro, assegna sottoattività e unisce i risultati.176> Genera [più agenti Claude Code](https://code.claude.com/docs/it/sub-agents.md) che lavorano su diverse parti di un'attività contemporaneamente. Un agente principale coordina il lavoro, assegna sottoattività e unisce i risultati.

177>177>

178> Per eseguire diverse sessioni complete in parallelo e osservarle da una sola schermata, utilizza [agenti in background](https://code.claude.com/docs/it/agent-view.md). Per flussi di lavoro completamente personalizzati, l'[Agent SDK](https://code.claude.com/docs/it/agent-sdk/overview.md) ti permette di creare i tuoi agenti alimentati dagli strumenti e dalle capacità di Claude Code, con controllo completo sull'orchestrazione, l'accesso agli strumenti e i permessi.178> Per eseguire diverse sessioni complete in parallelo e osservarle da una sola schermata, utilizza [agenti in background](https://code.claude.com/docs/it/agent-view.md). Per flussi di lavoro completamente personalizzati, l'[Agent SDK](https://code.claude.com/docs/it/agent-sdk/overview.md) ti permette di creare i tuoi agenti alimentati dagli strumenti e dalle capacità di Claude Code, con controllo completo sull'orchestrazione, l'accesso agli strumenti e i permessi.

179 179 

180> **Pipe, script e automatizza con il CLI**180> [accordion] Pipe, script e automatizza con il CLI

181>181>

182> Claude Code è componibile e segue la filosofia Unix. Pipe i log in esso, eseguilo in CI o concatenalo con altri strumenti:182> Claude Code è componibile e segue la filosofia Unix. Pipe i log in esso, eseguilo in CI o concatenalo con altri strumenti:

183>183>

194>194>

195> Vedi il [riferimento CLI](https://code.claude.com/docs/it/cli-reference.md) per l'insieme completo di comandi e flag.195> Vedi il [riferimento CLI](https://code.claude.com/docs/it/cli-reference.md) per l'insieme completo di comandi e flag.

196 196 

197> **Pianifica attività ricorrenti**197> [accordion] Pianifica attività ricorrenti

198>198>

199> Esegui Claude su una pianificazione per automatizzare il lavoro che si ripete: revisioni PR mattutine, analisi dei fallimenti CI durante la notte, audit delle dipendenze settimanali o sincronizzazione dei documenti dopo l'unione dei PR.199> Esegui Claude su una pianificazione per automatizzare il lavoro che si ripete: revisioni PR mattutine, analisi dei fallimenti CI durante la notte, audit delle dipendenze settimanali o sincronizzazione dei documenti dopo l'unione dei PR.

200>200>

202> * [Attività pianificate desktop](https://code.claude.com/docs/it/desktop-scheduled-tasks.md) vengono eseguite sulla tua macchina, con accesso diretto ai tuoi file e strumenti locali202> * [Attività pianificate desktop](https://code.claude.com/docs/it/desktop-scheduled-tasks.md) vengono eseguite sulla tua macchina, con accesso diretto ai tuoi file e strumenti locali

203> * [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) ripete un prompt all'interno di una sessione CLI per il polling rapido203> * [`/loop`](https://code.claude.com/docs/it/scheduled-tasks) ripete un prompt all'interno di una sessione CLI per il polling rapido

204 204 

205> **Lavora da qualsiasi luogo**205> [accordion] Lavora da qualsiasi luogo

206>206>

207> Le sessioni non sono legate a una singola superficie. Sposta il lavoro tra gli ambienti mentre il tuo contesto cambia:207> Le sessioni non sono legate a una singola superficie. Sposta il lavoro tra gli ambienti mentre il tuo contesto cambia:

208>208>

permission-modes.md +140 −135

Details

8 8 

9Una modalità di autorizzazione imposta quali azioni Claude può intraprendere in una sessione senza chiederti prima. In modalità manuale, Claude Code si ferma e ti chiede prima della maggior parte delle azioni che modificano file, eseguono comandi shell o raggiungono la rete. In [auto mode](#eliminate-prompts-with-auto-mode), un secondo modello, il classificatore, esamina le azioni al tuo posto; [come il classificatore valuta le azioni](#how-the-classifier-evaluates-actions) elenca quali azioni esamina e quali le salta.9Una modalità di autorizzazione imposta quali azioni Claude può intraprendere in una sessione senza chiederti prima. In modalità manuale, Claude Code si ferma e ti chiede prima della maggior parte delle azioni che modificano file, eseguono comandi shell o raggiungono la rete. In [auto mode](#eliminate-prompts-with-auto-mode), un secondo modello, il classificatore, esamina le azioni al tuo posto; [come il classificatore valuta le azioni](#how-the-classifier-evaluates-actions) elenca quali azioni esamina e quali le salta.

10 10 

11Con Claude Code v2.1.283 o successivo, la modalità auto è la modalità di autorizzazione predefinita integrata per le sessioni di terminale interattivo e VS Code. Nelle versioni precedenti, è la modalità di autorizzazione predefinita integrata solo nei piani Pro, Max e Team. [In quale modalità inizia una sessione](#which-mode-a-session-starts-in) copre le superfici e le impostazioni che cambiano la modalità di autorizzazione iniziale. Puoi anche cambiare la modalità di autorizzazione di una sessione in esecuzione in qualsiasi momento.11Con Claude Code v2.1.283 o successivo, la modalità auto è la modalità di permesso iniziale integrata per le sessioni di terminale interattivo e VS Code. Nelle versioni precedenti, è la modalità di permesso iniziale integrata solo nei piani Pro, Max, Ultra e Team. [In quale modalità inizia una sessione](#which-mode-a-session-starts-in) copre le superfici e le impostazioni che cambiano la modalità di permesso iniziale. Puoi anche cambiare la modalità di permesso di una sessione in esecuzione in qualsiasi momento.

12 12 

13## Modalità disponibili13## Modalità disponibili

14 14 

80| Un file di impostazioni imposta `disableAutoMode` su `"disable"` | `default` |80| Un file di impostazioni imposta `disableAutoMode` su `"disable"` | `default` |

81| `claude -p` o l'[Agent SDK](https://code.claude.com/docs/it/agent-sdk/permissions.md#permission-modes) | `default` |81| `claude -p` o l'[Agent SDK](https://code.claude.com/docs/it/agent-sdk/permissions.md#permission-modes) | `default` |

82| La tua organizzazione ha applicato la [configurazione HIPAA](#hipaa-configuration) e la sessione è [idonea](https://code.claude.com/docs/it/hipaa-setup.md#check-how-developers-sign-in-and-connect) | `default` con Claude Code v2.1.285 o successivo; la modalità auto rimane disponibile per passarvi |82| La tua organizzazione ha applicato la [configurazione HIPAA](#hipaa-configuration) e la sessione è [idonea](https://code.claude.com/docs/it/hipaa-setup.md#check-how-developers-sign-in-and-connect) | `default` con Claude Code v2.1.285 o successivo; la modalità auto rimane disponibile per passarvi |

83| In un terminale o tramite l'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md) | `auto` con Claude Code v2.1.283 o successivo; su versioni precedenti, `auto` su piani Pro, Max, o Team in sessioni che [recuperano flag di funzionalità](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), e `default` altrimenti |83| In un terminale o tramite l'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md) | `auto` con Claude Code v2.1.283 o successivo; su versioni precedenti, `auto` su piani Pro, Max, Ultra o Team in sessioni che [recuperano flag di funzionalità](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), e `default` altrimenti |

84 84 

85Quando il flag, un file di impostazioni, o l'impostazione predefinita integrata seleziona `auto` ma la modalità auto non è disponibile per la sessione, Claude Code avvia la sessione in Manual invece. La modalità auto non è disponibile quando la sessione non soddisfa i [requisiti di disponibilità](#eliminate-prompts-with-auto-mode), come un file di impostazioni che la disattiva o un modello che non la supporta, o quando Anthropic l'ha temporaneamente disattivata lato server.85Quando il flag, un file di impostazioni, o l'impostazione predefinita integrata seleziona `auto` ma la modalità auto non è disponibile per la sessione, Claude Code avvia la sessione in Manual invece. La modalità auto non è disponibile quando la sessione non soddisfa i [requisiti di disponibilità](#eliminate-prompts-with-auto-mode), come un file di impostazioni che la disattiva o un modello che non la supporta, o quando Anthropic l'ha temporaneamente disattivata lato server.

86 86 

89* In un terminale, una volta, in cima alla sessione89* In un terminale, una volta, in cima alla sessione

90* Nell'estensione VS Code, come una scheda nella schermata di nuova conversazione che rimane finché non la chiudi90* Nell'estensione VS Code, come una scheda nella schermata di nuova conversazione che rimane finché non la chiudi

91 91 

92Se il tuo `~/.claude/settings.json` imposta un `defaultMode` diverso da `auto` e nessun altro file di impostazioni ne imposta uno, le tue sessioni continuano a iniziare in quella modalità. Su piani Pro, Max e Team, e in sessioni che [non recuperano flag di funzionalità](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), Claude Code chiede una volta, nel terminale o nell'estensione VS Code, se cambiare l'impostazione in modalità auto. Se rifiuti, la tua impostazione rimane come è.92Se il tuo `~/.claude/settings.json` imposta un `defaultMode` diverso da `auto` e nessun altro file di impostazioni ne imposta uno, le tue sessioni continuano a iniziare in quella modalità.

93 

94Su piani Pro, Max, Ultra e Team, e in sessioni che [non recuperano flag di funzionalità](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), Claude Code chiede una volta se cambiare l'impostazione in modalità auto. La domanda appare nel terminale o nell'estensione VS Code e, se rifiuti, la tua impostazione rimane come è.

93 95 

94### Chiamate agli strumenti negate nelle esecuzioni di `claude -p` e dell'Agent SDK96### Chiamate agli strumenti negate nelle esecuzioni di `claude -p` e dell'Agent SDK

95 97 

102 104 

103Questi esempi mostrano la forma della modalità auto per la CLI e per ciascun SDK:105Questi esempi mostrano la forma della modalità auto per la CLI e per ciascun SDK:

104 106 

105**CLI**107> [tab] CLI

106 108>

107```bash theme={null}109> ```bash theme={null}

108claude -p "Run the test suite and fix any failures" --permission-mode auto110> claude -p "Run the test suite and fix any failures" --permission-mode auto

109```111> ```

110 

111**TypeScript**

112 

113```typescript theme={null}

114const options = {

115 permissionMode: "auto"

116};

117```

118 

119**Python**

120 112 

121```python theme={null}113> [tab] TypeScript

122from claude_agent_sdk import ClaudeAgentOptions114>

115> ```typescript theme={null}

116> const options = {

117> permissionMode: "auto"

118> };

119> ```

123 120 

124options = ClaudeAgentOptions(permission_mode="auto")121> [tab] Python

125```122>

123> ```python theme={null}

124> from claude_agent_sdk import ClaudeAgentOptions

125>

126> options = ClaudeAgentOptions(permission_mode="auto")

127> ```

126 128 

127Prima della v2.1.302, queste esecuzioni potevano iniziare in modalità auto se non [recuperavano flag di funzionalità](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), ad esempio su un [provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md) o con `DISABLE_TELEMETRY`.129Prima della v2.1.302, queste esecuzioni potevano iniziare in modalità auto se non [recuperavano flag di funzionalità](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), ad esempio su un [provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md) o con `DISABLE_TELEMETRY`.

128 130 

166 168 

167Ogni interfaccia ha il proprio controllo per cambiare le modalità di autorizzazione durante una sessione e il proprio modo di scegliere la modalità di autorizzazione con cui iniziano le nuove sessioni. Seleziona la tua interfaccia per vedere i suoi controlli.169Ogni interfaccia ha il proprio controllo per cambiare le modalità di autorizzazione durante una sessione e il proprio modo di scegliere la modalità di autorizzazione con cui iniziano le nuove sessioni. Seleziona la tua interfaccia per vedere i suoi controlli.

168 170 

169**CLI**171> [tab] CLI

170 172>

171**Durante una sessione**: premi `Shift+Tab` per scorrere ciclicamente le modalità di permesso. Da `auto`, la prima pressione passa a `default`, e il ciclo prosegue poi con `default` → `acceptEdits` → `plan`. Le modalità opzionali si inseriscono dopo `plan`. La barra di stato mostra la modalità attiva come `⏸ manual mode on` in grigio per `default`, oppure come `⏵⏵ accept edits on`, `⏸ plan mode on`, `⏵⏵ auto mode on`, `⏵⏵ don't ask on` o `⏵⏵ bypass permissions on`.173> **Durante una sessione**: premi `Shift+Tab` per scorrere ciclicamente le modalità di permesso. Da `auto`, la prima pressione passa a `default`, e il ciclo prosegue poi con `default` → `acceptEdits` → `plan`. Le modalità opzionali si inseriscono dopo `plan`. La barra di stato mostra la modalità attiva come `⏸ manual mode on` in grigio per `default`, oppure come `⏵⏵ accept edits on`, `⏸ plan mode on`, `⏵⏵ auto mode on`, `⏵⏵ don't ask on` o `⏵⏵ bypass permissions on`.

172 174>

173Osserva la barra di stato in questo clip di una sessione avviata in modalità auto. Ogni volta che premi `Shift+Tab`, passa da `auto mode on` a `manual mode on`, `accept edits on`, `plan mode on` e di nuovo a `auto mode on`.175> Osserva la barra di stato in questo clip di una sessione avviata in modalità auto. Ogni volta che premi `Shift+Tab`, passa da `auto mode on` a `manual mode on`, `accept edits on`, `plan mode on` e di nuovo a `auto mode on`.

174 176>

175<video autoPlay muted loop playsInline src="https://mintcdn.com/claude-code/tA-x-5L2YsYSVdee/images/permission-modes-cycle-light.mp4?fit=max&auto=format&n=tA-x-5L2YsYSVdee&q=85&s=3927dd62d59b01efd81b3578f2a6f971" aria-label="La barra di stato sotto il prompt di Claude Code cambia a ogni pressione di Shift+Tab: auto mode on, manual mode on, accept edits on, plan mode on, poi di nuovo auto mode on." />177> <video autoPlay muted loop playsInline src="https://mintcdn.com/claude-code/tA-x-5L2YsYSVdee/images/permission-modes-cycle-light.mp4?fit=max&auto=format&n=tA-x-5L2YsYSVdee&q=85&s=3927dd62d59b01efd81b3578f2a6f971" aria-label="La barra di stato sotto il prompt di Claude Code cambia a ogni pressione di Shift+Tab: auto mode on, manual mode on, accept edits on, plan mode on, poi di nuovo auto mode on." />

176 178>

177Non tutte le modalità sono nel ciclo predefinito:179> Non tutte le modalità sono nel ciclo predefinito:

178 180>

179* `auto`: appare quando [auto mode è disponibile](#eliminate-prompts-with-auto-mode); il ciclo ad essa passa le modalità di autorizzazione senza un prompt di conferma181> * `auto`: appare quando [auto mode è disponibile](#eliminate-prompts-with-auto-mode); il ciclo ad essa passa le modalità di autorizzazione senza un prompt di conferma

180* `bypassPermissions`: appare dopo che inizi con `--permission-mode bypassPermissions`, `--dangerously-skip-permissions`, `--allow-dangerously-skip-permissions`, o `permissions.defaultMode: "bypassPermissions"` in [impostazioni utente, `--settings`, o impostazioni gestite](https://code.claude.com/docs/it/settings-reference#permissions-defaultmode). La variante `--allow-` aggiunge la modalità di autorizzazione al ciclo senza attivarla182> * `bypassPermissions`: appare dopo che inizi con `--permission-mode bypassPermissions`, `--dangerously-skip-permissions`, `--allow-dangerously-skip-permissions`, o `permissions.defaultMode: "bypassPermissions"` in [impostazioni utente, `--settings`, o impostazioni gestite](https://code.claude.com/docs/it/settings-reference#permissions-defaultmode). La variante `--allow-` aggiunge la modalità di autorizzazione al ciclo senza attivarla

181* `dontAsk`: non appare mai nel ciclo; impostala con `--permission-mode dontAsk`183> * `dontAsk`: non appare mai nel ciclo; impostala con `--permission-mode dontAsk`

182 184>

183Le modalità opzionali abilitate si inseriscono dopo `plan`, con `bypassPermissions` per primo e `auto` per ultimo. Se hai entrambe abilitate, ciclerai attraverso `bypassPermissions` sulla strada verso `auto`.185> Le modalità opzionali abilitate si inseriscono dopo `plan`, con `bypassPermissions` per primo e `auto` per ultimo. Se hai entrambe abilitate, ciclerai attraverso `bypassPermissions` sulla strada verso `auto`.

184 186>

185**Da un prompt di autorizzazione Bash**: nelle modalità di autorizzazione Manual e `acceptEdits`, quando [auto mode](#eliminate-prompts-with-auto-mode) è disponibile, Claude Code aggiunge **Yes, and switch to auto mode** al prompt di autorizzazione di un comando Bash. Selezionalo per approvare il comando e passare la sessione alla modalità auto. I prompt dello [strumento PowerShell](https://code.claude.com/docs/it/tools-reference.md#powershell-tool) non offrono l'opzione. Richiede Claude Code v2.1.247 o successivo.187> **Da un prompt di autorizzazione Bash**: nelle modalità di autorizzazione Manual e `acceptEdits`, quando [auto mode](#eliminate-prompts-with-auto-mode) è disponibile, Claude Code aggiunge **Yes, and switch to auto mode** al prompt di autorizzazione di un comando Bash. Selezionalo per approvare il comando e passare la sessione alla modalità auto. I prompt dello [strumento PowerShell](https://code.claude.com/docs/it/tools-reference.md#powershell-tool) non offrono l'opzione. Richiede Claude Code v2.1.247 o successivo.

186 188>

187Claude Code non aggiunge l'opzione ai prompt forzati da una delle tue [regole `ask`](https://code.claude.com/docs/it/permissions#manage-permissions) o da un [hook](https://code.claude.com/docs/it/hooks.md#pretooluse-decision-control), perché la modalità auto ti mostra comunque quei prompt, quindi il passaggio non li rimuoverebbe.189> Claude Code non aggiunge l'opzione ai prompt forzati da una delle tue [regole `ask`](https://code.claude.com/docs/it/permissions#manage-permissions) o da un [hook](https://code.claude.com/docs/it/hooks.md#pretooluse-decision-control), perché la modalità auto ti mostra comunque quei prompt, quindi il passaggio non li rimuoverebbe.

188 190>

189**All'avvio**: passa la modalità di autorizzazione come flag.191> **All'avvio**: passa la modalità di autorizzazione come flag.

190 192>

191```bash theme={null}193> ```bash theme={null}

192claude --permission-mode plan194> claude --permission-mode plan

193```195> ```

194 196>

195**Come predefinito**: imposta `permissions.defaultMode` nell'ambito che desideri, come descritto in [Inizia in una modalità di autorizzazione diversa](#start-in-a-different-mode).197> **Come predefinito**: imposta `permissions.defaultMode` nell'ambito che desideri, come descritto in [Inizia in una modalità di autorizzazione diversa](#start-in-a-different-mode).

196 198>

197Lo stesso flag `--permission-mode` funziona con `-p` per [esecuzioni non interattive](https://code.claude.com/docs/it/headless.md).199> Lo stesso flag `--permission-mode` funziona con `-p` per [esecuzioni non interattive](https://code.claude.com/docs/it/headless.md).

198 

199**VS Code**

200 

201**Durante una sessione**: fai clic sull'indicatore di modalità nella parte inferiore della casella del prompt. Utilizza queste etichette per le modalità in questa pagina:

202 

203| Etichetta UI | Modalità |

204| :- | :- |

205| Manual | `default` |

206| Edit automatically | `acceptEdits` |

207| Plan | `plan` |

208| Auto | `auto` |

209| Bypass permissions | `bypassPermissions` |

210 

211**Come predefinito**: per fissare la modalità di autorizzazione con cui iniziano le conversazioni, imposta `claudeCode.initialPermissionMode` nelle impostazioni utente di VS Code su `default`, `manual`, `acceptEdits`, `plan`, o `bypassPermissions`. L'impostazione non accetta `auto`; per iniziare in Auto, lasciala non impostata e seleziona **Auto** dall'indicatore di modalità una volta, come descrive l'elemento 2 di seguito. L'estensione inizia ogni nuova conversazione nel primo di questi che si applica:

212 

2131. `claudeCode.initialPermissionMode`

2142. La modalità che hai selezionato per ultimo dall'indicatore di modalità, se era Manual, Edit automatically, o Auto. Selezionare Plan o Bypass permissions si applica solo a quella conversazione

2153. `permissions.defaultMode` da [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) o `~/.claude/settings.json`

2164. Il [predefinito incorporato](#which-mode-a-session-starts-in) per il tuo piano, provider e impostazioni dell'organizzazione

217 

218L'estensione non legge mai il `.claude/settings.json` o `.claude/settings.local.json` di un progetto per la modalità di autorizzazione iniziale. Quando `claudeCode.claudeProcessWrapper` è impostato, gli elementi 3 e 4 non si applicano: quelle conversazioni iniziano in Manual a meno che l'elemento 1 o l'elemento 2 non imposti una modalità di autorizzazione.

219 

220Prima di v2.1.283, l'elemento 3 si applicava solo su piani Pro, Max e Team in sessioni che [recuperano feature flag](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching).

221 

222Auto appare nell'indicatore di modalità quando [auto mode è disponibile](#eliminate-prompts-with-auto-mode).

223 

224Bypass permissions richiede l'interruttore **Allow dangerously skip permissions** nelle impostazioni dell'estensione. Senza di esso, la modalità di autorizzazione non appare nell'indicatore, e un valore `bypassPermissions` dall'elemento 1 o dall'elemento 3 inizia la conversazione in Manual invece. Auto da qualsiasi elemento allo stesso modo inizia la conversazione in Manual quando la modalità auto non è disponibile.

225 

226Vedi la [guida VS Code](https://code.claude.com/docs/it/vs-code.md) per i dettagli specifici dell'estensione.

227 

228**JetBrains**

229 

230Il plugin JetBrains esegue Claude Code nel terminale dell'IDE, quindi il cambio delle modalità di permesso funziona come nella CLI: premi `Shift+Tab` per scorrerle ciclicamente, o passa `--permission-mode` al lancio.

231 

232**Desktop**

233 

234**Durante una sessione**: nella scheda Code, utilizza il selettore di modalità nella riga sotto la casella del prompt. Non tutte le modalità appaiono nel selettore:

235 

236* **Auto**: appare quando [auto mode è disponibile](#eliminate-prompts-with-auto-mode)

237* **Bypass permissions**: richiede l'interruttore **Allow bypass permissions mode** nelle impostazioni Desktop su piani Pro e Max; su piani Team e Enterprise, la politica dell'organizzazione la controlla invece

238 

239Cowork non utilizza queste modalità. Ha le sue proprie modalità di permesso, abilitate separatamente, e non mostra alcun selettore di modalità finché una modalità oltre quella predefinita non viene abilitata per il tuo account. Vedi la [documentazione Cowork](https://claude.com/docs/cowork/overview).

240 

241Per i dettagli specifici del desktop, vedi [Scegli una modalità di autorizzazione](https://code.claude.com/docs/it/desktop.md#choose-a-permission-mode) nella guida Desktop.

242 

243**Come predefinito**: imposta `defaultMode` in [impostazioni](https://code.claude.com/docs/it/settings.md#where-settings-live). L'app desktop legge gli stessi file di impostazioni della CLI e applica la modalità di autorizzazione alle nuove sessioni locali.

244 

245Una modalità che scegli nel selettore di modalità viene ricordata per cartella e ha la precedenza su `defaultMode` per quella cartella. Plan è l'eccezione: selezionarla si applica solo alla sessione corrente.

246 

247Per sapere dove va `defaultMode` in un file di impostazioni, consulta l'esempio in [Inizia in una modalità di permesso diversa](#start-in-a-different-mode).

248 

249**Web and mobile**

250 200 

251Su [claude.ai/code](https://claude.ai/code), utilizza il menu a discesa della modalità nella riga sotto la casella del prompt. Nell'app mobile, tocca il pulsante **+** nella casella del prompt, poi **Permission**. Le sessioni cloud e le sessioni Remote Control offrono modalità di permesso diverse:201> [tab] VS Code

202>

203> **Durante una sessione**: fai clic sull'indicatore di modalità nella parte inferiore della casella del prompt. Utilizza queste etichette per le modalità in questa pagina:

204>

205> | Etichetta UI | Modalità |

206> | :- | :- |

207> | Manual | `default` |

208> | Edit automatically | `acceptEdits` |

209> | Plan | `plan` |

210> | Auto | `auto` |

211> | Bypass permissions | `bypassPermissions` |

212>

213> **Come predefinito**: per fissare la modalità di autorizzazione con cui iniziano le conversazioni, imposta `claudeCode.initialPermissionMode` nelle impostazioni utente di VS Code su `default`, `manual`, `acceptEdits`, `plan`, o `bypassPermissions`. L'impostazione non accetta `auto`; per iniziare in Auto, lasciala non impostata e seleziona **Auto** dall'indicatore di modalità una volta, come descrive l'elemento 2 di seguito. L'estensione inizia ogni nuova conversazione nel primo di questi che si applica:

214>

215> 1. `claudeCode.initialPermissionMode`

216> 2. La modalità che hai selezionato per ultimo dall'indicatore di modalità, se era Manual, Edit automatically, o Auto. Selezionare Plan o Bypass permissions si applica solo a quella conversazione

217> 3. `permissions.defaultMode` da [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) o `~/.claude/settings.json`

218> 4. Il [predefinito incorporato](#which-mode-a-session-starts-in) per il tuo piano, provider e impostazioni dell'organizzazione

219>

220> L'estensione non legge mai il `.claude/settings.json` o `.claude/settings.local.json` di un progetto per la modalità di autorizzazione iniziale. Quando `claudeCode.claudeProcessWrapper` è impostato, gli elementi 3 e 4 non si applicano: quelle conversazioni iniziano in Manual a meno che l'elemento 1 o l'elemento 2 non imposti una modalità di autorizzazione.

221>

222> Prima di v2.1.283, l'elemento 3 si applicava solo su piani Pro, Max, Ultra e Team in sessioni che [recuperano feature flag](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching).

223>

224> Auto appare nell'indicatore di modalità quando [auto mode è disponibile](#eliminate-prompts-with-auto-mode).

225>

226> Bypass permissions richiede l'interruttore **Allow dangerously skip permissions** nelle impostazioni dell'estensione. Senza di esso, la modalità di autorizzazione non appare nell'indicatore, e un valore `bypassPermissions` dall'elemento 1 o dall'elemento 3 inizia la conversazione in Manual invece. Auto da qualsiasi elemento allo stesso modo inizia la conversazione in Manual quando la modalità auto non è disponibile.

227>

228> Vedi la [guida VS Code](https://code.claude.com/docs/it/vs-code.md) per i dettagli specifici dell'estensione.

252 229 

253* **[Sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md)**: Accept edits, Plan e Auto. Accept edits corrisponde alla modalità `default`: le sessioni cloud pre-approvano le modifiche ai file indipendentemente dalla modalità, quindi il menu a discesa mostra Accept edits invece di Manual. Le sessioni cloud rispettano comunque `defaultMode: "acceptEdits"` dalle impostazioni. La modalità auto appare solo quando la tua organizzazione la consente e il modello selezionato la supporta. Bypass permissions non è disponibile.230> [tab] JetBrains

254* **[Sessioni Remote Control](https://code.claude.com/docs/it/remote-control.md)** sulla tua macchina locale: Manual, Accept edits, Plan e Auto per una sessione che hai avviato tu stesso, e non puoi selezionare Bypass permissions dall'app. Per usare Auto, la sessione deve soddisfare i [requisiti di disponibilità](#eliminate-prompts-with-auto-mode) della modalità auto. Per un thread di progetto in esecuzione sul tuo computer, consulta [Esegui un thread sul tuo computer](https://code.claude.com/docs/it/claude-projects.md#run-a-thread-on-your-own-computer).231>

255 * Ad eccezione di Bypass permissions, il menu a discesa mostra la modalità di permesso in cui si trova la sessione locale, inclusa una impostata dal terminale. Si aggiorna quando la modalità di permesso cambia nell'app o nel terminale.232> Il plugin JetBrains esegue Claude Code nel terminale dell'IDE, quindi il cambio delle modalità di permesso funziona come nella CLI: premi `Shift+Tab` per scorrerle ciclicamente, o passa `--permission-mode` al lancio.

256 * Le sessioni ospitate dall'[app desktop](https://code.claude.com/docs/it/desktop.md) o dall'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md) segnalano i cambiamenti della modalità di permesso a claude.ai man mano che avvengono, come le sessioni ospitate in un terminale.

257 233 

258Per Remote Control, la macchina locale che esegue la sessione deve essere connessa con il tuo account claude.ai; le chiavi API non sono supportate. Puoi anche impostare la modalità di autorizzazione iniziale al lancio di quella sessione locale:234> [tab] Desktop

235>

236> **Durante una sessione**: nella scheda Code, utilizza il selettore di modalità nella riga sotto la casella del prompt. Non tutte le modalità appaiono nel selettore:

237>

238> * **Auto**: appare quando [auto mode è disponibile](#eliminate-prompts-with-auto-mode)

239> * **Bypass permissions**: richiede l'interruttore **Allow bypass permissions mode** nelle impostazioni Desktop su piani Pro, Max e Ultra; su piani Team e Enterprise, la politica dell'organizzazione la controlla invece

240>

241> Cowork non utilizza queste modalità. Ha le sue proprie modalità di permesso, abilitate separatamente, e non mostra alcun selettore di modalità finché una modalità oltre quella predefinita non viene abilitata per il tuo account. Vedi la [documentazione Cowork](https://claude.com/docs/cowork/overview).

242>

243> Per i dettagli specifici del desktop, vedi [Scegli una modalità di autorizzazione](https://code.claude.com/docs/it/desktop.md#choose-a-permission-mode) nella guida Desktop.

244>

245> **Come predefinito**: imposta `defaultMode` in [impostazioni](https://code.claude.com/docs/it/settings.md#where-settings-live). L'app desktop legge gli stessi file di impostazioni della CLI e applica la modalità di autorizzazione alle nuove sessioni locali.

246>

247> Una modalità che scegli nel selettore di modalità viene ricordata per cartella e ha la precedenza su `defaultMode` per quella cartella. Plan è l'eccezione: selezionarla si applica solo alla sessione corrente.

248>

249> Per sapere dove va `defaultMode` in un file di impostazioni, consulta l'esempio in [Inizia in una modalità di permesso diversa](#start-in-a-different-mode).

259 250 

260```bash theme={null}251> [tab] Web and mobile

261claude remote-control --permission-mode acceptEdits252>

262```253> Su [claude.ai/code](https://claude.ai/code), utilizza il menu a discesa della modalità nella riga sotto la casella del prompt. Nell'app mobile, tocca il pulsante **+** nella casella del prompt, poi **Permission**. Le sessioni cloud e le sessioni Remote Control offrono modalità di permesso diverse:

254>

255> * **[Sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md)**: Accept edits, Plan e Auto. Accept edits corrisponde alla modalità `default`: le sessioni cloud pre-approvano le modifiche ai file indipendentemente dalla modalità, quindi il menu a discesa mostra Accept edits invece di Manual. Le sessioni cloud rispettano comunque `defaultMode: "acceptEdits"` dalle impostazioni. La modalità auto appare solo quando la tua organizzazione la consente e il modello selezionato la supporta. Bypass permissions non è disponibile.

256> * **[Sessioni Remote Control](https://code.claude.com/docs/it/remote-control.md)** sulla tua macchina locale: Manual, Accept edits, Plan e Auto per una sessione che hai avviato tu stesso, e non puoi selezionare Bypass permissions dall'app. Per usare Auto, la sessione deve soddisfare i [requisiti di disponibilità](#eliminate-prompts-with-auto-mode) della modalità auto. Per un thread di progetto in esecuzione sul tuo computer, consulta [Esegui un thread sul tuo computer](https://code.claude.com/docs/it/claude-projects.md#run-a-thread-on-your-own-computer).

257> * Ad eccezione di Bypass permissions, il menu a discesa mostra la modalità di permesso in cui si trova la sessione locale, inclusa una impostata dal terminale. Si aggiorna quando la modalità di permesso cambia nell'app o nel terminale.

258> * Le sessioni ospitate dall'[app desktop](https://code.claude.com/docs/it/desktop.md) o dall'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md) segnalano i cambiamenti della modalità di permesso a claude.ai man mano che avvengono, come le sessioni ospitate in un terminale.

259>

260> Per Remote Control, la macchina locale che esegue la sessione deve essere connessa con il tuo account claude.ai; le chiavi API non sono supportate. Puoi anche impostare la modalità di autorizzazione iniziale al lancio di quella sessione locale:

261>

262> ```bash theme={null}

263> claude remote-control --permission-mode acceptEdits

264> ```

263 265 

264## Auto-approva le modifiche ai file con la modalità acceptEdits266## Auto-approva le modifiche ai file con la modalità acceptEdits

265 267 

327 329 

328La modalità auto consente a Claude di eseguire senza richieste di permesso di routine. Un modello classificatore separato esamina le azioni prima che vengano eseguite, bloccando qualsiasi cosa che vada oltre la tua richiesta, che prenda di mira un'infrastruttura non riconosciuta, o che sembri guidata da contenuti ostili che Claude ha letto. Le [regole ask](https://code.claude.com/docs/it/permissions.md#manage-permissions) esplicite forzano comunque una richiesta di permesso.330La modalità auto consente a Claude di eseguire senza richieste di permesso di routine. Un modello classificatore separato esamina le azioni prima che vengano eseguite, bloccando qualsiasi cosa che vada oltre la tua richiesta, che prenda di mira un'infrastruttura non riconosciuta, o che sembri guidata da contenuti ostili che Claude ha letto. Le [regole ask](https://code.claude.com/docs/it/permissions.md#manage-permissions) esplicite forzano comunque una richiesta di permesso.

329 331 

330Con Claude Code v2.1.283 o successivo, la modalità auto è la [modalità di permesso iniziale integrata](#which-mode-a-session-starts-in) per le sessioni di terminale interattivo e VS Code su ogni piano e provider. Nelle versioni precedenti, è la modalità di permesso iniziale integrata solo sui piani Pro, Max e Team.332Con Claude Code v2.1.283 o successivo, la modalità auto è la [modalità di permesso iniziale integrata](#which-mode-a-session-starts-in) per le sessioni di terminale interattivo e VS Code su ogni piano e provider. Nelle versioni precedenti, è la modalità di permesso iniziale integrata solo sui piani Pro, Max, Ultra e Team.

331 333 

332Il classificatore esamina anche ogni messaggio che Claude invia a un altro agente con [`SendMessage`](https://code.claude.com/docs/it/tools-reference), sia testo semplice che un messaggio strutturato di [team di agenti](https://code.claude.com/docs/it/agent-teams.md), prima che Claude Code lo consegni, sia in modalità auto che in [modalità plan mentre il classificatore esamina i comandi](#analyze-before-you-edit-with-plan-mode); la revisione dell'invio richiede Claude Code v2.1.222 o successivo.334Il classificatore esamina anche ogni messaggio che Claude invia a un altro agente con [`SendMessage`](https://code.claude.com/docs/it/tools-reference), sia testo semplice che un messaggio strutturato di [team di agenti](https://code.claude.com/docs/it/agent-teams.md), prima che Claude Code lo consegni, sia in modalità auto che in [modalità plan mentre il classificatore esamina i comandi](#analyze-before-you-edit-with-plan-mode); la revisione dell'invio richiede Claude Code v2.1.222 o successivo.

333 335 

367 369 

368In modalità auto, Claude Code può chiedere al server di controllare le azioni che [l'ordine decisionale](#how-the-classifier-evaluates-actions) invia per la revisione, come parte delle richieste al modello della sessione, al posto di inviare le proprie richieste del classificatore. Queste sessioni chiedono:370In modalità auto, Claude Code può chiedere al server di controllare le azioni che [l'ordine decisionale](#how-the-classifier-evaluates-actions) invia per la revisione, come parte delle richieste al modello della sessione, al posto di inviare le proprie richieste del classificatore. Queste sessioni chiedono:

369 371 

370* **Una connessione diretta all'API Anthropic**: nelle sessioni di terminale interattivo e nelle sessioni `-p`, Agent SDK, [estensione VS Code](https://code.claude.com/docs/it/vs-code.md) e [app desktop](https://code.claude.com/docs/it/desktop.md), indipendentemente dal tuo piano o tipo di account, man mano che Anthropic lo distribuisce. Nelle sessioni di terminale interattivo, questo richiede Claude Code v2.1.271 o successivo sui piani Pro, Max e Team, e v2.1.278 o successivo sui piani Enterprise e sugli account Claude API. Nelle sessioni `-p`, Agent SDK, estensione VS Code e app desktop, questo richiede Claude Code v2.1.281 o successivo. Dalla v2.1.282, una sessione che [non recupera i feature flag](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), ad esempio perché hai disattivato la telemetria, chiede al server per impostazione predefinita in qualsiasi tipo di sessione.372* **Una connessione diretta all'API Anthropic**: nelle sessioni di terminale interattivo e nelle sessioni `-p`, Agent SDK, [estensione VS Code](https://code.claude.com/docs/it/vs-code.md) e [app desktop](https://code.claude.com/docs/it/desktop.md), indipendentemente dal tuo piano o tipo di account, man mano che Anthropic lo distribuisce. Verifica il tuo tipo di sessione rispetto a queste versioni minime di Claude Code:

373 * Nelle sessioni di terminale interattivo, chiedere al server richiede Claude Code v2.1.271 o successivo sui piani Pro, Max, Ultra e Team. Sui piani Enterprise e sugli account Claude API, quelle sessioni richiedono v2.1.278 o successivo.

374 * Nelle sessioni `-p`, Agent SDK, estensione VS Code e app desktop, chiedere al server richiede Claude Code v2.1.281 o successivo

375 * Dalla v2.1.282, una sessione che [non recupera i feature flag](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), ad esempio perché hai disattivato la telemetria, chiede al server per impostazione predefinita in qualsiasi tipo di sessione

371* **Un provider cloud, o un gateway LLM o proxy**: su [Claude Platform su AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md), Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry, e ogni volta che punti `ANTHROPIC_BASE_URL` a un [gateway LLM o proxy](https://code.claude.com/docs/it/llm-gateway), indipendentemente dal tuo piano. Chiedere per impostazione predefinita richiede Claude Code v2.1.278 o successivo.376* **Un provider cloud, o un gateway LLM o proxy**: su [Claude Platform su AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md), Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry, e ogni volta che punti `ANTHROPIC_BASE_URL` a un [gateway LLM o proxy](https://code.claude.com/docs/it/llm-gateway), indipendentemente dal tuo piano. Chiedere per impostazione predefinita richiede Claude Code v2.1.278 o successivo.

372* **Una sessione [gateway di app Claude](https://code.claude.com/docs/it/claude-apps-gateway) con accesso**: richiede Claude Code v2.1.280 o successivo377* **Una sessione [gateway di app Claude](https://code.claude.com/docs/it/claude-apps-gateway) con accesso**: richiede Claude Code v2.1.280 o successivo

373* **Una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) in un ambiente ospitato da Anthropic**: indipendentemente dal tuo piano, quando la avvii dal web, dall'app mobile o dall'app desktop con **Cloud** selezionato. Le sessioni avviate da un'[attività pianificata cloud](https://code.claude.com/docs/it/routines.md) chiedono al server man mano che Anthropic lo distribuisce.378* **Una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) in un ambiente ospitato da Anthropic**: indipendentemente dal tuo piano, quando la avvii dal web, dall'app mobile o dall'app desktop con **Cloud** selezionato. Le sessioni avviate da un'[attività pianificata cloud](https://code.claude.com/docs/it/routines.md) chiedono al server man mano che Anthropic lo distribuisce.

566 571 

567Le sezioni seguenti descrivono l'ordine in cui Claude Code valuta un'azione, come il classificatore esamina il lavoro dei subagent, e cosa aggiungono le chiamate al classificatore in termini di costo e latenza.572Le sezioni seguenti descrivono l'ordine in cui Claude Code valuta un'azione, come il classificatore esamina il lavoro dei subagent, e cosa aggiungono le chiamate al classificatore in termini di costo e latenza.

568 573 

569> **Come il classificatore valuta le azioni**574> [accordion] Come il classificatore valuta le azioni

570>575>

571> Ogni azione passa attraverso un ordine decisionale fisso. Prevale il primo passaggio corrispondente:576> Ogni azione passa attraverso un ordine decisionale fisso. Prevale il primo passaggio corrispondente:

572>577>

608>613>

609> Una sonda lato server separata analizza i risultati degli strumenti in arrivo e segnala il contenuto sospetto prima che Claude lo legga. Per ulteriori informazioni su come questi livelli funzionano insieme, vedi l'[annuncio della modalità auto](https://claude.com/blog/auto-mode) e l'[approfondimento tecnico](https://www.anthropic.com/engineering/claude-code-auto-mode).614> Una sonda lato server separata analizza i risultati degli strumenti in arrivo e segnala il contenuto sospetto prima che Claude lo legga. Per ulteriori informazioni su come questi livelli funzionano insieme, vedi l'[annuncio della modalità auto](https://claude.com/blog/auto-mode) e l'[approfondimento tecnico](https://www.anthropic.com/engineering/claude-code-auto-mode).

610 615 

611> **Come la modalità auto gestisce i subagent**616> [accordion] Come la modalità auto gestisce i subagent

612>617>

613> Il classificatore controlla il lavoro dei [subagent](https://code.claude.com/docs/it/sub-agents.md) in tre punti:618> Il classificatore controlla il lavoro dei [subagent](https://code.claude.com/docs/it/sub-agents.md) in tre punti:

614>619>

616> 2. Mentre il subagent è in esecuzione, ciascuna delle sue azioni passa attraverso lo stesso [ordine decisionale](#how-the-classifier-evaluates-actions) della sessione padre, con le stesse regole di blocco e di consenso. Qualsiasi `permissionMode` nel frontmatter del subagent viene ignorato.621> 2. Mentre il subagent è in esecuzione, ciascuna delle sue azioni passa attraverso lo stesso [ordine decisionale](#how-the-classifier-evaluates-actions) della sessione padre, con le stesse regole di blocco e di consenso. Qualsiasi `permissionMode` nel frontmatter del subagent viene ignorato.

617> 3. Quando il subagent termina, il classificatore esamina il suo lavoro e il suo rapporto finale prima che la sessione padre legga il rapporto. Quando il classificatore segnala il lavoro o il rapporto del subagent, o un controllo di sicurezza separato dell'API rifiuta la revisione, il rapporto viene comunque consegnato, preceduto da un avviso di sicurezza. Quando il classificatore non è disponibile per la revisione, il rapporto arriva con una nota che invita a verificare il lavoro del subagent prima di agire di conseguenza.622> 3. Quando il subagent termina, il classificatore esamina il suo lavoro e il suo rapporto finale prima che la sessione padre legga il rapporto. Quando il classificatore segnala il lavoro o il rapporto del subagent, o un controllo di sicurezza separato dell'API rifiuta la revisione, il rapporto viene comunque consegnato, preceduto da un avviso di sicurezza. Quando il classificatore non è disponibile per la revisione, il rapporto arriva con una nota che invita a verificare il lavoro del subagent prima di agire di conseguenza.

618 623 

619> **Costo e latenza**624> [accordion] Costo e latenza

620>625>

621> Le richieste del classificatore di Claude Code possono essere eseguite su un modello diverso da quello selezionato con `/model`. Vedi [su quale modello vengono eseguite](#default-classifier-model).626> Le richieste del classificatore di Claude Code possono essere eseguite su un modello diverso da quello selezionato con `/model`. Vedi [su quale modello vengono eseguite](#default-classifier-model).

622>627>

964 969 

965Per eseguire senza prompt i comandi Bash `rm` e `rmdir` che prendono di mira [percorsi critici](#critical-paths) in modalità `bypassPermissions`, avvia Claude Code con [`CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS=1`](https://code.claude.com/docs/it/env-vars#variables) nel suo ambiente. Questo richiede Claude Code v2.1.311 o successivo. Claude Code legge la variabile solo dall'ambiente di avvio e [la ignora nel blocco `env` di un file di impostazioni](https://code.claude.com/docs/it/settings-reference#variables-claude-code-ignores-in-env). Ad esempio, impostala nella [tua shell](https://code.claude.com/docs/it/env-vars.md#set-variables-in-your-shell) e avvia `claude` da lì:970Per eseguire senza prompt i comandi Bash `rm` e `rmdir` che prendono di mira [percorsi critici](#critical-paths) in modalità `bypassPermissions`, avvia Claude Code con [`CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS=1`](https://code.claude.com/docs/it/env-vars#variables) nel suo ambiente. Questo richiede Claude Code v2.1.311 o successivo. Claude Code legge la variabile solo dall'ambiente di avvio e [la ignora nel blocco `env` di un file di impostazioni](https://code.claude.com/docs/it/settings-reference#variables-claude-code-ignores-in-env). Ad esempio, impostala nella [tua shell](https://code.claude.com/docs/it/env-vars.md#set-variables-in-your-shell) e avvia `claude` da lì:

966 971 

967**macOS, Linux, WSL**972> [tab] macOS, Linux, WSL

968 973>

969```bash theme={null}974> ```bash theme={null}

970export CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS=1975> export CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS=1

971claude --permission-mode bypassPermissions976> claude --permission-mode bypassPermissions

972```977> ```

973 

974**Windows PowerShell**

975 

976```powershell theme={null}

977$env:CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS = "1"

978claude --permission-mode bypassPermissions

979```

980 978 

981**Windows CMD**979> [tab] Windows PowerShell

980>

981> ```powershell theme={null}

982> $env:CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS = "1"

983> claude --permission-mode bypassPermissions

984> ```

982 985 

983```batch theme={null}986> [tab] Windows CMD

984set CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS=1987>

985claude --permission-mode bypassPermissions988> ```batch theme={null}

986```989> set CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS=1

990> claude --permission-mode bypassPermissions

991> ```

987 992 

988> [!WARNING]993> [!WARNING]

989>994>

platforms.md +6 −6

Details

14 14 

15| Piattaforma | Ideale per | Cosa ottieni |15| Piattaforma | Ideale per | Cosa ottieni |

16| :- | :- | :- |16| :- | :- | :- |

17| [CLI](https://code.claude.com/docs/it/quickstart.md) | Flussi di lavoro da terminale, scripting, server remoti | Set completo di funzionalità, [Agent SDK](https://code.claude.com/docs/it/headless.md), [computer use](https://code.claude.com/docs/it/computer-use.md) su macOS (Pro e Max), provider di terze parti |17| [CLI](https://code.claude.com/docs/it/quickstart.md) | Flussi di lavoro da terminale, scripting, server remoti | Set completo di funzionalità, [Agent SDK](https://code.claude.com/docs/it/headless.md), [computer use](https://code.claude.com/docs/it/computer-use.md) su macOS (Pro, Max e Ultra), provider di terze parti |

18| [Desktop](https://code.claude.com/docs/it/desktop.md) | Revisione visiva, sessioni parallele, configurazione gestita | Visualizzatore diff, anteprima app, [computer use](https://code.claude.com/docs/it/desktop.md#let-claude-use-your-computer) e [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) su Pro e Max |18| [Desktop](https://code.claude.com/docs/it/desktop.md) | Revisione visiva, sessioni parallele, configurazione gestita | Visualizzatore diff, anteprima app, [computer use](https://code.claude.com/docs/it/desktop.md#let-claude-use-your-computer) e [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) su Pro, Max e Ultra |

19| [VS Code](https://code.claude.com/docs/it/vs-code.md) | Lavorare all'interno di VS Code senza passare a un terminale | Diff inline, terminale integrato, contesto file |19| [VS Code](https://code.claude.com/docs/it/vs-code.md) | Lavorare all'interno di VS Code senza passare a un terminale | Diff inline, terminale integrato, contesto file |

20| [JetBrains](https://code.claude.com/docs/it/jetbrains.md) | Lavorare all'interno di IntelliJ, PyCharm, WebStorm o altri IDE JetBrains | Visualizzatore diff, condivisione selezione, sessione terminale |20| [JetBrains](https://code.claude.com/docs/it/jetbrains.md) | Lavorare all'interno di IntelliJ, PyCharm, WebStorm o altri IDE JetBrains | Visualizzatore diff, condivisione selezione, sessione terminale |

21| [Web](https://code.claude.com/docs/it/claude-code-on-the-web.md) | Attività a lunga esecuzione che non richiedono molto controllo, o lavoro che dovrebbe continuare quando sei offline | Cloud, gestito da Anthropic per impostazione predefinita; continua dopo la disconnessione |21| [Web](https://code.claude.com/docs/it/claude-code-on-the-web.md) | Attività a lunga esecuzione che non richiedono molto controllo, o lavoro che dovrebbe continuare quando sei offline | Cloud, gestito da Anthropic per impostazione predefinita; continua dopo la disconnessione |

22| [Mobile](https://code.claude.com/docs/it/mobile.md) | Avviare e monitorare attività mentre sei lontano dal tuo computer | Sessioni cloud dall'app Claude per iOS e Android, [Remote Control](https://code.claude.com/docs/it/remote-control.md) per sessioni locali, [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) verso Desktop su Pro e Max |22| [Mobile](https://code.claude.com/docs/it/mobile.md) | Avviare e monitorare attività mentre sei lontano dal tuo computer | Sessioni cloud dall'app Claude per iOS e Android, [Remote Control](https://code.claude.com/docs/it/remote-control.md) per sessioni locali, [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) verso Desktop su Pro, Max e Ultra |

23 23 

24La CLI è la superficie più completa per il lavoro nativo da terminale: scripting e Agent SDK sono solo CLI. I provider di terze parti funzionano anche in [VS Code](https://code.claude.com/docs/it/vs-code.md#use-third-party-providers) e in [JetBrains](https://code.claude.com/docs/it/feature-availability.md#features-available-on-every-provider), che esegue la CLI nel terminale del tuo IDE. Le distribuzioni [Desktop](https://code.claude.com/docs/it/desktop.md) aziendali supportano Google Cloud's Agent Platform, e Desktop supporta [provider gateway](https://code.claude.com/docs/it/llm-gateway-connect.md#desktop-app); per Amazon Bedrock o Microsoft Foundry, usa la CLI o un'estensione IDE, oppure [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview), che esegue la scheda Code su questi provider. Desktop e le estensioni IDE scambiano alcune funzionalità solo CLI per revisione visiva e integrazione editor più stretta. Il web viene eseguito nel cloud, quindi le attività continuano dopo la disconnessione. Mobile è un thin client nelle stesse sessioni cloud o in una sessione locale tramite Remote Control, e può inviare attività a Desktop con Dispatch.24La CLI è la superficie più completa per il lavoro nativo da terminale: scripting e Agent SDK sono solo CLI. I provider di terze parti funzionano anche in [VS Code](https://code.claude.com/docs/it/vs-code.md#use-third-party-providers) e in [JetBrains](https://code.claude.com/docs/it/feature-availability.md#features-available-on-every-provider), che esegue la CLI nel terminale del tuo IDE. Le distribuzioni [Desktop](https://code.claude.com/docs/it/desktop.md) aziendali supportano Google Cloud's Agent Platform, e Desktop supporta [provider gateway](https://code.claude.com/docs/it/llm-gateway-connect.md#desktop-app); per Amazon Bedrock o Microsoft Foundry, usa la CLI o un'estensione IDE, oppure [Claude Desktop on 3P](https://claude.com/docs/third-party/claude-desktop/overview), che esegue la scheda Code su questi provider. Desktop e le estensioni IDE scambiano alcune funzionalità solo CLI per revisione visiva e integrazione editor più stretta. Il web viene eseguito nel cloud, quindi le attività continuano dopo la disconnessione. Mobile è un thin client nelle stesse sessioni cloud o in una sessione locale tramite Remote Control, e può inviare attività a Desktop con Dispatch.

25 25 

35| [GitHub Actions](https://code.claude.com/docs/it/github-actions.md) | Esegue Claude nella tua pipeline CI | Revisioni PR automatizzate, triage problemi, manutenzione programmata |35| [GitHub Actions](https://code.claude.com/docs/it/github-actions.md) | Esegue Claude nella tua pipeline CI | Revisioni PR automatizzate, triage problemi, manutenzione programmata |

36| [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md) | Come GitHub Actions per GitLab | Automazione guidata da CI su GitLab |36| [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md) | Come GitHub Actions per GitLab | Automazione guidata da CI su GitLab |

37| [Code Review](https://code.claude.com/docs/it/code-review.md) | Rivede automaticamente ogni PR | Catturare bug prima della revisione umana |37| [Code Review](https://code.claude.com/docs/it/code-review.md) | Rivede automaticamente ogni PR | Catturare bug prima della revisione umana |

38| [Slack](https://code.claude.com/docs/it/slack.md) | Risponde alle menzioni `@Claude` nei tuoi canali, con il tuo account personale | Trasformare segnalazioni di bug in pull request dalla chat del team sui piani Pro e Max |38| [Slack](https://code.claude.com/docs/it/slack.md) | Risponde alle menzioni `@Claude` nei tuoi canali, con il tuo account personale | Trasformare segnalazioni di bug in pull request dalla chat del team sui piani Pro, Max e Ultra |

39| [Claude Tag](https://claude.com/docs/claude-tag) | Esegue `@Claude` come identità condivisa della tua organizzazione con accesso configurato dall'amministratore | Accesso condiviso del team su piani Team ed Enterprise, invece di sessioni Slack per utente |39| [Claude Tag](https://claude.com/docs/claude-tag) | Esegue `@Claude` come identità condivisa della tua organizzazione con accesso configurato dall'amministratore | Accesso condiviso del team su piani Team ed Enterprise, invece di sessioni Slack per utente |

40 40 

41Per integrazioni non elencate qui, [server MCP](https://code.claude.com/docs/it/mcp.md) e [connettori](https://code.claude.com/docs/it/desktop.md#connect-external-tools) ti permettono di collegare quasi tutto: Linear, Notion, Google Drive o le tue API interne.41Per integrazioni non elencate qui, [server MCP](https://code.claude.com/docs/it/mcp.md) e [connettori](https://code.claude.com/docs/it/desktop.md#connect-external-tools) ti permettono di collegare quasi tutto: Linear, Notion, Google Drive o le tue API interne.

49| [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) | Invia un'attività dall'app mobile Claude | La tua macchina (Desktop) | [Associa l'app mobile a Desktop](https://support.claude.com/en/articles/13947068) | Delegare il lavoro mentre sei via, setup minimo |49| [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) | Invia un'attività dall'app mobile Claude | La tua macchina (Desktop) | [Associa l'app mobile a Desktop](https://support.claude.com/en/articles/13947068) | Delegare il lavoro mentre sei via, setup minimo |

50| [Remote Control](https://code.claude.com/docs/it/remote-control.md) | Guida una sessione in esecuzione da [claude.ai/code](https://claude.ai/code) o dall'app mobile Claude | La tua macchina (CLI, Desktop, o VS Code) | Esegui [`claude remote-control` o `/remote-control`](https://code.claude.com/docs/it/remote-control#start-a-remote-control-session) | Guidare il lavoro in corso da un altro dispositivo |50| [Remote Control](https://code.claude.com/docs/it/remote-control.md) | Guida una sessione in esecuzione da [claude.ai/code](https://claude.ai/code) o dall'app mobile Claude | La tua macchina (CLI, Desktop, o VS Code) | Esegui [`claude remote-control` o `/remote-control`](https://code.claude.com/docs/it/remote-control#start-a-remote-control-session) | Guidare il lavoro in corso da un altro dispositivo |

51| [Channels](https://code.claude.com/docs/it/channels.md) | Invia eventi da un'app di chat come Telegram o Discord, o dal tuo server | La tua macchina (CLI) | [Installa un plugin channel](https://code.claude.com/docs/it/channels.md#quickstart) o [crea il tuo](https://code.claude.com/docs/it/channels-reference.md) | Reagire a eventi esterni come errori CI o messaggi di chat |51| [Channels](https://code.claude.com/docs/it/channels.md) | Invia eventi da un'app di chat come Telegram o Discord, o dal tuo server | La tua macchina (CLI) | [Installa un plugin channel](https://code.claude.com/docs/it/channels.md#quickstart) o [crea il tuo](https://code.claude.com/docs/it/channels-reference.md) | Reagire a eventi esterni come errori CI o messaggi di chat |

52| [Slack](https://code.claude.com/docs/it/slack.md) | Menziona `@Claude` in un canale del team | Cloud Anthropic | [Installa l'app Slack](https://code.claude.com/docs/it/slack.md#setting-up-claude-code-in-slack) con [Claude Code sul web](https://code.claude.com/docs/it/claude-code-on-the-web.md) abilitato, sui piani Pro e Max | PR e revisioni dalla chat del team |52| [Slack](https://code.claude.com/docs/it/slack.md) | Menziona `@Claude` in un canale del team | Cloud Anthropic | [Installa l'app Slack](https://code.claude.com/docs/it/slack.md#setting-up-claude-code-in-slack) con [Claude Code sul web](https://code.claude.com/docs/it/claude-code-on-the-web.md) abilitato, sui piani Pro, Max e Ultra | PR e revisioni dalla chat del team |

53| [Self-hosted environments](https://code.claude.com/docs/it/self-hosted-environments) | Avvia una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e scegli l'ambiente della tua organizzazione | L'infrastruttura della tua organizzazione | [Distribuisci runner](https://code.claude.com/docs/it/self-hosted-environments-quickstart.md), su piani Team e Enterprise | Sessioni cloud che devono essere eseguite all'interno della tua rete |53| [Self-hosted environments](https://code.claude.com/docs/it/self-hosted-environments) | Avvia una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e scegli l'ambiente della tua organizzazione | L'infrastruttura della tua organizzazione | [Distribuisci runner](https://code.claude.com/docs/it/self-hosted-environments-quickstart.md), su piani Team e Enterprise | Sessioni cloud che devono essere eseguite all'interno della tua rete |

54| [Scheduled tasks](https://code.claude.com/docs/it/scheduled-tasks.md) | Imposta una pianificazione | [CLI](https://code.claude.com/docs/it/scheduled-tasks.md), [Desktop](https://code.claude.com/docs/it/desktop-scheduled-tasks.md), o [cloud](https://code.claude.com/docs/it/routines.md) | Scegli una frequenza | Automazione ricorrente come revisioni giornaliere |54| [Scheduled tasks](https://code.claude.com/docs/it/scheduled-tasks.md) | Imposta una pianificazione | [CLI](https://code.claude.com/docs/it/scheduled-tasks.md), [Desktop](https://code.claude.com/docs/it/desktop-scheduled-tasks.md), o [cloud](https://code.claude.com/docs/it/routines.md) | Scegli una frequenza | Automazione ricorrente come revisioni giornaliere |

55 55 

74* [GitHub Actions](https://code.claude.com/docs/it/github-actions.md): esegui Claude nella tua pipeline CI74* [GitHub Actions](https://code.claude.com/docs/it/github-actions.md): esegui Claude nella tua pipeline CI

75* [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md): lo stesso per GitLab75* [GitLab CI/CD](https://code.claude.com/docs/it/gitlab-ci-cd.md): lo stesso per GitLab

76* [Code Review](https://code.claude.com/docs/it/code-review.md): revisione automatica su ogni pull request76* [Code Review](https://code.claude.com/docs/it/code-review.md): revisione automatica su ogni pull request

77* [Slack](https://code.claude.com/docs/it/slack.md): invia attività dalla chat del team e ricevi PR indietro, sui piani Pro e Max77* [Slack](https://code.claude.com/docs/it/slack.md): invia attività dalla chat del team e ricevi PR indietro, sui piani Pro, Max e Ultra

78* [Claude Tag](https://claude.com/docs/claude-tag): esegui `@Claude` come identità condivisa della tua organizzazione su piani Team ed Enterprise78* [Claude Tag](https://claude.com/docs/claude-tag): esegui `@Claude` come identità condivisa della tua organizzazione su piani Team ed Enterprise

79 79 

80### Accesso remoto80### Accesso remoto

plugins/install.md +96 −96

Details

27 27 

28Scegli la scheda per il luogo in cui esegui Claude Code.28Scegli la scheda per il luogo in cui esegui Claude Code.

29 29 

30**Terminal**30> [tab] Terminal

31 31>

32Avvia Claude Code con `claude` nel tuo progetto, quindi:32> Avvia Claude Code con `claude` nel tuo progetto, quindi:

33 33>

34**1. Apri i dettagli del plugin con il comando di installazione**34> **1. Apri i dettagli del plugin con il comando di installazione**

35 35>

36Esegui `/plugin install` con il nome del plugin e il marketplace. In una sessione, questo comando non installa subito: apre il pannello `/plugin` sui dettagli di quel plugin in modo che tu possa rivederlo e scegliere prima un ambito.36> Esegui `/plugin install` con il nome del plugin e il marketplace. In una sessione, questo comando non installa subito: apre il pannello `/plugin` sui dettagli di quel plugin in modo che tu possa rivederlo e scegliere prima un ambito.

37 37>

38```text theme={null}38> ```text theme={null}

39/plugin install commit-commands@claude-plugins-official39> /plugin install commit-commands@claude-plugins-official

40```40> ```

41 41>

42Per sfogliare invece, esegui `/plugin` senza un nome di plugin: il pannello si apre sulla scheda **Discover**, che elenca i plugin dai tuoi marketplace, e puoi digitare per cercare, quindi premere **Enter** su un plugin per aprire i suoi dettagli.42> Per sfogliare invece, esegui `/plugin` senza un nome di plugin: il pannello si apre sulla scheda **Discover**, che elenca i plugin dai tuoi marketplace, e puoi digitare per cercare, quindi premere **Enter** su un plugin per aprire i suoi dettagli.

43 43>

44**2. Rivedi cosa aggiunge il plugin**44> **2. Rivedi cosa aggiunge il plugin**

45 45>

46Il riquadro dei dettagli mostra la descrizione del plugin. Può anche mostrare:46> Il riquadro dei dettagli mostra la descrizione del plugin. Può anche mostrare:

47 47>

48* **Will install**: i comandi, gli agents, le skills, gli hooks e i server MCP e LSP che il plugin aggiunge.48> * **Will install**: i comandi, gli agents, le skills, gli hooks e i server MCP e LSP che il plugin aggiunge.

49* **Last updated**: mostrato per un plugin nel marketplace ufficiale di Anthropic.49> * **Last updated**: mostrato per un plugin nel marketplace ufficiale di Anthropic.

50* **Context cost**: per un plugin nel marketplace ufficiale di Anthropic, due stime di token. **Every turn** è quello che il plugin aggiunge a ogni messaggio che invii, e **When invoked** è quello che le sue skills e agents aggiungono una volta che Claude le carica. Le stime appaiono quando apri il plugin nominando il suo marketplace, come fa il comando del passaggio 1, o dalla scheda **Marketplaces**. Il riquadro dei dettagli che raggiungi dall'elenco **Discover** non le mostra.50> * **Context cost**: per un plugin nel marketplace ufficiale di Anthropic, due stime di token. **Every turn** è quello che il plugin aggiunge a ogni messaggio che invii, e **When invoked** è quello che le sue skills e agents aggiungono una volta che Claude le carica. Le stime appaiono quando apri il plugin nominando il suo marketplace, come fa il comando del passaggio 1, o dalla scheda **Marketplaces**. Il riquadro dei dettagli che raggiungi dall'elenco **Discover** non le mostra.

51 51>

52I plugin da un marketplace locale o personalizzato possono mostrare `Components will be discovered at installation` invece.52> I plugin da un marketplace locale o personalizzato possono mostrare `Components will be discovered at installation` invece.

53 53>

54Un plugin può eseguire hooks e server MCP, quindi leggi il riquadro prima di installare. Vedi [Plugin security and trust](https://code.claude.com/docs/it/plugins/security.md).54> Un plugin può eseguire hooks e server MCP, quindi leggi il riquadro prima di installare. Vedi [Plugin security and trust](https://code.claude.com/docs/it/plugins/security.md).

55 55>

56**3. Scegli un ambito**56> **3. Scegli un ambito**

57 57>

58Seleziona una delle tre opzioni di installazione:58> Seleziona una delle tre opzioni di installazione:

59 59>

60* **Install for you (user scope)**: ottieni il plugin in ogni progetto su questa macchina60> * **Install for you (user scope)**: ottieni il plugin in ogni progetto su questa macchina

61* **Install for all collaborators on this repository (project scope)**: è abilitato per tutti coloro che lavorano in questo repository61> * **Install for all collaborators on this repository (project scope)**: è abilitato per tutti coloro che lavorano in questo repository

62* **Install for you, in this repo only (local scope)**: lo ottieni solo in questo repository62> * **Install for you, in this repo only (local scope)**: lo ottieni solo in questo repository

63 63>

64[Scegli un ambito di installazione](#choose-an-install-scope) dice quale file di impostazioni ogni uno scrive e quale si applica quando lo stesso plugin è impostato in più di uno.64> [Scegli un ambito di installazione](#choose-an-install-scope) dice quale file di impostazioni ogni uno scrive e quale si applica quando lo stesso plugin è impostato in più di uno.

65 65>

66Dopo aver selezionato un ambito, Claude Code installa il plugin insieme a tutte le dipendenze che dichiara, quindi stampa un riepilogo dell'installazione.66> Dopo aver selezionato un ambito, Claude Code installa il plugin insieme a tutte le dipendenze che dichiara, quindi stampa un riepilogo dell'installazione.

67 67>

68**4. Leggi il riepilogo dell'installazione**68> **4. Leggi il riepilogo dell'installazione**

69 69>

70L'ultima frase del riepilogo ti dice se il plugin è utilizzabile in questa sessione:70> L'ultima frase del riepilogo ti dice se il plugin è utilizzabile in questa sessione:

71 71>

72* **Active now**: `Plugin is now active.` Non è necessario ricaricare.72> * **Active now**: `Plugin is now active.` Non è necessario ricaricare.

73* **Active, but a server needs setup**: `Plugin is now active.` è seguito da `Its bundled MCP server needs configuration before it can start`. Il [server MCP in bundle](https://code.claude.com/docs/it/plugins/components.md#include-a-packaged-mcpb-server) del plugin non può avviarsi finché non imposti le sue opzioni. Seleziona il plugin sulla scheda **Installed** in `/plugin` e scegli **Configure** per impostare le opzioni del server.73> * **Active, but a server needs setup**: `Plugin is now active.` è seguito da `Its bundled MCP server needs configuration before it can start`. Il [server MCP in bundle](https://code.claude.com/docs/it/plugins/components.md#include-a-packaged-mcpb-server) del plugin non può avviarsi finché non imposti le sue opzioni. Seleziona il plugin sulla scheda **Installed** in `/plugin` e scegli **Configure** per impostare le opzioni del server.

74* **Reload needed**: `Run /reload-plugins to apply.` Il pannello si chiude e Claude Code esegue quel ricaricamento per te. Se il ricaricamento [invaliderebbe la prompt cache](https://code.claude.com/docs/it/prompt-caching.md#enabling-or-disabling-a-plugin), avverte e lascia il plugin in sospeso invece. Esegui `/reload-plugins --force` per attivarlo comunque, il che costa una richiesta non memorizzata nella cache.74> * **Reload needed**: `Run /reload-plugins to apply.` Il pannello si chiude e Claude Code esegue quel ricaricamento per te. Se il ricaricamento [invaliderebbe la prompt cache](https://code.claude.com/docs/it/prompt-caching.md#enabling-or-disabling-a-plugin), avverte e lascia il plugin in sospeso invece. Esegui `/reload-plugins --force` per attivarlo comunque, il che costa una richiesta non memorizzata nella cache.

75* **Load failed**: `The plugin couldn't be loaded`. Apri la scheda **Errors** in `/plugin` per il motivo, quindi vedi [After install: plugin not working](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-installed-but-not-working).75> * **Load failed**: `The plugin couldn't be loaded`. Apri la scheda **Errors** in `/plugin` per il motivo, quindi vedi [After install: plugin not working](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-installed-but-not-working).

76 76>

77**5. Conferma che il plugin funziona**77> **5. Conferma che il plugin funziona**

78 78>

79Digita `/` e cerca le skill del plugin sotto il suo nome, nella forma `/<plugin>:<skill>`. Per `commit-commands`, appare `/commit-commands:commit`. Due altri posti elencano il plugin:79> Digita `/` e cerca le skill del plugin sotto il suo nome, nella forma `/<plugin>:<skill>`. Per `commit-commands`, appare `/commit-commands:commit`. Due altri posti elencano il plugin:

80 80>

81* Apri la scheda **Installed** in `/plugin`, che elenca il plugin con il suo ambito.81> * Apri la scheda **Installed** in `/plugin`, che elenca il plugin con il suo ambito.

82* Nel tuo shell, esegui `claude plugin list`, che stampa lo stesso elenco con le righe `Version`, `Scope` e `Status`.82> * Nel tuo shell, esegui `claude plugin list`, che stampa lo stesso elenco con le righe `Version`, `Scope` e `Status`.

83 83>

84Se `/commit-commands:commit` non appare, vedi [After install: plugin not working](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-installed-but-not-working).84> Se `/commit-commands:commit` non appare, vedi [After install: plugin not working](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugin-installed-but-not-working).

85 85>

86L'installazione da qualsiasi altro marketplace richiede un passaggio extra prima: [aggiungi il marketplace](#add-a-marketplace). Claude Code aggiunge il marketplace ufficiale di Anthropic per te la prima volta che avvii una sessione di terminale interattiva, motivo per cui l'esempio salta quel passaggio. Se hai trovato un plugin su [claude.com/marketplace](https://claude.com/marketplace), il suo pulsante **Claude Code** copia il comando di installazione nella sua [forma shell](#install-from-your-shell), `claude plugin install <name>@claude-plugins-official`.86> L'installazione da qualsiasi altro marketplace richiede un passaggio extra prima: [aggiungi il marketplace](#add-a-marketplace). Claude Code aggiunge il marketplace ufficiale di Anthropic per te la prima volta che avvii una sessione di terminale interattiva, motivo per cui l'esempio salta quel passaggio. Se hai trovato un plugin su [claude.com/marketplace](https://claude.com/marketplace), il suo pulsante **Claude Code** copia il comando di installazione nella sua [forma shell](#install-from-your-shell), `claude plugin install <name>@claude-plugins-official`.

87 

88**Desktop app**

89 

90In una sessione locale o SSH nella scheda **Code** dell'app desktop:

91 

92**1. Apri il browser dei plugin**

93 

94Fai clic sul pulsante **+** accanto alla casella del prompt e seleziona **Add plugins**. Se il menu **+** mostra **Plugins** invece di **Add plugins**, seleziona **Plugins**, quindi **Browse plugins**. Il browser dei plugin si apre con i plugin dai tuoi marketplace.

95 

96**2. Seleziona il plugin**

97 

98Trova `commit-commands` e selezionalo.

99 

100**3. Scegli un ambito**

101 

102Scegli un [ambito](#choose-an-install-scope): il tuo account utente, questo progetto o solo locale.

103 

104Per abilitare, disabilitare o disinstallare un plugin in seguito, vedi [Install plugins in the desktop app](https://code.claude.com/docs/it/desktop.md#install-plugins).

105 

106**VS Code**

107 

108Nel pannello Claude Code in VS Code:

109 

110**1. Apri Manage plugins**

111 

112Digita `/plugins` nella casella del prompt per aprire **Manage plugins**.

113 

114**2. Installa il plugin**

115 

116Sulla scheda **Plugins**, cerca `commit-commands` e fai clic su **Install**. Se la scheda non elenca alcun plugin, aggiungi prima `anthropics/claude-plugins-official` sulla scheda **Marketplaces**.

117 

118**3. Scegli un ambito**

119 

120Scegli un [ambito](#choose-an-install-scope): **Install for you**, **Install for this project** o **Install locally**.

121 

122Le tue modifiche si applicano alle sessioni aperte senza un riavvio. Vedi [Manage plugins in VS Code](https://code.claude.com/docs/it/vs-code.md#manage-plugins).

123 87 

124**Cloud session**88> [tab] Desktop app

89>

90> In una sessione locale o SSH nella scheda **Code** dell'app desktop:

91>

92> **1. Apri il browser dei plugin**

93>

94> Fai clic sul pulsante **+** accanto alla casella del prompt e seleziona **Add plugins**. Se il menu **+** mostra **Plugins** invece di **Add plugins**, seleziona **Plugins**, quindi **Browse plugins**. Il browser dei plugin si apre con i plugin dai tuoi marketplace.

95>

96> **2. Seleziona il plugin**

97>

98> Trova `commit-commands` e selezionalo.

99>

100> **3. Scegli un ambito**

101>

102> Scegli un [ambito](#choose-an-install-scope): il tuo account utente, questo progetto o solo locale.

103>

104> Per abilitare, disabilitare o disinstallare un plugin in seguito, vedi [Install plugins in the desktop app](https://code.claude.com/docs/it/desktop.md#install-plugins).

125 105 

126Una [sessione cloud](https://code.claude.com/docs/it/cloud-environments.md), incluso [il browser su claude.ai/code](https://code.claude.com/docs/it/claude-code-on-the-web.md), non ha un browser dei plugin e non carica i plugin che hai installato sulla tua macchina o quelli che il `.claude/settings.json` del tuo repository attiva. Per i plugin che la tua organizzazione distribuisce attraverso le impostazioni gestite, vedi [Manage plugins for your organization](https://code.claude.com/docs/it/plugins/org.md).106> [tab] VS Code

107>

108> Nel pannello Claude Code in VS Code:

109>

110> **1. Apri Manage plugins**

111>

112> Digita `/plugins` nella casella del prompt per aprire **Manage plugins**.

113>

114> **2. Installa il plugin**

115>

116> Sulla scheda **Plugins**, cerca `commit-commands` e fai clic su **Install**. Se la scheda non elenca alcun plugin, aggiungi prima `anthropics/claude-plugins-official` sulla scheda **Marketplaces**.

117>

118> **3. Scegli un ambito**

119>

120> Scegli un [ambito](#choose-an-install-scope): **Install for you**, **Install for this project** o **Install locally**.

121>

122> Le tue modifiche si applicano alle sessioni aperte senza un riavvio. Vedi [Manage plugins in VS Code](https://code.claude.com/docs/it/vs-code.md#manage-plugins).

127 123 

128Vedi [quali parti della tua configurazione sono disponibili anche in una sessione cloud](https://code.claude.com/docs/it/cloud-environments.md#what-carries-over-from-your-setup) per il resto della tua configurazione.124> [tab] Cloud session

125>

126> Una [sessione cloud](https://code.claude.com/docs/it/cloud-environments.md), incluso [il browser su claude.ai/code](https://code.claude.com/docs/it/claude-code-on-the-web.md), non ha un browser dei plugin e non carica i plugin che hai installato sulla tua macchina o quelli che il `.claude/settings.json` del tuo repository attiva. Per i plugin che la tua organizzazione distribuisce attraverso le impostazioni gestite, vedi [Manage plugins for your organization](https://code.claude.com/docs/it/plugins/org.md).

127>

128> Vedi [quali parti della tua configurazione sono disponibili anche in una sessione cloud](https://code.claude.com/docs/it/cloud-environments.md#what-carries-over-from-your-setup) per il resto della tua configurazione.

129 129 

130### Scegli un ambito di installazione130### Scegli un ambito di installazione

131 131 

Details

116 116 

117### Condivisione dell'utilizzo in `/usage`117### Condivisione dell'utilizzo in `/usage`

118 118 

119Su un piano Pro, Max, Team o Enterprise, la suddivisione `/usage` attribuisce l'utilizzo recente a skills, subagents, plugin e server MCP come quota del totale. Vedi [Using the `/usage` command](https://code.claude.com/docs/it/costs#using-the-/usage-command).119Su un piano Pro, Max, Ultra, Team o Enterprise, la suddivisione `/usage` attribuisce l'utilizzo recente a skill, subagent, plugin e server MCP come quota del totale. Vedi [Using the `/usage` command](https://code.claude.com/docs/it/costs#using-the-/usage-command).

120 120 

121## Misurare su una flotta121## Misurare su una flotta

122 122 

Details

92 92 

93Crea le due directory che contengono i file:93Crea le due directory che contengono i file:

94 94 

95**Bash o Zsh**95> [tab] Bash o Zsh

96 96>

97```bash theme={null}97> ```bash theme={null}

98mkdir -p first-mod/.claude-plugin first-mod/hooks98> mkdir -p first-mod/.claude-plugin first-mod/hooks

99```99> ```

100 

101**PowerShell**

102 100 

103```powershell theme={null}101> [tab] PowerShell

104New-Item -ItemType Directory -Force first-mod\.claude-plugin, first-mod\hooks102>

105```103> ```powershell theme={null}

104> New-Item -ItemType Directory -Force first-mod\.claude-plugin, first-mod\hooks

105> ```

106 106 

107**2. Scrivi il manifest**107**2. Scrivi il manifest**

108 108 

Details

181 181 

182Il pannello e la fascia sono vuoti finché un mod non li riempie. Seleziona una scheda per vedere che cos'è ciascuno e come disegnarci dentro:182Il pannello e la fascia sono vuoti finché un mod non li riempie. Seleziona una scheda per vedere che cos'è ciascuno e come disegnarci dentro:

183 183 

184**Pannello**184> [tab] Pannello

185 185>

186Un pannello è una barra laterale accanto alla trascrizione in un terminale a schermo intero ampio, oppure, negli altri casi, un'area incorniciata sopra il prompt. Con più pannelli aperti, ognuno ha una scheda che ne mostra il titolo.186> Un pannello è una barra laterale accanto alla trascrizione in un terminale a schermo intero ampio, oppure, negli altri casi, un'area incorniciata sopra il prompt. Con più pannelli aperti, ognuno ha una scheda che ne mostra il titolo.

187 187>

188Un pannello appare quando il tuo mod chiama `$.ui.open` con un `id` che scegli tu, come in `$.ui.open({ id: 'hello-tabs' })`. [Apri un pannello al momento giusto](#open-a-pane-at-the-right-time) descrive gli altri campi e quando un pannello attende un terminale più ampio.188> Un pannello appare quando il tuo mod chiama `$.ui.open` con un `id` che scegli tu, come in `$.ui.open({ id: 'hello-tabs' })`. [Apri un pannello al momento giusto](#open-a-pane-at-the-right-time) descrive gli altri campi e quando un pannello attende un terminale più ampio.

189 189>

190Per disegnare nel tuo pannello, filtra su `{ component: 'Pane' }` e verifica che `e.requestId` sia il tuo `id`.190> Per disegnare nel tuo pannello, filtra su `{ component: 'Pane' }` e verifica che `e.requestId` sia il tuo `id`.

191 

192**Fascia sopra il prompt**

193 

194La fascia è una striscia direttamente sopra il campo di input del prompt. È sempre presente e tutti i mod la condividono.

195 

196Il tuo hook restituisce un albero per mostrare qualcosa nella fascia, oppure `next(e)` per non mostrare nulla. Un albero sostituisce ciò che i mod [dopo il tuo](https://code.claude.com/docs/it/plugins/mods/events.md#the-order-mods-run-in) disegnano lì. Per mantenere ciò che disegnano loro, inserisci il risultato di `await next(e)` tra i figli di un [`Box`](#build-a-tree-from-elements) nel tuo albero.

197 191 

198Per disegnare nella fascia, filtra su `{ component: 'AbovePrompt' }`.192> [tab] Fascia sopra il prompt

193>

194> La fascia è una striscia direttamente sopra il campo di input del prompt. È sempre presente e tutti i mod la condividono.

195>

196> Il tuo hook restituisce un albero per mostrare qualcosa nella fascia, oppure `next(e)` per non mostrare nulla. Un albero sostituisce ciò che i mod [dopo il tuo](https://code.claude.com/docs/it/plugins/mods/events.md#the-order-mods-run-in) disegnano lì. Per mantenere ciò che disegnano loro, inserisci il risultato di `await next(e)` tra i figli di un [`Box`](#build-a-tree-from-elements) nel tuo albero.

197>

198> Per disegnare nella fascia, filtra su `{ component: 'AbovePrompt' }`.

199 199 

200### Modifica ciò che Claude Code disegna già200### Modifica ciò che Claude Code disegna già

201 201 

214 214 

215In un punto che Claude Code disegna già, il tuo hook può modificare un dettaglio, sostituire il disegno o lasciarlo invariato. Seleziona una scheda per vedere ciascuna opzione applicata allo spinner. Gli esempi leggono una variabile `calls` conteggiata da un altro hook, come nel [mod del tutorial](https://code.claude.com/docs/it/plugins/mods/create.md#write-a-mod-yourself).215In un punto che Claude Code disegna già, il tuo hook può modificare un dettaglio, sostituire il disegno o lasciarlo invariato. Seleziona una scheda per vedere ciascuna opzione applicata allo spinner. Gli esempi leggono una variabile `calls` conteggiata da un altro hook, come nel [mod del tutorial](https://code.claude.com/docs/it/plugins/mods/create.md#write-a-mod-yourself).

216 216 

217**Modifica un dettaglio**217> [tab] Modifica un dettaglio

218 218>

219Per mantenere il disegno di Claude Code e modificarne una parte, passa a `next` una copia dell'evento con `props` modificate. Questo hook modifica il testo dopo la parola dello spinner:219> Per mantenere il disegno di Claude Code e modificarne una parte, passa a `next` una copia dell'evento con `props` modificate. Questo hook modifica il testo dopo la parola dello spinner:

220 220>

221```javascript theme={null}221> ```javascript theme={null}

222on('ui.render', { component: 'Spinner' }, async ($, e, next) => {222> on('ui.render', { component: 'Spinner' }, async ($, e, next) => {

223 // Keep Claude Code's spinner, and change the text after its word223> // Keep Claude Code's spinner, and change the text after its word

224 return next({ ...e, props: { ...e.props, suffix: ' · tool calls: ' + calls + '…' } })224> return next({ ...e, props: { ...e.props, suffix: ' · tool calls: ' + calls + '…' } })

225})225> })

226```226> ```

227 227>

228Lo spinner mantiene la sua animazione e la sua parola, e il tuo testo segue la parola:228> Lo spinner mantiene la sua animazione e la sua parola, e il tuo testo segue la parola:

229 229>

230```text theme={null}230> ```text theme={null}

231Thinking · tool calls: 2…231> Thinking · tool calls: 2…

232```232> ```

233 

234**Sostituisci il disegno**

235 

236Per disegnare qualcosa di tuo al posto del punto, restituisci un albero e non chiamare `next`. Questo hook disegna una riga di testo dove si troverebbe lo spinner:

237 

238```javascript theme={null}

239on('ui.render', { component: 'Spinner' }, async ($, e) => {

240 const { Text } = $.ui.resolve(e)

241 // No call to next, so this line is drawn in the spinner's place

242 return Text({ children: ['Claude has made ' + calls + ' tool calls'] })

243})

244```

245 

246Mentre Claude lavora, viene mostrata la tua riga e non lo spinner di Claude Code:

247 

248```text theme={null}

249Claude has made 2 tool calls

250```

251 

252**Lascialo invariato**

253 

254Per lasciare il punto così come lo disegna Claude Code, restituisci `next(e)`. Spesso un hook lo fa per alcuni eventi e non per altri. Questo hook lascia invariato lo spinner finché non c'è una chiamata da contare:

255 

256```javascript theme={null}

257on('ui.render', { component: 'Spinner' }, async ($, e, next) => {

258 // Nothing to show yet, so pass the event on unchanged

259 if (calls === 0) return next(e)

260 return next({ ...e, props: { ...e.props, suffix: ' · tool calls: ' + calls + '…' } })

261})

262```

263 233 

264Prima della prima chiamata a uno strumento, lo spinner appare come senza il mod:234> [tab] Sostituisci il disegno

235>

236> Per disegnare qualcosa di tuo al posto del punto, restituisci un albero e non chiamare `next`. Questo hook disegna una riga di testo dove si troverebbe lo spinner:

237>

238> ```javascript theme={null}

239> on('ui.render', { component: 'Spinner' }, async ($, e) => {

240> const { Text } = $.ui.resolve(e)

241> // No call to next, so this line is drawn in the spinner's place

242> return Text({ children: ['Claude has made ' + calls + ' tool calls'] })

243> })

244> ```

245>

246> Mentre Claude lavora, viene mostrata la tua riga e non lo spinner di Claude Code:

247>

248> ```text theme={null}

249> Claude has made 2 tool calls

250> ```

265 251 

266```text theme={null}252> [tab] Lascialo invariato

267Thinking…253>

268```254> Per lasciare il punto così come lo disegna Claude Code, restituisci `next(e)`. Spesso un hook lo fa per alcuni eventi e non per altri. Questo hook lascia invariato lo spinner finché non c'è una chiamata da contare:

255>

256> ```javascript theme={null}

257> on('ui.render', { component: 'Spinner' }, async ($, e, next) => {

258> // Nothing to show yet, so pass the event on unchanged

259> if (calls === 0) return next(e)

260> return next({ ...e, props: { ...e.props, suffix: ' · tool calls: ' + calls + '…' } })

261> })

262> ```

263>

264> Prima della prima chiamata a uno strumento, lo spinner appare come senza il mod:

265>

266> ```text theme={null}

267> Thinking…

268> ```

269 269 

270In questi punti, `next(e)` restituisce un riferimento al disegno di Claude Code, `{ type: 'engine', ref }`, a meno che un mod eseguito dopo il tuo non abbia restituito un proprio albero. Per modificare il contenuto di quel disegno, passa a `next` una copia dell'evento con prop diverse, come fa la scheda **Modifica un dettaglio**. Puoi restituire il riferimento così com'è, oppure inserirlo in un `Box` accanto a elementi tuoi:270In questi punti, `next(e)` restituisce un riferimento al disegno di Claude Code, `{ type: 'engine', ref }`, a meno che un mod eseguito dopo il tuo non abbia restituito un proprio albero. Per modificare il contenuto di quel disegno, passa a `next` una copia dell'evento con prop diverse, come fa la scheda **Modifica un dettaglio**. Puoi restituire il riferimento così com'è, oppure inserirlo in un `Box` accanto a elementi tuoi:

271 271 

357 357 

358Seleziona una scheda per vedere ciascuno degli elementi più comuni e come il terminale lo disegna:358Seleziona una scheda per vedere ciascuno degli elementi più comuni e come il terminale lo disegna:

359 359 

360**Text**360> [tab] Text

361 361>

362`Text` disegna una stringa, con uno stile facoltativo come `bold` e `color`:362> `Text` disegna una stringa, con uno stile facoltativo come `bold` e `color`:

363 363>

364```javascript theme={null}364> ```javascript theme={null}

365Text({ children: ['This is the first tab.'] })365> Text({ children: ['This is the first tab.'] })

366```366> ```

367 367>

368```text theme={null}368> ```text theme={null}

369This is the first tab.369> This is the first tab.

370```370> ```

371 

372**Box**

373 

374`Box` dispone ciò che contiene, in una riga o in una colonna. Questo mette un pulsante e una riga di testo uno accanto all'altro, a due colonne di distanza:

375 

376```javascript theme={null}

377Box({

378 flexDirection: 'row',

379 columnGap: 2,

380 children: [

381 Button({ key: 'more', label: 'Add one', onPress: addOne }),

382 Text({ children: ['Count: 0'] }),

383 ],

384})

385```

386 

387```text theme={null}

388[ Add one ] Count: 0

389```

390 

391**Button**

392 

393`Button` è un controllo che l'utente può premere. Esegue la tua callback `onPress`. Con `plain: true` non ha parentesi e mostra il suo tasto di scelta rapida:

394 

395```javascript theme={null}

396Button({ key: 'more', label: 'Add one', onPress: addOne })

397Button({ key: 'tab-one', label: 'One', hotkey: '1', plain: true, onPress: showTabOne })

398```

399 

400```text theme={null}

401[ Add one ]

4021: One

403```

404 

405**Input**

406 

407`Input` è un campo di testo. Esegue la tua callback `onSubmit` con il testo quando l'utente preme Enter:

408 371 

409```javascript theme={null}372> [tab] Box

410Input({373>

411 key: 'new-note',374> `Box` dispone ciò che contiene, in una riga o in una colonna. Questo mette un pulsante e una riga di testo uno accanto all'altro, a due colonne di distanza:

412 label: 'Note',375>

413 placeholder: 'Type a note and press Enter',376> ```javascript theme={null}

414 value: '',377> Box({

415 submitLabel: 'add',378> flexDirection: 'row',

416 onSubmit: addNote,379> columnGap: 2,

417})380> children: [

418```381> Button({ key: 'more', label: 'Add one', onPress: addOne }),

382> Text({ children: ['Count: 0'] }),

383> ],

384> })

385> ```

386>

387> ```text theme={null}

388> [ Add one ] Count: 0

389> ```

419 390 

420```text theme={null}391> [tab] Button

421Note: Type a note and press Enter392>

422```393> `Button` è un controllo che l'utente può premere. Esegue la tua callback `onPress`. Con `plain: true` non ha parentesi e mostra il suo tasto di scelta rapida:

394>

395> ```javascript theme={null}

396> Button({ key: 'more', label: 'Add one', onPress: addOne })

397> Button({ key: 'tab-one', label: 'One', hotkey: '1', plain: true, onPress: showTabOne })

398> ```

399>

400> ```text theme={null}

401> [ Add one ]

402> 1: One

403> ```

423 404 

424Imposta `rows` a 2 o più per [un campo che contiene più righe](https://code.claude.com/docs/it/plugins/mods/gallery.md#input).405> [tab] Input

406>

407> `Input` è un campo di testo. Esegue la tua callback `onSubmit` con il testo quando l'utente preme Enter:

408>

409> ```javascript theme={null}

410> Input({

411> key: 'new-note',

412> label: 'Note',

413> placeholder: 'Type a note and press Enter',

414> value: '',

415> submitLabel: 'add',

416> onSubmit: addNote,

417> })

418> ```

419>

420> ```text theme={null}

421> Note: Type a note and press Enter

422> ```

423>

424> Imposta `rows` a 2 o più per [un campo che contiene più righe](https://code.claude.com/docs/it/plugins/mods/gallery.md#input).

425 425 

426La [galleria dell'interfaccia](https://code.claude.com/docs/it/plugins/mods/gallery.md) contiene esempi e screenshot della maggior parte degli elementi. Questa tabella elenca tutti gli elementi:426La [galleria dell'interfaccia](https://code.claude.com/docs/it/plugins/mods/gallery.md) contiene esempi e screenshot della maggior parte degli elementi. Questa tabella elenca tutti gli elementi:

427 427 

Details

132 132 

133**1. Conferma che puoi inviare**133**1. Conferma che puoi inviare**

134 134 

135L'invio richiede un piano claude.ai a pagamento. Su Pro e Max invii dal tuo account personale. Su Team e Enterprise, un Proprietario può inviare, e su Enterprise un Proprietario può anche concedere il permesso **Directory** ad altri membri attraverso un ruolo personalizzato in **Impostazioni organizzazione > Ruoli**. Vedi [Conferma che puoi inviare alla directory](https://claude.com/docs/directory/publish#confirm-you-can-submit-to-the-directory).135L'invio richiede un piano claude.ai a pagamento. Su Pro, Max e Ultra invii dal tuo account personale. Su Team e Enterprise, un Proprietario può inviare, e su Enterprise un Proprietario può anche concedere il permesso **Directory** ad altri membri attraverso un ruolo personalizzato in **Impostazioni organizzazione > Ruoli**. Vedi [Conferma che puoi inviare alla directory](https://claude.com/docs/directory/publish#confirm-you-can-submit-to-the-directory).

136 136 

137**2. Convalida il plugin localmente**137**2. Convalida il plugin localmente**

138 138 

Details

302 302 

303La clonazione di un marketplace e la re-clonazione per aggiornarlo ottiene 120 secondi per impostazione predefinita. Per un repository di grandi dimensioni o una connessione lenta, aumentare il limite. Il valore è in millisecondi:303La clonazione di un marketplace e la re-clonazione per aggiornarlo ottiene 120 secondi per impostazione predefinita. Per un repository di grandi dimensioni o una connessione lenta, aumentare il limite. Il valore è in millisecondi:

304 304 

305**Bash or Zsh**305> [tab] Bash or Zsh

306 306>

307```bash theme={null}307> ```bash theme={null}

308export CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=300000308> export CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS=300000

309```309> ```

310 

311**PowerShell**

312 310 

313```powershell theme={null}311> [tab] PowerShell

314$env:CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS = "300000"312>

315```313> ```powershell theme={null}

314> $env:CLAUDE_CODE_PLUGIN_GIT_TIMEOUT_MS = "300000"

315> ```

316 316 

317Quindi riprovare nella stessa shell.317Quindi riprovare nella stessa shell.

318 318 

328 328 

329Impostare questa variabile per saltare il tentativo di re-clone e continuare a utilizzare il checkout esistente quando il controllo non può raggiungere l'host:329Impostare questa variabile per saltare il tentativo di re-clone e continuare a utilizzare il checkout esistente quando il controllo non può raggiungere l'host:

330 330 

331**Bash or Zsh**331> [tab] Bash or Zsh

332 332>

333```bash theme={null}333> ```bash theme={null}

334export CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1334> export CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE=1

335```335> ```

336 

337**PowerShell**

338 336 

339```powershell theme={null}337> [tab] PowerShell

340$env:CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE = "1"338>

341```339> ```powershell theme={null}

340> $env:CLAUDE_CODE_PLUGIN_KEEP_MARKETPLACE_ON_FAILURE = "1"

341> ```

342 342 

343Con la variabile impostata, Claude Code salta il re-clone solo per un checkout che contiene già `.claude-plugin/marketplace.json`. Un marketplace che non è mai stato clonato o il cui clone si è fermato a metà ottiene comunque il tentativo di clone, quindi aggiungerlo una volta mentre online.343Con la variabile impostata, Claude Code salta il re-clone solo per un checkout che contiene già `.claude-plugin/marketplace.json`. Un marketplace che non è mai stato clonato o il cui clone si è fermato a metà ottiene comunque il tentativo di clone, quindi aggiungerlo una volta mentre online.

344 344 

quickstart.md +56 −56

Details

14 14 

15* Un terminale o un prompt dei comandi aperto15* Un terminale o un prompt dei comandi aperto

16* Un progetto di codice con cui lavorare16* Un progetto di codice con cui lavorare

17* Un [abbonamento Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Team o Enterprise), un account [Claude Console](https://platform.claude.com/) o accesso tramite un [provider cloud supportato](https://code.claude.com/docs/it/third-party-integrations.md)17* Un [abbonamento Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Ultra, Team o Enterprise), un account [Claude Console](https://platform.claude.com/) o accesso tramite un [provider cloud supportato](https://code.claude.com/docs/it/third-party-integrations.md)

18 18 

19> [!NOTE]19> [!NOTE]

20>20>

27 27 

28Per installare Claude Code, apri un terminale ed esegui il comando per il tuo sistema. Se non hai mai utilizzato un terminale prima, la [guida al terminale](https://code.claude.com/docs/it/terminal-guide) mostra come aprirne uno e incollare il comando.28Per installare Claude Code, apri un terminale ed esegui il comando per il tuo sistema. Se non hai mai utilizzato un terminale prima, la [guida al terminale](https://code.claude.com/docs/it/terminal-guide) mostra come aprirne uno e incollare il comando.

29 29 

30**Installazione nativa (consigliata)**30> [tab] Installazione nativa (consigliata)

31 

32**macOS, Linux, WSL:**

33 

34```bash theme={null}

35curl -fsSL https://claude.ai/install.sh | bash

36```

37 

38Su Windows, il tuo prompt mostra `PS C:\` quando sei in PowerShell e `C:\` senza il `PS` quando sei in CMD.

39 

40**Windows PowerShell:**

41 

42```powershell theme={null}

43irm https://claude.ai/install.ps1 | iex

44```

45 

46**Windows CMD:**

47 

48```batch theme={null}

49curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

50```

51 

52Il comando di installazione non mostra alcun avanzamento mentre scarica Claude Code. Quando il programma di installazione termina, apri una nuova finestra del terminale ed esegui `claude --version`. Un'installazione funzionante stampa un numero di versione. Se la tua shell dice che `claude` non è trovato o non è riconosciuto, la directory di installazione non è ancora nel tuo PATH: vedi [Correggi il tuo PATH](https://code.claude.com/docs/it/troubleshoot-install.md#command-not-found-claude-after-installation).

53 

54Se vedi `The token '&&' is not a valid statement separator`, sei in PowerShell, non in CMD. Se vedi `'irm' is not recognized as an internal or external command`, sei in CMD, non in PowerShell.

55 

56Se il comando di installazione non riesce con `syntax error near unexpected token '<'`, un `403` o qualsiasi altro errore, consulta [Risoluzione dei problemi di installazione](https://code.claude.com/docs/it/troubleshoot-install.md#find-your-error) per abbinare l'errore a una soluzione e per metodi di installazione alternativi.

57 

58[Git for Windows](https://git-scm.com/downloads/win) è consigliato su Windows nativo in modo che Claude Code possa utilizzare lo strumento Bash. Se Git for Windows non è installato, Claude Code utilizza PowerShell come strumento shell. Le configurazioni WSL non necessitano di Git for Windows.

59 

60> [!NOTE]

61>31>

62> Le installazioni native si aggiornano automaticamente in background per mantenerti sulla versione più recente.32> **macOS, Linux, WSL:**

63 

64**Homebrew**

65 

66```bash theme={null}

67brew install --cask claude-code

68```

69 

70Homebrew offre due cask. `claude-code` traccia il canale di rilascio stabile, che in genere è circa una settimana indietro e salta i rilasci con regressioni importanti. `claude-code@latest` traccia il canale più recente e riceve nuove versioni non appena vengono rilasciate.

71 

72> [!NOTE]

73>33>

74> Le installazioni Homebrew non si aggiornano automaticamente. Esegui `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask hai installato, per ottenere le funzionalità più recenti e le correzioni di sicurezza.34> ```bash theme={null}

75 35> curl -fsSL https://claude.ai/install.sh | bash

76**WinGet**36> ```

37>

38> Su Windows, il tuo prompt mostra `PS C:\` quando sei in PowerShell e `C:\` senza il `PS` quando sei in CMD.

39>

40> **Windows PowerShell:**

41>

42> ```powershell theme={null}

43> irm https://claude.ai/install.ps1 | iex

44> ```

45>

46> **Windows CMD:**

47>

48> ```batch theme={null}

49> curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

50> ```

51>

52> Il comando di installazione non mostra alcun avanzamento mentre scarica Claude Code. Quando il programma di installazione termina, apri una nuova finestra del terminale ed esegui `claude --version`. Un'installazione funzionante stampa un numero di versione. Se la tua shell dice che `claude` non è trovato o non è riconosciuto, la directory di installazione non è ancora nel tuo PATH: vedi [Correggi il tuo PATH](https://code.claude.com/docs/it/troubleshoot-install.md#command-not-found-claude-after-installation).

53>

54> Se vedi `The token '&&' is not a valid statement separator`, sei in PowerShell, non in CMD. Se vedi `'irm' is not recognized as an internal or external command`, sei in CMD, non in PowerShell.

55>

56> Se il comando di installazione non riesce con `syntax error near unexpected token '<'`, un `403` o qualsiasi altro errore, consulta [Risoluzione dei problemi di installazione](https://code.claude.com/docs/it/troubleshoot-install.md#find-your-error) per abbinare l'errore a una soluzione e per metodi di installazione alternativi.

57>

58> [Git for Windows](https://git-scm.com/downloads/win) è consigliato su Windows nativo in modo che Claude Code possa utilizzare lo strumento Bash. Se Git for Windows non è installato, Claude Code utilizza PowerShell come strumento shell. Le configurazioni WSL non necessitano di Git for Windows.

59>

60> > [!NOTE]

61> >

62> > Le installazioni native si aggiornano automaticamente in background per mantenerti sulla versione più recente.

77 63 

78```powershell theme={null}64> [tab] Homebrew

79winget install Anthropic.ClaudeCode65>

80```66> ```bash theme={null}

67> brew install --cask claude-code

68> ```

69>

70> Homebrew offre due cask. `claude-code` traccia il canale di rilascio stabile, che in genere è circa una settimana indietro e salta i rilasci con regressioni importanti. `claude-code@latest` traccia il canale più recente e riceve nuove versioni non appena vengono rilasciate.

71>

72> > [!NOTE]

73> >

74> > Le installazioni Homebrew non si aggiornano automaticamente. Esegui `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask hai installato, per ottenere le funzionalità più recenti e le correzioni di sicurezza.

81 75 

82> [!NOTE]76> [tab] WinGet

77>

78> ```powershell theme={null}

79> winget install Anthropic.ClaudeCode

80> ```

83>81>

84> Le installazioni WinGet non si aggiornano automaticamente. Esegui `winget upgrade Anthropic.ClaudeCode` periodicamente per ottenere le funzionalità più recenti e le correzioni di sicurezza.82> > [!NOTE]

83> >

84> > Le installazioni WinGet non si aggiornano automaticamente. Esegui `winget upgrade Anthropic.ClaudeCode` periodicamente per ottenere le funzionalità più recenti e le correzioni di sicurezza.

85 85 

86Puoi anche installare con [apt, dnf, o apk](https://code.claude.com/docs/it/setup.md#install-with-linux-package-managers) su Debian, Fedora, RHEL e Alpine.86Puoi anche installare con [apt, dnf, o apk](https://code.claude.com/docs/it/setup.md#install-with-linux-package-managers) su Debian, Fedora, RHEL e Alpine.

87 87 

108 108 

109Puoi accedere con uno qualsiasi di questi tipi di account:109Puoi accedere con uno qualsiasi di questi tipi di account:

110 110 

111* [Claude Pro, Max, Team o Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_login) (consigliato)111* [Claude Pro, Max, Ultra, Team o Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_login) (consigliato)

112* [Claude Console](https://platform.claude.com/) (accesso API con crediti prepagati). Al primo accesso, viene creato automaticamente un workspace "Claude Code" nella Console per il monitoraggio centralizzato dei costi.112* [Claude Console](https://platform.claude.com/) (accesso API con crediti prepagati). Al primo accesso, viene creato automaticamente un workspace "Claude Code" nella Console per il monitoraggio centralizzato dei costi.

113* [Amazon Bedrock, Agent Platform di Google Cloud o Microsoft Foundry](https://code.claude.com/docs/it/third-party-integrations.md) (provider cloud aziendali)113* [Amazon Bedrock, Agent Platform di Google Cloud o Microsoft Foundry](https://code.claude.com/docs/it/third-party-integrations.md) (provider cloud aziendali)

114* Un [gateway delle app Claude](https://code.claude.com/docs/it/claude-apps-gateway) self-hosted, se la tua organizzazione ne gestisce uno: il tuo amministratore preconfigura l'URL del gateway e `/login` si apre direttamente sulla schermata **Cloud gateway** per consentirti di accedere con l'SSO aziendale114* Un [gateway delle app Claude](https://code.claude.com/docs/it/claude-apps-gateway) self-hosted, se la tua organizzazione ne gestisce uno: il tuo amministratore preconfigura l'URL del gateway e `/login` si apre direttamente sulla schermata **Cloud gateway** per consentirti di accedere con l'SSO aziendale

267 267 

268Per ulteriori informazioni, vedi [best practices](https://code.claude.com/docs/it/best-practices.md) e [flussi di lavoro comuni](https://code.claude.com/docs/it/common-workflows.md).268Per ulteriori informazioni, vedi [best practices](https://code.claude.com/docs/it/best-practices.md) e [flussi di lavoro comuni](https://code.claude.com/docs/it/common-workflows.md).

269 269 

270> **Sii specifico con le tue richieste**270> [accordion] Sii specifico con le tue richieste

271>271>

272> Invece di: "correggi il bug"272> Invece di: "correggi il bug"

273>273>

274> Prova: "correggi il bug di accesso in cui gli utenti vedono una schermata vuota dopo aver inserito credenziali errate"274> Prova: "correggi il bug di accesso in cui gli utenti vedono una schermata vuota dopo aver inserito credenziali errate"

275 275 

276> **Usa istruzioni passo dopo passo**276> [accordion] Usa istruzioni passo dopo passo

277>277>

278> Suddividi i compiti complessi in passaggi:278> Suddividi i compiti complessi in passaggi:

279>279>

283> 3. costruisci una pagina web che consenta agli utenti di visualizzare e modificare le loro informazioni283> 3. costruisci una pagina web che consenta agli utenti di visualizzare e modificare le loro informazioni

284> ```284> ```

285 285 

286> **Lascia che Claude esplori prima**286> [accordion] Lascia che Claude esplori prima

287>287>

288> Prima di apportare modifiche, lascia che Claude comprenda il tuo codice:288> Prima di apportare modifiche, lascia che Claude comprenda il tuo codice:

289>289>

295> costruisci una dashboard che mostra i prodotti che vengono restituiti più frequentemente dai nostri clienti nel Regno Unito295> costruisci una dashboard che mostra i prodotti che vengono restituiti più frequentemente dai nostri clienti nel Regno Unito

296> ```296> ```

297 297 

298> **Risparmia tempo con le scorciatoie**298> [accordion] Risparmia tempo con le scorciatoie

299>299>

300> * Digita `/` per vedere tutti i comandi e le skills disponibili300> * Digita `/` per vedere tutti i comandi e le skills disponibili

301> * Usa Tab per il completamento dei comandi301> * Usa Tab per il completamento dei comandi

remote-control.md +97 −97

Details

25 25 

26Prima di utilizzare Remote Control, conferma che il tuo ambiente soddisfi queste condizioni:26Prima di utilizzare Remote Control, conferma che il tuo ambiente soddisfi queste condizioni:

27 27 

28* **Abbonamento**: disponibile su piani Pro, Max, Team e Enterprise. Le chiavi API non sono supportate. Su Team e Enterprise, un proprietario deve prima abilitare l'interruttore Remote Control nelle [impostazioni di amministrazione di Claude Code](https://claude.ai/admin-settings/claude-code).28* **Abbonamento**: disponibile su piani Pro, Max, Ultra, Team e Enterprise. Le chiavi API non sono supportate. Su Team e Enterprise, un Owner deve prima abilitare l'interruttore Remote Control nelle [impostazioni di amministrazione di Claude Code](https://claude.ai/admin-settings/claude-code).

29* **Ruoli personalizzati**: se la tua organizzazione Enterprise gestisce il tuo accesso con [ruoli personalizzati](https://support.claude.com/en/articles/13930452), i tuoi ruoli devono concederti sia il permesso per le sessioni cloud sia il permesso **Claude Code remote control**. Se manca uno dei due, l'avvio di Remote Control mostra [`Remote Control is disabled by your organization's policy`](#remote-control-is-disabled-by-your-organizations-policy). Chiedi a un Owner di verificare i tuoi ruoli e di aggiungere ciò che manca in [**Organization settings > Roles**](https://claude.ai/admin-settings/roles).29* **Ruoli personalizzati**: se la tua organizzazione Enterprise gestisce il tuo accesso con [ruoli personalizzati](https://support.claude.com/en/articles/13930452), i tuoi ruoli devono concederti sia il permesso per le sessioni cloud sia il permesso **Claude Code remote control**. Se manca uno dei due, l'avvio di Remote Control mostra [`Remote Control is disabled by your organization's policy`](#remote-control-is-disabled-by-your-organizations-policy). Chiedi a un Owner di verificare i tuoi ruoli e di aggiungere ciò che manca in [**Organization settings > Roles**](https://claude.ai/admin-settings/roles).

30* **Autenticazione**: esegui `claude` e utilizza `/login` per accedere tramite claude.ai se non l'hai già fatto. Senza un accesso idoneo, `claude remote-control` esce con un errore, mentre `claude --remote-control` avvia comunque una sessione interattiva e mostra una notifica di errore di Remote Control poco dopo l'avvio.30* **Autenticazione**: esegui `claude` e utilizza `/login` per accedere tramite claude.ai se non l'hai già fatto. Senza un accesso idoneo, `claude remote-control` esce con un errore, mentre `claude --remote-control` avvia comunque una sessione interattiva e mostra una notifica di errore di Remote Control poco dopo l'avvio.

31* **Endpoint API**: non disponibile in nessuna di queste configurazioni:31* **Endpoint API**: non disponibile in nessuna di queste configurazioni:

41 41 

42È possibile avviare una sessione Remote Control dalla CLI, dall'[app Claude Desktop](https://code.claude.com/docs/it/desktop.md) o dall'estensione VS Code. La CLI offre tre modalità di invocazione; l'app Desktop e VS Code utilizzano il comando `/remote-control`.42È possibile avviare una sessione Remote Control dalla CLI, dall'[app Claude Desktop](https://code.claude.com/docs/it/desktop.md) o dall'estensione VS Code. La CLI offre tre modalità di invocazione; l'app Desktop e VS Code utilizzano il comando `/remote-control`.

43 43 

44**Modalità server**44> [tab] Modalità server

45 45>

46Nella directory del progetto, eseguire:46> Nella directory del progetto, eseguire:

47 47>

48```bash theme={null}48> ```bash theme={null}

49claude remote-control49> claude remote-control

50```50> ```

51 51>

52Fino a quando non si accetta la conferma una tantum di Remote Control, `claude remote-control` spiega cosa fa e chiede `Enable Remote Control? (y/n)` prima di avviare il server. Rispondere `y` per accettare e avviare il server. Se si rifiuta, Claude Code esce senza avviare il server e chiede di nuovo la prossima volta che si esegue il comando.52> Fino a quando non si accetta la conferma una tantum di Remote Control, `claude remote-control` spiega cosa fa e chiede `Enable Remote Control? (y/n)` prima di avviare il server. Rispondere `y` per accettare e avviare il server. Se si rifiuta, Claude Code esce senza avviare il server e chiede di nuovo la prossima volta che si esegue il comando.

53 53>

54Il processo rimane in esecuzione nel terminale in modalità server, in attesa di connessioni remote. Visualizza un URL di sessione che è possibile utilizzare per [connettersi da un altro dispositivo](#connect-from-another-device), e si può premere la barra spaziatrice per visualizzare un codice QR per un accesso rapido dal telefono. Mentre una sessione remota è attiva, il terminale mostra lo stato della connessione e l'attività degli strumenti.54> Il processo rimane in esecuzione nel terminale in modalità server, in attesa di connessioni remote. Visualizza un URL di sessione che è possibile utilizzare per [connettersi da un altro dispositivo](#connect-from-another-device), e si può premere la barra spaziatrice per visualizzare un codice QR per un accesso rapido dal telefono. Mentre una sessione remota è attiva, il terminale mostra lo stato della connessione e l'attività degli strumenti.

55 55>

56Passare uno qualsiasi di questi flag dopo `remote-control`:56> Passare uno qualsiasi di questi flag dopo `remote-control`:

57 57>

58| Flag | Descrizione |58> | Flag | Descrizione |

59| - | - |59> | - | - |

60| `--name "My Project"` | Imposta un titolo di sessione personalizzato visibile nell'elenco delle sessioni su claude.ai/code. |60> | `--name "My Project"` | Imposta un titolo di sessione personalizzato visibile nell'elenco delle sessioni su claude.ai/code. |

61| `--remote-control-session-name-prefix <prefix>` | Prefisso per i nomi di sessione generati automaticamente quando non è impostato un nome esplicito. Per impostazione predefinita, il nome host della macchina, producendo nomi come `myhost-graceful-unicorn`. Impostare `CLAUDE_REMOTE_CONTROL_SESSION_NAME_PREFIX` per lo stesso effetto. |61> | `--remote-control-session-name-prefix <prefix>` | Prefisso per i nomi di sessione generati automaticamente quando non è impostato un nome esplicito. Per impostazione predefinita, il nome host della macchina, producendo nomi come `myhost-graceful-unicorn`. Impostare `CLAUDE_REMOTE_CONTROL_SESSION_NAME_PREFIX` per lo stesso effetto. |

62| `-c`, `--continue` | Ripristina la sessione che l'ultimo server in questa directory ha avviato, invece di crearne una nuova. Vedere [Riprendere le sessioni dopo l'arresto del server](#resume-sessions-after-stopping-the-server). Non può essere combinato con `--session-id`, `--spawn`, `--capacity` o `--create-session-in-dir`. Richiede Claude Code v2.1.200 o successivo. |62> | `-c`, `--continue` | Ripristina la sessione che l'ultimo server in questa directory ha avviato, invece di crearne una nuova. Vedere [Riprendere le sessioni dopo l'arresto del server](#resume-sessions-after-stopping-the-server). Non può essere combinato con `--session-id`, `--spawn`, `--capacity` o `--create-session-in-dir`. Richiede Claude Code v2.1.200 o successivo. |

63| `--session-id <id>` | Ripristina una sessione in base al suo ID. Vedere [Riprendere le sessioni dopo l'arresto del server](#resume-sessions-after-stopping-the-server). Non può essere combinato con `--continue`, `--spawn`, `--capacity` o `--create-session-in-dir`. Richiede Claude Code v2.1.200 o successivo. |63> | `--session-id <id>` | Ripristina una sessione in base al suo ID. Vedere [Riprendere le sessioni dopo l'arresto del server](#resume-sessions-after-stopping-the-server). Non può essere combinato con `--continue`, `--spawn`, `--capacity` o `--create-session-in-dir`. Richiede Claude Code v2.1.200 o successivo. |

64| `--spawn <mode>` | Come il server crea le sessioni. • `same-dir` (predefinito quando non è salvata alcuna modalità): tutte le sessioni condividono la directory di lavoro corrente, quindi possono entrare in conflitto se modificano gli stessi file. • `worktree`: ogni sessione su richiesta ottiene il proprio [git worktree](https://code.claude.com/docs/it/worktrees.md). Richiede un repository git o un [hook `WorktreeCreate`](https://code.claude.com/docs/it/hooks#worktreecreate). • `session`: modalità a sessione singola. Serve esattamente una sessione e rifiuta connessioni aggiuntive. Impostato solo all'avvio. Premi `w` durante l'esecuzione per alternare tra `same-dir` e `worktree`. La modalità a cui passi diventa il [valore predefinito per questo progetto](#set-the-default-spawn-mode-for-a-project). |64> | `--spawn <mode>` | Come il server crea le sessioni. • `same-dir` (predefinito quando non è salvata alcuna modalità): tutte le sessioni condividono la directory di lavoro corrente, quindi possono entrare in conflitto se modificano gli stessi file. • `worktree`: ogni sessione su richiesta ottiene il proprio [git worktree](https://code.claude.com/docs/it/worktrees.md). Richiede un repository git o un [hook `WorktreeCreate`](https://code.claude.com/docs/it/hooks#worktreecreate). • `session`: modalità a sessione singola. Serve esattamente una sessione e rifiuta connessioni aggiuntive. Impostato solo all'avvio. Premi `w` durante l'esecuzione per alternare tra `same-dir` e `worktree`. La modalità a cui passi diventa il [valore predefinito per questo progetto](#set-the-default-spawn-mode-for-a-project). |

65| `--capacity <N>` | Numero massimo di sessioni simultanee. Il valore predefinito è 32. Non può essere utilizzato con `--spawn=session`. |65> | `--capacity <N>` | Numero massimo di sessioni simultanee. Il valore predefinito è 32. Non può essere utilizzato con `--spawn=session`. |

66| `--[no-]create-session-in-dir` | Pre-crea una sessione nella directory corrente quando il server si avvia, in modo da avere un posto dove digitare immediatamente. In modalità `worktree` questa sessione rimane nella directory corrente mentre le sessioni su richiesta ottengono worktree isolati. Attivato per impostazione predefinita. Se si passa `--no-create-session-in-dir` per iniziare senza nessuno, Claude Code archivia le sessioni del server quando lo si arresta, quindi non c'è nulla da [riprendere](#resume-sessions-after-stopping-the-server). |66> | `--[no-]create-session-in-dir` | Pre-crea una sessione nella directory corrente quando il server si avvia, in modo da avere un posto dove digitare immediatamente. In modalità `worktree` questa sessione rimane nella directory corrente mentre le sessioni su richiesta ottengono worktree isolati. Attivato per impostazione predefinita. Se si passa `--no-create-session-in-dir` per iniziare senza nessuno, Claude Code archivia le sessioni del server quando lo si arresta, quindi non c'è nulla da [riprendere](#resume-sessions-after-stopping-the-server). |

67| `--permission-mode <mode>` | Imposta la [modalità di autorizzazione](https://code.claude.com/docs/it/permission-modes.md) iniziale per le sessioni del server, come `acceptEdits`. Accetta `manual` come alias per `default`; una modalità non riconosciuta arresta il server all'avvio ed elenca le modalità valide. |67> | `--permission-mode <mode>` | Imposta la [modalità di autorizzazione](https://code.claude.com/docs/it/permission-modes.md) iniziale per le sessioni del server, come `acceptEdits`. Accetta `manual` come alias per `default`; una modalità non riconosciuta arresta il server all'avvio ed elenca le modalità valide. |

68| `--chrome` / `--no-chrome` | Attiva o disattiva l'[integrazione Chrome](https://code.claude.com/docs/it/chrome.md) nelle sessioni che il server crea, in modo che Claude possa utilizzare Chrome sulla tua macchina mentre lavori da un altro dispositivo. Senza nessuno dei due flag, la sessione che il server pre-crea e qualsiasi sessione che avvii tu stesso da claude.ai/code o dall'app Claude iniziano con Chrome disattivato, anche se hai [abilitato Chrome per impostazione predefinita](https://code.claude.com/docs/it/chrome.md#enable-chrome-by-default). Una sessione che il server avvia per uno dei tuoi thread di [progetto](https://code.claude.com/docs/it/claude-projects.md) segue invece quella impostazione, tranne in modalità `bypassPermissions`. Richiede Claude Code v2.1.273 o successivo. |68> | `--chrome` / `--no-chrome` | Attiva o disattiva l'[integrazione Chrome](https://code.claude.com/docs/it/chrome.md) nelle sessioni che il server crea, in modo che Claude possa utilizzare Chrome sulla tua macchina mentre lavori da un altro dispositivo. Senza nessuno dei due flag, la sessione che il server pre-crea e qualsiasi sessione che avvii tu stesso da claude.ai/code o dall'app Claude iniziano con Chrome disattivato, anche se hai [abilitato Chrome per impostazione predefinita](https://code.claude.com/docs/it/chrome.md#enable-chrome-by-default). Una sessione che il server avvia per uno dei tuoi thread di [progetto](https://code.claude.com/docs/it/claude-projects.md) segue invece quella impostazione, tranne in modalità `bypassPermissions`. Richiede Claude Code v2.1.273 o successivo. |

69| `-d`, `--debug[=<filter>]` | Attiva la registrazione del debug per il server, facoltativamente filtrata per categoria. Passare un filtro solo nella forma `=`, come `--debug=api,hooks`. Richiede Claude Code v2.1.282 o successivo. |69> | `-d`, `--debug[=<filter>]` | Attiva la registrazione del debug per il server, facoltativamente filtrata per categoria. Passare un filtro solo nella forma `=`, come `--debug=api,hooks`. Richiede Claude Code v2.1.282 o successivo. |

70| `--debug-file <path>` | Scrive i log di debug nel file specificato. |70> | `--debug-file <path>` | Scrive i log di debug nel file specificato. |

71| `--verbose` | Mostra log dettagliati di connessione e sessione. |71> | `--verbose` | Mostra log dettagliati di connessione e sessione. |

72| `--sandbox`, `--no-sandbox` | Rimossi in v2.1.300. Se passi uno dei due flag, il server [esce con un errore](https://code.claude.com/docs/it/errors.md#sandbox-is-not-supported-by-claude-remote-control) invece di avviarsi. |72> | `--sandbox`, `--no-sandbox` | Rimossi in v2.1.300. Se passi uno dei due flag, il server [esce con un errore](https://code.claude.com/docs/it/errors.md#sandbox-is-not-supported-by-claude-remote-control) invece di avviarsi. |

73 73>

74Se si passa un flag `claude` globale prima di `remote-control`, o uno script wrapper ne aggiunge uno, Claude Code non trasporta il flag alle sessioni che il server crea. Claude Code consente il flag solo quando è noto che eliminarlo non cambia ciò che quelle sessioni possono fare, come `--verbose` o `--model`. Per qualsiasi altro flag, come `--settings`, Claude Code [rifiuta di avviarsi](https://code.claude.com/docs/it/errors.md#not-carried-over-to-the-sessions-remote-control-starts) e nomina il flag da rimuovere.74> Se si passa un flag `claude` globale prima di `remote-control`, o uno script wrapper ne aggiunge uno, Claude Code non trasporta il flag alle sessioni che il server crea. Claude Code consente il flag solo quando è noto che eliminarlo non cambia ciò che quelle sessioni possono fare, come `--verbose` o `--model`. Per qualsiasi altro flag, come `--settings`, Claude Code [rifiuta di avviarsi](https://code.claude.com/docs/it/errors.md#not-carried-over-to-the-sessions-remote-control-starts) e nomina il flag da rimuovere.

75 75>

76Per eseguire il sandbox delle sessioni che il server avvia, attivare il [sandboxing](https://code.claude.com/docs/it/sandboxing.md) in un file di impostazioni.76> Per eseguire il sandbox delle sessioni che il server avvia, attivare il [sandboxing](https://code.claude.com/docs/it/sandboxing.md) in un file di impostazioni.

77 77>

78Per stampare i flag di `remote-control` nel terminale, esegui `claude remote-control --help`. Prima della v2.1.302, senza un accesso idoneo il comando restituiva invece uno degli errori elencati in [Risoluzione dei problemi](#troubleshooting).78> Per stampare i flag di `remote-control` nel terminale, esegui `claude remote-control --help`. Prima della v2.1.302, senza un accesso idoneo il comando restituiva invece uno degli errori elencati in [Risoluzione dei problemi](#troubleshooting).

79 

80**Sessione interattiva**

81 

82Per avviare una normale sessione Claude Code interattiva con Remote Control abilitato, utilizza il flag `--remote-control` (o `--rc`):

83 

84```bash theme={null}

85claude --remote-control

86```

87 

88Facoltativamente, passare un nome per la sessione:

89 

90```bash theme={null}

91claude --remote-control "My Project"

92```

93 

94Questo ti dà una sessione interattiva completa nel tuo terminale che puoi anche controllare da claude.ai o dall'app Claude. A differenza di `claude remote-control` (modalità server), puoi digitare messaggi localmente mentre la sessione è anche disponibile da remoto.

95 

96**Da una sessione esistente**

97 

98Se sei già in una sessione Claude Code e vuoi continuarla da remoto, utilizza il comando `/remote-control` (o `/rc`):

99 

100```text theme={null}

101/remote-control

102```

103 

104Passa un nome come argomento per impostare un titolo di sessione personalizzato:

105 

106```text theme={null}

107/remote-control My Project

108```

109 

110Questo avvia una sessione Remote Control che trasporta la cronologia della conversazione corrente.

111 

112Fino a quando non si accetta la conferma una tantum di Remote Control, una finestra di dialogo appare prima che `/remote-control` si connetta. Selezionare **Enable Remote Control** per accettare e connettersi. Se si seleziona **Never mind** o si preme Esc, Claude Code non si connette e chiede di nuovo la prossima volta che si esegue `/remote-control`.

113 

114Il flag `--verbose` non è disponibile con questo comando.

115 

116**VS Code**

117 

118Nell'[estensione Claude Code VS Code](https://code.claude.com/docs/it/vs-code.md), digitare `/remote-control` o `/rc` nella casella del prompt.

119 

120```text theme={null}

121/remote-control

122```

123 

124Mentre Remote Control è attivo, Claude Code mostra un indicatore **Remote Control** nel footer della casella del prompt. Una volta che la sessione si connette, fare clic sull'indicatore per andare direttamente alla sessione, oppure trovarla nell'elenco delle sessioni su [claude.ai/code](https://claude.ai/code). Claude Code pubblica anche l'URL della sessione nella conversazione. Per disconnettersi, eseguire `/remote-control` di nuovo.

125 

126A differenza della CLI, il comando VS Code non accetta un argomento di nome o non visualizza un codice QR. Il titolo della sessione è derivato dalla cronologia della conversazione o dal primo prompt.

127 

128**App Desktop**

129 79 

130In una sessione locale nella scheda Code dell'[app Claude Desktop](https://code.claude.com/docs/it/desktop.md), digitare `/remote-control` o `/rc` nella casella del prompt.80> [tab] Sessione interattiva

81>

82> Per avviare una normale sessione Claude Code interattiva con Remote Control abilitato, utilizza il flag `--remote-control` (o `--rc`):

83>

84> ```bash theme={null}

85> claude --remote-control

86> ```

87>

88> Facoltativamente, passare un nome per la sessione:

89>

90> ```bash theme={null}

91> claude --remote-control "My Project"

92> ```

93>

94> Questo ti dà una sessione interattiva completa nel tuo terminale che puoi anche controllare da claude.ai o dall'app Claude. A differenza di `claude remote-control` (modalità server), puoi digitare messaggi localmente mentre la sessione è anche disponibile da remoto.

131 95 

132```text theme={null}96> [tab] Da una sessione esistente

133/remote-control97>

134```98> Se sei già in una sessione Claude Code e vuoi continuarla da remoto, utilizza il comando `/remote-control` (o `/rc`):

99>

100> ```text theme={null}

101> /remote-control

102> ```

103>

104> Passa un nome come argomento per impostare un titolo di sessione personalizzato:

105>

106> ```text theme={null}

107> /remote-control My Project

108> ```

109>

110> Questo avvia una sessione Remote Control che trasporta la cronologia della conversazione corrente.

111>

112> Fino a quando non si accetta la conferma una tantum di Remote Control, una finestra di dialogo appare prima che `/remote-control` si connetta. Selezionare **Enable Remote Control** per accettare e connettersi. Se si seleziona **Never mind** o si preme Esc, Claude Code non si connette e chiede di nuovo la prossima volta che si esegue `/remote-control`.

113>

114> Il flag `--verbose` non è disponibile con questo comando.

135 115 

136Una volta che la sessione si connette, trovarla nell'elenco delle sessioni su [claude.ai/code](https://claude.ai/code). Per disconnettersi, eseguire `/remote-control` di nuovo.116> [tab] VS Code

117>

118> Nell'[estensione Claude Code VS Code](https://code.claude.com/docs/it/vs-code.md), digitare `/remote-control` o `/rc` nella casella del prompt.

119>

120> ```text theme={null}

121> /remote-control

122> ```

123>

124> Mentre Remote Control è attivo, Claude Code mostra un indicatore **Remote Control** nel footer della casella del prompt. Una volta che la sessione si connette, fare clic sull'indicatore per andare direttamente alla sessione, oppure trovarla nell'elenco delle sessioni su [claude.ai/code](https://claude.ai/code). Claude Code pubblica anche l'URL della sessione nella conversazione. Per disconnettersi, eseguire `/remote-control` di nuovo.

125>

126> A differenza della CLI, il comando VS Code non accetta un argomento di nome o non visualizza un codice QR. Il titolo della sessione è derivato dalla cronologia della conversazione o dal primo prompt.

137 127 

138Per attivare Remote Control per ogni sessione per impostazione predefinita, vedere [Abilitare Remote Control per tutte le sessioni](#enable-remote-control-for-all-sessions).128> [tab] App Desktop

129>

130> In una sessione locale nella scheda Code dell'[app Claude Desktop](https://code.claude.com/docs/it/desktop.md), digitare `/remote-control` o `/rc` nella casella del prompt.

131>

132> ```text theme={null}

133> /remote-control

134> ```

135>

136> Una volta che la sessione si connette, trovarla nell'elenco delle sessioni su [claude.ai/code](https://claude.ai/code). Per disconnettersi, eseguire `/remote-control` di nuovo.

137>

138> Per attivare Remote Control per ogni sessione per impostazione predefinita, vedere [Abilitare Remote Control per tutte le sessioni](#enable-remote-control-for-all-sessions).

139 139 

140### Verificare lo stato della connessione140### Verificare lo stato della connessione

141 141 

250>250>

251> Dispositivi affidabili è attualmente in beta. Le funzionalità e la funzionalità possono evolversi man mano che l'esperienza viene perfezionata.251> Dispositivi affidabili è attualmente in beta. Le funzionalità e la funzionalità possono evolversi man mano che l'esperienza viene perfezionata.

252>252>

253> Dispositivi affidabili è disponibile su piani Pro, Max, Team ed Enterprise ed è disabilitato per impostazione predefinita. Su piani Team ed Enterprise, un Owner lo abilita per l'organizzazione. Su piani Pro e Max, Lei abilita **Require trusted devices** da sola nelle impostazioni, sulla pagina Cowork o Account.253> Dispositivi affidabili è disponibile sui piani Pro, Max, Ultra, Team ed Enterprise ed è disabilitato per impostazione predefinita. Su piani Team ed Enterprise, un Owner lo abilita per l'organizzazione. Sui piani Pro, Max e Ultra, sei tu ad attivare **Require trusted devices** nelle tue impostazioni, sulla pagina Cowork o Account.

254 254 

255Dispositivi affidabili richiede a ogni membro della vostra organizzazione, o a Lei sola su un piano Pro o Max, di verificare il proprio dispositivo prima di poter visualizzare o controllare le sessioni Remote Control da claude.ai, dalle app Claude per dispositivi mobili o da Claude Desktop. Lega l'accesso a Remote Control a un dispositivo noto e a un'autenticazione recente, non solo a un account connesso.255Dispositivi affidabili richiede un dispositivo verificato prima di poter visualizzare o controllare le sessioni Remote Control da claude.ai, dalle app Claude per dispositivi mobili o da Claude Desktop. Il requisito si applica a ogni membro della tua organizzazione, o solo a te su un piano Pro, Max o Ultra. Lega l'accesso a Remote Control a un dispositivo noto e a un'autenticazione recente, non solo a un account connesso.

256 256 

257Quando l'impostazione è attiva, l'interazione con una sessione Remote Control richiede entrambi i seguenti:257Quando l'impostazione è attiva, l'interazione con una sessione Remote Control richiede entrambi i seguenti:

258 258 

310| [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) | Invia un'attività dall'app mobile Claude | La tua macchina (Desktop) | [Associa l'app mobile a Desktop](https://support.claude.com/en/articles/13947068) | Delegare il lavoro mentre sei via, setup minimo |310| [Dispatch](https://code.claude.com/docs/it/desktop.md#sessions-from-dispatch) | Invia un'attività dall'app mobile Claude | La tua macchina (Desktop) | [Associa l'app mobile a Desktop](https://support.claude.com/en/articles/13947068) | Delegare il lavoro mentre sei via, setup minimo |

311| [Remote Control](https://code.claude.com/docs/it/remote-control.md) | Guida una sessione in esecuzione da [claude.ai/code](https://claude.ai/code) o dall'app mobile Claude | La tua macchina (CLI, Desktop, o VS Code) | Esegui [`claude remote-control` o `/remote-control`](https://code.claude.com/docs/it/remote-control#start-a-remote-control-session) | Guidare il lavoro in corso da un altro dispositivo |311| [Remote Control](https://code.claude.com/docs/it/remote-control.md) | Guida una sessione in esecuzione da [claude.ai/code](https://claude.ai/code) o dall'app mobile Claude | La tua macchina (CLI, Desktop, o VS Code) | Esegui [`claude remote-control` o `/remote-control`](https://code.claude.com/docs/it/remote-control#start-a-remote-control-session) | Guidare il lavoro in corso da un altro dispositivo |

312| [Channels](https://code.claude.com/docs/it/channels.md) | Invia eventi da un'app di chat come Telegram o Discord, o dal tuo server | La tua macchina (CLI) | [Installa un plugin channel](https://code.claude.com/docs/it/channels.md#quickstart) o [crea il tuo](https://code.claude.com/docs/it/channels-reference.md) | Reagire a eventi esterni come errori CI o messaggi di chat |312| [Channels](https://code.claude.com/docs/it/channels.md) | Invia eventi da un'app di chat come Telegram o Discord, o dal tuo server | La tua macchina (CLI) | [Installa un plugin channel](https://code.claude.com/docs/it/channels.md#quickstart) o [crea il tuo](https://code.claude.com/docs/it/channels-reference.md) | Reagire a eventi esterni come errori CI o messaggi di chat |

313| [Slack](https://code.claude.com/docs/it/slack.md) | Menziona `@Claude` in un canale del team | Cloud Anthropic | [Installa l'app Slack](https://code.claude.com/docs/it/slack.md#setting-up-claude-code-in-slack) con [Claude Code sul web](https://code.claude.com/docs/it/claude-code-on-the-web.md) abilitato, sui piani Pro e Max | PR e revisioni dalla chat del team |313| [Slack](https://code.claude.com/docs/it/slack.md) | Menziona `@Claude` in un canale del team | Cloud Anthropic | [Installa l'app Slack](https://code.claude.com/docs/it/slack.md#setting-up-claude-code-in-slack) con [Claude Code sul web](https://code.claude.com/docs/it/claude-code-on-the-web.md) abilitato, sui piani Pro, Max e Ultra | PR e revisioni dalla chat del team |

314| [Self-hosted environments](https://code.claude.com/docs/it/self-hosted-environments) | Avvia una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e scegli l'ambiente della tua organizzazione | L'infrastruttura della tua organizzazione | [Distribuisci runner](https://code.claude.com/docs/it/self-hosted-environments-quickstart.md), su piani Team e Enterprise | Sessioni cloud che devono essere eseguite all'interno della tua rete |314| [Self-hosted environments](https://code.claude.com/docs/it/self-hosted-environments) | Avvia una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e scegli l'ambiente della tua organizzazione | L'infrastruttura della tua organizzazione | [Distribuisci runner](https://code.claude.com/docs/it/self-hosted-environments-quickstart.md), su piani Team e Enterprise | Sessioni cloud che devono essere eseguite all'interno della tua rete |

315| [Scheduled tasks](https://code.claude.com/docs/it/scheduled-tasks.md) | Imposta una pianificazione | [CLI](https://code.claude.com/docs/it/scheduled-tasks.md), [Desktop](https://code.claude.com/docs/it/desktop-scheduled-tasks.md), o [cloud](https://code.claude.com/docs/it/routines.md) | Scegli una frequenza | Automazione ricorrente come revisioni giornaliere |315| [Scheduled tasks](https://code.claude.com/docs/it/scheduled-tasks.md) | Imposta una pianificazione | [CLI](https://code.claude.com/docs/it/scheduled-tasks.md), [Desktop](https://code.claude.com/docs/it/desktop-scheduled-tasks.md), o [cloud](https://code.claude.com/docs/it/routines.md) | Scegli una frequenza | Automazione ricorrente come revisioni giornaliere |

316 316 

444Una [variabile d'ambiente](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching) che disattiva la valutazione feature-flag è impostata, e il messaggio completo nomina la variabile che Claude Code ha trovato. Nelle versioni precedenti alla 2.1.154, la stessa configurazione produce "Remote Control is not yet enabled for your account" invece. Cosa fare dipende dalla variabile che il messaggio nomina:444Una [variabile d'ambiente](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching) che disattiva la valutazione feature-flag è impostata, e il messaggio completo nomina la variabile che Claude Code ha trovato. Nelle versioni precedenti alla 2.1.154, la stessa configurazione produce "Remote Control is not yet enabled for your account" invece. Cosa fare dipende dalla variabile che il messaggio nomina:

445 445 

446* **`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` o `DISABLE_GROWTHBOOK`**: annulla l'impostazione della variabile ovunque sia impostata, nel tuo ambiente shell o nel blocco `env` di un [file `settings.json`](https://code.claude.com/docs/it/settings-reference#all-settings).446* **`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` o `DISABLE_GROWTHBOOK`**: annulla l'impostazione della variabile ovunque sia impostata, nel tuo ambiente shell o nel blocco `env` di un [file `settings.json`](https://code.claude.com/docs/it/settings-reference#all-settings).

447* **`DISABLE_TELEMETRY` o `DO_NOT_TRACK`**: su un piano Pro, Max, Team o Enterprise con `DISABLE_GROWTHBOOK` non impostato, queste variabili lasciano Remote Control disponibile a meno che la tua organizzazione non richieda [Trusted Devices](#trusted-devices). Se lo richiede, annulla l'impostazione della variabile ovunque sia impostata per utilizzare Remote Control. Dalla v2.1.154 alla v2.1.282, vedi questo messaggio con una qualsiasi delle due variabili impostata, quindi aggiorna Claude Code a una versione che soddisfi il [requisito per queste variabili](#requirements).447* **`DISABLE_TELEMETRY` o `DO_NOT_TRACK`**: su un piano Pro, Max, Ultra, Team o Enterprise con `DISABLE_GROWTHBOOK` non impostato, Remote Control resta disponibile con queste variabili impostate, a meno che la tua organizzazione non richieda [Trusted Devices](#trusted-devices). Se lo richiede, annulla l'impostazione della variabile ovunque sia impostata per utilizzare Remote Control. Dalla v2.1.154 alla v2.1.282, vedi questo messaggio con una qualsiasi delle due variabili impostata, quindi aggiorna Claude Code a una versione che soddisfi il [requisito per queste variabili](#requirements).

448 448 

449### "Remote Control is only available when using Claude via api.anthropic.com"449### "Remote Control is only available when using Claude via api.anthropic.com"

450 450 

457Una policy blocca Remote Control. Controlla queste cause in ordine:457Una policy blocca Remote Control. Controlla queste cause in ordine:

458 458 

459* **L'errore menziona `disableRemoteControl`**: il tuo amministratore IT ha disabilitato Remote Control su questo dispositivo tramite [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md), indipendentemente dall'interruttore a livello di organizzazione e da come sei connesso.459* **L'errore menziona `disableRemoteControl`**: il tuo amministratore IT ha disabilitato Remote Control su questo dispositivo tramite [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md), indipendentemente dall'interruttore a livello di organizzazione e da come sei connesso.

460* **Il tuo piano claude.ai è Pro o Max**: Claude Code è ancora connesso con un'organizzazione Team o Enterprise da un accesso precedente, quindi controlla la policy Remote Control di quell'organizzazione. Esegui `/status` per vedere quale piano e organizzazione utilizza il tuo accesso. Esegui `claude auth logout` quindi `claude auth login` per accedere di nuovo con il tuo piano attuale.460* **Il tuo piano claude.ai è Pro, Max o Ultra**: Claude Code è ancora connesso con un'organizzazione Team o Enterprise da un accesso precedente, quindi controlla la policy Remote Control di quell'organizzazione. Esegui `/status` per vedere quale piano e organizzazione utilizza il tuo accesso. Esegui `claude auth logout` quindi `claude auth login` per accedere di nuovo con il tuo piano attuale.

461* **Il messaggio non dice di contattare l'amministratore della tua organizzazione**: alla tua organizzazione è applicata la [configurazione HIPAA](https://code.claude.com/docs/it/hipaa-setup.md), che disattiva Remote Control. Per verificarlo, esegui `/status` e cerca `HIPAA` nella riga `Organization configuration`. Un Owner vede l'interruttore **Remote Control** disattivato in grigio nelle [impostazioni di amministrazione](https://claude.ai/admin-settings/claude-code) e non può attivarlo. Se hai domande sulla configurazione, chiedi a un Owner, che può contattare il team account Anthropic della tua organizzazione. Prima della v2.1.267, questo caso mostrava "Remote Control isn't available for your organization due to its compliance policy" invece.461* **Il messaggio non dice di contattare l'amministratore della tua organizzazione**: alla tua organizzazione è applicata la [configurazione HIPAA](https://code.claude.com/docs/it/hipaa-setup.md), che disattiva Remote Control. Per verificarlo, esegui `/status` e cerca `HIPAA` nella riga `Organization configuration`. Un Owner vede l'interruttore **Remote Control** disattivato in grigio nelle [impostazioni di amministrazione](https://claude.ai/admin-settings/claude-code) e non può attivarlo. Se hai domande sulla configurazione, chiedi a un Owner, che può contattare il team account Anthropic della tua organizzazione. Prima della v2.1.267, questo caso mostrava "Remote Control isn't available for your organization due to its compliance policy" invece.

462* **Remote Control funziona per altri membri della tua organizzazione ma non per te**: se la tua organizzazione Enterprise gestisce il tuo accesso con [ruoli personalizzati](https://support.claude.com/en/articles/13930452), la causa possono essere i tuoi ruoli. Remote Control richiede sia il permesso per le sessioni cloud sia il permesso **Claude Code remote control**. Chiedi a un Owner di verificare se i tuoi ruoli includono entrambi e di aggiungere ciò che manca in [**Organization settings > Roles**](https://claude.ai/admin-settings/roles).462* **Remote Control funziona per altri membri della tua organizzazione ma non per te**: se la tua organizzazione Enterprise gestisce il tuo accesso con [ruoli personalizzati](https://support.claude.com/en/articles/13930452), la causa possono essere i tuoi ruoli. Remote Control richiede sia il permesso per le sessioni cloud sia il permesso **Claude Code remote control**. Chiedi a un Owner di verificare se i tuoi ruoli includono entrambi e di aggiungere ciò che manca in [**Organization settings > Roles**](https://claude.ai/admin-settings/roles).

463* **Altrimenti, un Owner non l'ha abilitato per la tua organizzazione**: Remote Control è disattivato per impostazione predefinita sui piani Team e Enterprise. Un Owner può abilitarlo su [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code) attivando l'interruttore **Remote Control**. Questo interruttore è un'impostazione dell'organizzazione lato server.463* **Altrimenti, un Owner non l'ha abilitato per la tua organizzazione**: Remote Control è disattivato per impostazione predefinita sui piani Team e Enterprise. Un Owner può abilitarlo su [claude.ai/admin-settings/claude-code](https://claude.ai/admin-settings/claude-code) attivando l'interruttore **Remote Control**. Questo interruttore è un'impostazione dell'organizzazione lato server.

routines.md +11 −11

Details

25* Un'attività con solo un trigger API viene eseguita quando chiami il suo endpoint.25* Un'attività con solo un trigger API viene eseguita quando chiami il suo endpoint.

26* Un'attività con solo un trigger GitHub viene eseguita quando si verifica un evento del repository corrispondente.26* Un'attività con solo un trigger GitHub viene eseguita quando si verifica un evento del repository corrispondente.

27 27 

28Le attività pianificate sono disponibili sui piani Pro, Max, Team ed Enterprise. Creale e gestiscile su [claude.ai/code/routines](https://claude.ai/code/routines), oppure dalla CLI con `/schedule`. Il nome precedente, routine, [compare ancora](#where-the-name-routines-still-appears).28Le attività pianificate sono disponibili sui piani Pro, Max, Ultra, Team ed Enterprise. Creale e gestiscile su [claude.ai/code/routines](https://claude.ai/code/routines), oppure dalla CLI con `/schedule`. Il nome precedente, routine, [compare ancora](#where-the-name-routines-still-appears).

29 29 

30> [!NOTE]30> [!NOTE]

31>31>

85 85 

86Nella riga **Trigger**, scegli come inizia l'attività. Per combinare più trigger, fai clic su **+** alla fine della riga.86Nella riga **Trigger**, scegli come inizia l'attività. Per combinare più trigger, fai clic su **+** alla fine della riga.

87 87 

88**Schedule**88> [tab] Schedule

89 89>

90Scegli una frequenza preimpostata per un'esecuzione ricorrente. Consulta [Aggiungere un trigger di pianificazione](#add-a-schedule-trigger) per la gestione del fuso orario, gli avvii in ritardo, gli intervalli cron personalizzati e le esecuzioni una tantum.90> Scegli una frequenza preimpostata per un'esecuzione ricorrente. Consulta [Aggiungere un trigger di pianificazione](#add-a-schedule-trigger) per la gestione del fuso orario, gli avvii in ritardo, gli intervalli cron personalizzati e le esecuzioni una tantum.

91 

92**GitHub event**

93 

94Seleziona il repository, l'evento a cui reagire e i filtri facoltativi. Consulta [Aggiungere un trigger GitHub](#add-a-github-trigger) per l'elenco completo degli eventi supportati e dei campi di filtro.

95 91 

96**API**92> [tab] GitHub event

93>

94> Seleziona il repository, l'evento a cui reagire e i filtri facoltativi. Consulta [Aggiungere un trigger GitHub](#add-a-github-trigger) per l'elenco completo degli eventi supportati e dei campi di filtro.

97 95 

98Seleziona **API** qui. Quando fai clic su **Create**, la finestra di dialogo **API token** mostra il token una sola volta, quindi copialo prima di chiudere la finestra di dialogo. Consulta [Aggiungere un trigger API](#add-an-api-trigger) per copiare l'URL o generare un nuovo token.96> [tab] API

97>

98> Seleziona **API** qui. Quando fai clic su **Create**, la finestra di dialogo **API token** mostra il token una sola volta, quindi copialo prima di chiudere la finestra di dialogo. Consulta [Aggiungere un trigger API](#add-an-api-trigger) per copiare l'URL o generare un nuovo token.

99 99 

100**4. Seleziona i repository**100**4. Seleziona i repository**

101 101 

502* Un Owner ha [disattivato le attività pianificate](#routines-are-disabled-by-your-organizations-policy) per la tua organizzazione Team o Enterprise. Prima della v2.1.227, in questo caso il comando compariva comunque e claude.ai rifiutava l'attività quando Claude tentava di crearla o eseguirla502* Un Owner ha [disattivato le attività pianificate](#routines-are-disabled-by-your-organizations-policy) per la tua organizzazione Team o Enterprise. Prima della v2.1.227, in questo caso il comando compariva comunque e claude.ai rifiutava l'attività quando Claude tentava di crearla o eseguirla

503* La tua organizzazione Enterprise gestisce il tuo accesso con [ruoli personalizzati](https://support.claude.com/en/articles/13930452) e nessuno dei tuoi ruoli include il permesso per le attività pianificate in **Remote sessions**. Chiedi a un Owner di aggiungerlo a uno dei tuoi ruoli503* La tua organizzazione Enterprise gestisce il tuo accesso con [ruoli personalizzati](https://support.claude.com/en/articles/13930452) e nessuno dei tuoi ruoli include il permesso per le attività pianificate in **Remote sessions**. Chiedi a un Owner di aggiungerlo a uno dei tuoi ruoli

504 504 

505Se la causa è l'accesso alla CLI o il fatto che ti trovi all'interno di una sessione cloud, puoi comunque creare e gestire le attività pianificate su [claude.ai/code/routines](https://claude.ai/code/routines). Lì ti serve un account Pro, Max, Team o Enterprise. Se le attività pianificate o le sessioni cloud sono disattivate per la tua organizzazione o mancano dai tuoi ruoli, non puoi crearle nemmeno sul web.505Se la causa è l'accesso alla CLI o il fatto che ti trovi all'interno di una sessione cloud, puoi comunque creare e gestire le attività pianificate su [claude.ai/code/routines](https://claude.ai/code/routines). Lì ti serve un account Pro, Max, Ultra, Team o Enterprise. Se le attività pianificate o le sessioni cloud sono disattivate per la tua organizzazione o mancano dai tuoi ruoli, non puoi crearle nemmeno sul web.

506 506 

507### "Routines are disabled by your organization's policy"507### "Routines are disabled by your organization's policy"

508 508 

sandboxing.md +12 −12

Details

119 119 

120Installali con il gestore di pacchetti della tua distribuzione:120Installali con il gestore di pacchetti della tua distribuzione:

121 121 

122**Ubuntu/Debian**122> [tab] Ubuntu/Debian

123 123>

124```bash theme={null}124> ```bash theme={null}

125sudo apt-get install bubblewrap socat125> sudo apt-get install bubblewrap socat

126```126> ```

127 

128**Fedora**

129 127 

130```bash theme={null}128> [tab] Fedora

131sudo dnf install bubblewrap socat129>

132```130> ```bash theme={null}

131> sudo dnf install bubblewrap socat

132> ```

133 133 

134Quando manca una dipendenza, la scheda Dependencies in `/sandbox` elenca quali tra `ripgrep`, `bubblewrap`, `socat` e il filtro seccomp mancano alla tua piattaforma. Se non vedi la scheda dopo aver installato e riavviato Claude Code, tutte le dipendenze sono presenti.134Quando manca una dipendenza, la scheda Dependencies in `/sandbox` elenca quali tra `ripgrep`, `bubblewrap`, `socat` e il filtro seccomp mancano alla tua piattaforma. Se non vedi la scheda dopo aver installato e riavviato Claude Code, tutte le dipendenze sono presenti.

135 135 

137 137 

138Quando manca una dipendenza richiesta, la scheda Dependencies è l'unica mostrata finché non la installi. Quando manca solo il filtro seccomp opzionale, la scheda Dependencies appare insieme alle altre schede. Il controllo delle dipendenze viene eseguito all'avvio, quindi riavvia Claude Code dopo aver installato i pacchetti affinché `/sandbox` li rilevi.138Quando manca una dipendenza richiesta, la scheda Dependencies è l'unica mostrata finché non la installi. Quando manca solo il filtro seccomp opzionale, la scheda Dependencies appare insieme alle altre schede. Il controllo delle dipendenze viene eseguito all'avvio, quindi riavvia Claude Code dopo aver installato i pacchetti affinché `/sandbox` li rilevi.

139 139 

140> **Ubuntu 24.04 e successivi: consentire a bubblewrap di creare user namespace**140> [accordion] Ubuntu 24.04 e successivi: consentire a bubblewrap di creare user namespace

141>141>

142> Su Ubuntu 24.04 e successivi, la policy AppArmor predefinita impedisce a bubblewrap di creare gli user namespace di cui ha bisogno per l'isolamento.142> Su Ubuntu 24.04 e successivi, la policy AppArmor predefinita impedisce a bubblewrap di creare gli user namespace di cui ha bisogno per l'isolamento.

143>143>

161> sudo systemctl reload apparmor161> sudo systemctl reload apparmor

162> ```162> ```

163 163 

164> **Note su WSL2**164> [accordion] Note su WSL2

165>165>

166> Controlla la tua versione di WSL con `wsl -l -v` da PowerShell. Se vedi `Sandboxing requires WSL2`, la tua distribuzione sta eseguendo WSL1. Aggiornala a WSL2 oppure esegui Claude Code senza sandboxing.166> Controlla la tua versione di WSL con `wsl -l -v` da PowerShell. Se vedi `Sandboxing requires WSL2`, la tua distribuzione sta eseguendo WSL1. Aggiornala a WSL2 oppure esegui Claude Code senza sandboxing.

167>167>

security.md +1 −1

Details

53* Accesso limitato ai dati della sessione utente53* Accesso limitato ai dati della sessione utente

54* Controllo dell'utente sulle preferenze di addestramento dei dati. Gli utenti consumer possono modificare le loro [impostazioni di privacy](https://claude.ai/settings/privacy) in qualsiasi momento.54* Controllo dell'utente sulle preferenze di addestramento dei dati. Gli utenti consumer possono modificare le loro [impostazioni di privacy](https://claude.ai/settings/privacy) in qualsiasi momento.

55 55 

56Per i dettagli completi, consultare i nostri [Termini di servizio commerciali](https://www.anthropic.com/legal/commercial-terms) (per utenti Team, Enterprise e API) o [Termini consumer](https://www.anthropic.com/legal/consumer-terms) (per utenti Free, Pro e Max) e [Informativa sulla privacy](https://www.anthropic.com/legal/privacy).56Per i dettagli completi, consulta i nostri [Termini di servizio commerciali](https://www.anthropic.com/legal/commercial-terms) (per utenti Team, Enterprise e API) o [Termini consumer](https://www.anthropic.com/legal/consumer-terms) (per utenti Free, Pro, Max e Ultra) e l'[Informativa sulla privacy](https://www.anthropic.com/legal/privacy).

57 57 

58### Misure di protezione aggiuntive58### Misure di protezione aggiuntive

59 59 

Details

14 14 

15In un ambiente self-hosted, quelle stesse sessioni vengono eseguite all'interno della tua rete. L'esperienza dello sviluppatore è altrimenti la stessa a parte le differenze in [Disponibilità e limitazioni](#availability-and-limitations) e i [problemi noti](https://code.claude.com/docs/it/self-hosted-environments-deploy.md#known-issues-and-limitations) della pagina di distribuzione.15In un ambiente self-hosted, quelle stesse sessioni vengono eseguite all'interno della tua rete. L'esperienza dello sviluppatore è altrimenti la stessa a parte le differenze in [Disponibilità e limitazioni](#availability-and-limitations) e i [problemi noti](https://code.claude.com/docs/it/self-hosted-environments-deploy.md#known-issues-and-limitations) della pagina di distribuzione.

16 16 

17Se il tuo team non utilizza sessioni cloud, non c'è nulla da configurare qui: le sessioni in un terminale o IDE vengono sempre eseguite sulla macchina dello sviluppatore. Se desideri eseguire Claude Code sulla tua macchina sempre accesa e controllarla da altri dispositivi, utilizza [Remote Control](https://code.claude.com/docs/it/remote-control.md), che è disponibile anche sui piani Pro e Max. Quando sei pronto per la configurazione, vai direttamente alla [guida rapida](https://code.claude.com/docs/it/self-hosted-environments-quickstart.md); per rivedere prima il profilo di sicurezza, inizia con [Distribuisci in produzione](https://code.claude.com/docs/it/self-hosted-environments-deploy.md). Il resto di questa pagina spiega come funziona il self-hosting e quando sceglierlo.17* Se il tuo team non utilizza sessioni cloud, non c'è nulla da configurare qui: le sessioni in un terminale o IDE vengono sempre eseguite sulla macchina dello sviluppatore

18* Per eseguire Claude Code sulla tua macchina sempre accesa e controllarla da altri dispositivi, utilizza [Remote Control](https://code.claude.com/docs/it/remote-control.md), che è disponibile anche sui piani Pro, Max e Ultra

19* Quando sei pronto per la configurazione, vai direttamente alla [guida rapida](https://code.claude.com/docs/it/self-hosted-environments-quickstart.md); per rivedere prima il profilo di sicurezza, inizia con [Distribuisci in produzione](https://code.claude.com/docs/it/self-hosted-environments-deploy.md)

20 

21Per scoprire come funziona il self-hosting e quando sceglierlo, leggi [Come funzionano gli ambienti self-hosted](#how-self-hosted-environments-work) e [Perché scegliere il self-hosting](#why-self-host).

18 22 

19## Come funzionano gli ambienti self-hosted23## Come funzionano gli ambienti self-hosted

20 24 

Details

531 531 

532Avvia questi runner con [`--confine-repo-settings enforce`](https://code.claude.com/docs/it/self-hosted-environments-deploy#harden-your-deployment). Rifiuta le sessioni sui repository le cui impostazioni committate vengono segnalate, quindi esegui prima nella modalità predefinita `warn` e risolvi ciò che viene registrato nei log.532Avvia questi runner con [`--confine-repo-settings enforce`](https://code.claude.com/docs/it/self-hosted-environments-deploy#harden-your-deployment). Rifiuta le sessioni sui repository le cui impostazioni committate vengono segnalate, quindi esegui prima nella modalità predefinita `warn` e risolvi ciò che viene registrato nei log.

533 533 

534**Amazon Bedrock**534> [tab] Amazon Bedrock

535 535>

536Sostituisci la regione con la tua:536> Sostituisci la regione con la tua:

537 537>

538```bash theme={null}538> ```bash theme={null}

539export CLAUDE_CODE_USE_BEDROCK=1539> export CLAUDE_CODE_USE_BEDROCK=1

540export AWS_REGION=us-east-1540> export AWS_REGION=us-east-1

541```541> ```

542 542>

543Per sapere come Claude Code determina la regione, consulta [Configurare Claude Code](https://code.claude.com/docs/it/amazon-bedrock.md#3-configure-claude-code). Per sapere quale prefisso del profilo di inferenza usa Claude Code per la tua regione, consulta [Prefissi dei profili di inferenza cross-region](https://code.claude.com/docs/it/amazon-bedrock.md#cross-region-inference-profile-prefixes).543> Per sapere come Claude Code determina la regione, consulta [Configurare Claude Code](https://code.claude.com/docs/it/amazon-bedrock.md#3-configure-claude-code). Per sapere quale prefisso del profilo di inferenza usa Claude Code per la tua regione, consulta [Prefissi dei profili di inferenza cross-region](https://code.claude.com/docs/it/amazon-bedrock.md#cross-region-inference-profile-prefixes).

544 

545**Google Cloud's Agent Platform**

546 

547Sostituisci la regione e l'ID del progetto con i tuoi:

548 

549```bash theme={null}

550export CLAUDE_CODE_USE_VERTEX=1

551export CLOUD_ML_REGION=global

552export ANTHROPIC_VERTEX_PROJECT_ID=YOUR-PROJECT-ID

553```

554 544 

555Per scegliere una regione, consulta [Configurazione della regione](https://code.claude.com/docs/it/google-vertex-ai.md#region-configuration).545> [tab] Google Cloud's Agent Platform

546>

547> Sostituisci la regione e l'ID del progetto con i tuoi:

548>

549> ```bash theme={null}

550> export CLAUDE_CODE_USE_VERTEX=1

551> export CLOUD_ML_REGION=global

552> export ANTHROPIC_VERTEX_PROJECT_ID=YOUR-PROJECT-ID

553> ```

554>

555> Per scegliere una regione, consulta [Configurazione della regione](https://code.claude.com/docs/it/google-vertex-ai.md#region-configuration).

556 556 

557**4. Verifica che le variabili abbiano raggiunto una sessione**557**4. Verifica che le variabili abbiano raggiunto una sessione**

558 558 

Details

90 90 

91I controlli si mappano direttamente sulle librerie JWT standard. Gli esempi seguenti implementano la sequenza completa in Node.js con [`jose`](https://www.npmjs.com/package/jose), che gestisce il recupero JWKS, la memorizzazione nella cache e la selezione di `kid`, e in Python con [`PyJWT`](https://pyjwt.readthedocs.io/) e il suo client JWKS integrato.91I controlli si mappano direttamente sulle librerie JWT standard. Gli esempi seguenti implementano la sequenza completa in Node.js con [`jose`](https://www.npmjs.com/package/jose), che gestisce il recupero JWKS, la memorizzazione nella cache e la selezione di `kid`, e in Python con [`PyJWT`](https://pyjwt.readthedocs.io/) e il suo client JWKS integrato.

92 92 

93**Node.js (jose)**93> [tab] Node.js (jose)

94 94>

95```typescript theme={null}95> ```typescript theme={null}

96import { createRemoteJWKSet, jwtVerify } from "jose";96> import { createRemoteJWKSet, jwtVerify } from "jose";

97 97>

98const JWKS = createRemoteJWKSet(98> const JWKS = createRemoteJWKSet(

99 new URL("https://api.anthropic.com/v1/code/.well-known/jwks.json")99> new URL("https://api.anthropic.com/v1/code/.well-known/jwks.json")

100);100> );

101 101>

102const PREFIX = "sk-ant-cc-";102> const PREFIX = "sk-ant-cc-";

103const EXPECTED_POOL_ID = "ccpool_...";103> const EXPECTED_POOL_ID = "ccpool_...";

104 104>

105export async function verifySessionToken(raw: string) {105> export async function verifySessionToken(raw: string) {

106 if (!raw.startsWith(PREFIX)) {106> if (!raw.startsWith(PREFIX)) {

107 throw new Error("not a self-hosted runner session token");107> throw new Error("not a self-hosted runner session token");

108 }108> }

109 const jwt = raw.slice(PREFIX.length);109> const jwt = raw.slice(PREFIX.length);

110 110>

111 const { payload } = await jwtVerify(jwt, JWKS, {111> const { payload } = await jwtVerify(jwt, JWKS, {

112 issuer: "ccr",112> issuer: "ccr",

113 audience: EXPECTED_POOL_ID,113> audience: EXPECTED_POOL_ID,

114 algorithms: ["ES256"],114> algorithms: ["ES256"],

115 });115> });

116 116>

117 if (payload["ccr:role"] !== "session_worker") {117> if (payload["ccr:role"] !== "session_worker") {

118 throw new Error("token is not a session_worker token");118> throw new Error("token is not a session_worker token");

119 }119> }

120 120>

121 const act = payload.act as { email?: string; sub?: string };121> const act = payload.act as { email?: string; sub?: string };

122 return {122> return {

123 sessionId: payload["ccr:session_id"] as string,123> sessionId: payload["ccr:session_id"] as string,

124 poolId: payload["ccr:pool_id"] as string,124> poolId: payload["ccr:pool_id"] as string,

125 orgId: payload["ccr:org_id"] as string,125> orgId: payload["ccr:org_id"] as string,

126 creatorEmail: act?.email,126> creatorEmail: act?.email,

127 creatorSub: act?.sub,127> creatorSub: act?.sub,

128 };128> };

129}129> }

130```130> ```

131 131 

132**Python (PyJWT)**132> [tab] Python (PyJWT)

133 133>

134```python theme={null}134> ```python theme={null}

135import jwt135> import jwt

136from jwt import PyJWKClient136> from jwt import PyJWKClient

137 137>

138JWKS_URL = "https://api.anthropic.com/v1/code/.well-known/jwks.json"138> JWKS_URL = "https://api.anthropic.com/v1/code/.well-known/jwks.json"

139PREFIX = "sk-ant-cc-"139> PREFIX = "sk-ant-cc-"

140EXPECTED_POOL_ID = "ccpool_..."140> EXPECTED_POOL_ID = "ccpool_..."

141 141>

142jwks = PyJWKClient(JWKS_URL)142> jwks = PyJWKClient(JWKS_URL)

143 143>

144 144>

145def verify_session_token(raw: str) -> dict:145> def verify_session_token(raw: str) -> dict:

146 if not raw.startswith(PREFIX):146> if not raw.startswith(PREFIX):

147 raise ValueError("not a self-hosted runner session token")147> raise ValueError("not a self-hosted runner session token")

148 token = raw.removeprefix(PREFIX)148> token = raw.removeprefix(PREFIX)

149 149>

150 signing_key = jwks.get_signing_key_from_jwt(token)150> signing_key = jwks.get_signing_key_from_jwt(token)

151 payload = jwt.decode(151> payload = jwt.decode(

152 token,152> token,

153 signing_key.key,153> signing_key.key,

154 algorithms=["ES256"],154> algorithms=["ES256"],

155 issuer="ccr",155> issuer="ccr",

156 audience=EXPECTED_POOL_ID,156> audience=EXPECTED_POOL_ID,

157 )157> )

158 158>

159 if payload.get("ccr:role") != "session_worker":159> if payload.get("ccr:role") != "session_worker":

160 raise ValueError("token is not a session_worker token")160> raise ValueError("token is not a session_worker token")

161 161>

162 act = payload.get("act") or {}162> act = payload.get("act") or {}

163 return {163> return {

164 "session_id": payload["ccr:session_id"],164> "session_id": payload["ccr:session_id"],

165 "pool_id": payload["ccr:pool_id"],165> "pool_id": payload["ccr:pool_id"],

166 "org_id": payload["ccr:org_id"],166> "org_id": payload["ccr:org_id"],

167 "creator_email": act.get("email"),167> "creator_email": act.get("email"),

168 "creator_sub": act.get("sub"),168> "creator_sub": act.get("sub"),

169 }169> }

170```170> ```

171 171 

172### Verificare il token all'interno della sessione172### Verificare il token all'interno della sessione

173 173 

sessions.md +1 −1

Details

95 95 

96Se vedi la finestra di dialogo "Resume this conversation?" quando riprendi una sessione, la sua stima è la quota del tuo limite di utilizzo di 5 ore che userebbe la sola conversazione salvata. La stima non conta ciò che hai già usato.96Se vedi la finestra di dialogo "Resume this conversation?" quando riprendi una sessione, la sua stima è la quota del tuo limite di utilizzo di 5 ore che userebbe la sola conversazione salvata. La stima non conta ciò che hai già usato.

97 97 

98Nei piani Pro e Max, la finestra di dialogo può comparire quando riprendi una conversazione lunga [dopo una lunga pausa](https://code.claude.com/docs/it/prompt-caching.md#resuming-a-session) o con un modello diverso. L'utilizzo stimato viene conteggiato quando invii il primo messaggio dopo **Resume**, non quando lo selezioni. Scegli in base al fatto che la tua prossima attività abbia ancora bisogno della conversazione salvata:98Nei piani Pro, Max e Ultra, la finestra di dialogo può comparire quando riprendi una conversazione lunga [dopo una lunga pausa](https://code.claude.com/docs/it/prompt-caching.md#resuming-a-session) o con un modello diverso. L'utilizzo stimato viene conteggiato quando invii il primo messaggio dopo **Resume**, non quando lo selezioni. Scegli in base al fatto che la tua prossima attività abbia ancora bisogno della conversazione salvata:

99 99 

100* **Resume**: continua a lavorare nella conversazione salvata.100* **Resume**: continua a lavorare nella conversazione salvata.

101* **Start a new conversation**: passa a un lavoro che non ha bisogno della conversazione salvata. Per riaprirla in seguito, esegui [`/resume`](#use-the-session-picker) al prompt. La stima non si applica al tuo primo messaggio nella nuova conversazione. Se l'opzione indica che Claude può consultare questa conversazione, puoi comunque fare riferimento al lavoro precedente nella nuova conversazione.101* **Start a new conversation**: passa a un lavoro che non ha bisogno della conversazione salvata. Per riaprirla in seguito, esegui [`/resume`](#use-the-session-picker) al prompt. La stima non si applica al tuo primo messaggio nella nuova conversazione. Se l'opzione indica che Claude può consultare questa conversazione, puoi comunque fare riferimento al lavoro precedente nella nuova conversazione.

settings-example.md +325 −325

Details

20 20 

21Le impostazioni personali di uno sviluppatore. Sceglie un modello e uno sforzo, regola il terminale e pre-approva un comando di sola lettura e una lettura di file. Tutto ciò che non è elencato mantiene il suo valore predefinito. Un file come questo va in `~/.claude/settings.json`, dove si applica a ogni progetto che apri.21Le impostazioni personali di uno sviluppatore. Sceglie un modello e uno sforzo, regola il terminale e pre-approva un comando di sola lettura e una lettura di file. Tutto ciò che non è elencato mantiene il suo valore predefinito. Un file come questo va in `~/.claude/settings.json`, dove si applica a ogni progetto che apri.

22 22 

23**Copyable settings file**23> [tab] Copyable settings file

24 24>

25Salva questo come `~/.claude/settings.json`. È JSON valido senza commenti, quindi puoi incollarlo così com'è ed eliminare le chiavi che non desideri.25> Salva questo come `~/.claude/settings.json`. È JSON valido senza commenti, quindi puoi incollarlo così com'è ed eliminare le chiavi che non desideri.

26 26>

27```json ~/.claude/settings.json theme={null}27> ```json ~/.claude/settings.json theme={null}

28{28> {

29 "model": "claude-sonnet-5",29> "model": "claude-sonnet-5",

30 "modelSettings": {30> "modelSettings": {

31 "claude-sonnet-5": { "effortLevel": "xhigh" }31> "claude-sonnet-5": { "effortLevel": "xhigh" }

32 },32> },

33 "editorMode": "vim",33> "editorMode": "vim",

34 "theme": "light-daltonized",34> "theme": "light-daltonized",

35 "statusLine": {35> "statusLine": {

36 "type": "command",36> "type": "command",

37 "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'",37> "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'",

38 "padding": 238> "padding": 2

39 },39> },

40 "spinnerTipsEnabled": false,40> "spinnerTipsEnabled": false,

41 "preferredNotifChannel": "terminal_bell",41> "preferredNotifChannel": "terminal_bell",

42 "permissions": {42> "permissions": {

43 "allow": [43> "allow": [

44 "Bash(git diff *)",44> "Bash(git diff *)",

45 "Read(~/.zshrc)"45> "Read(~/.zshrc)"

46 ]46> ]

47 },47> },

48 "autoUpdatesChannel": "stable",48> "autoUpdatesChannel": "stable",

49 "cleanupPeriodDays": 2049> "cleanupPeriodDays": 20

50}50> }

51```51> ```

52 52 

53**What each key does**53> [tab] What each key does

54 54>

55Lo stesso file con un commento sopra ogni chiave. Leggilo qui; copia dall'altra scheda, perché Claude Code non accetta commenti in un file di impostazioni.55> Lo stesso file con un commento sopra ogni chiave. Leggilo qui; copia dall'altra scheda, perché Claude Code non accetta commenti in un file di impostazioni.

56 56>

57```jsonc ~/.claude/settings.json theme={null}57> ```jsonc ~/.claude/settings.json theme={null}

58{58> {

59 // Inizia ogni sessione su Sonnet 559> // Inizia ogni sessione su Sonnet 5

60 "model": "claude-sonnet-5",60> "model": "claude-sonnet-5",

61 // Esegui Sonnet 5 al di sopra del suo livello alto predefinito; /effort salva un livello per modello, e --effort ne imposta uno per una singola sessione61> // Esegui Sonnet 5 al di sopra del suo livello alto predefinito; /effort salva un livello per modello, e --effort ne imposta uno per una singola sessione

62 "modelSettings": {62> "modelSettings": {

63 "claude-sonnet-5": { "effortLevel": "xhigh" }63> "claude-sonnet-5": { "effortLevel": "xhigh" }

64 },64> },

65 // Scorciatoie da tastiera Vim nel prompt65> // Scorciatoie da tastiera Vim nel prompt

66 "editorMode": "vim",66> "editorMode": "vim",

67 // Il tema chiaro adatto ai daltonici67> // Il tema chiaro adatto ai daltonici

68 "theme": "light-daltonized",68> "theme": "light-daltonized",

69 // Una riga di stato sotto il prompt: nome del modello e contesto utilizzato69> // Una riga di stato sotto il prompt: nome del modello e contesto utilizzato

70 "statusLine": {70> "statusLine": {

71 "type": "command",71> "type": "command",

72 "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'",72> "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'",

73 "padding": 273> "padding": 2

74 },74> },

75 // Nascondi i suggerimenti che ruotano sotto lo spinner75> // Nascondi i suggerimenti che ruotano sotto lo spinner

76 "spinnerTipsEnabled": false,76> "spinnerTipsEnabled": false,

77 // Suona il campanello del terminale per le notifiche, come un'attività completata o un prompt di autorizzazione in attesa77> // Suona il campanello del terminale per le notifiche, come un'attività completata o un prompt di autorizzazione in attesa

78 "preferredNotifChannel": "terminal_bell",78> "preferredNotifChannel": "terminal_bell",

79 // Consenti a Claude Code di eseguire git diff e leggere il tuo .zshrc senza chiedere79> // Consenti a Claude Code di eseguire git diff e leggere il tuo .zshrc senza chiedere

80 "permissions": {80> "permissions": {

81 "allow": [81> "allow": [

82 "Bash(git diff *)",82> "Bash(git diff *)",

83 "Read(~/.zshrc)"83> "Read(~/.zshrc)"

84 ]84> ]

85 },85> },

86 // Accetta gli aggiornamenti dal canale stabile86> // Accetta gli aggiornamenti dal canale stabile

87 "autoUpdatesChannel": "stable",87> "autoUpdatesChannel": "stable",

88 // Elimina i trascritti delle sessioni e altri dati locali delle sessioni più vecchi di 20 giorni88> // Elimina i trascritti delle sessioni e altri dati locali delle sessioni più vecchi di 20 giorni

89 "cleanupPeriodDays": 2089> "cleanupPeriodDays": 20

90}90> }

91```91> ```

92 92 

93## Le impostazioni condivise di un team93## Le impostazioni condivise di un team

94 94 

100* **L'hook è uno script nel repo.** L'hook di questo file esegue `.claude/hooks/block-rm.sh`; [How a hook resolves](https://code.claude.com/docs/it/hooks.md#how-a-hook-resolves) illustra come scriverlo.100* **L'hook è uno script nel repo.** L'hook di questo file esegue `.claude/hooks/block-rm.sh`; [How a hook resolves](https://code.claude.com/docs/it/hooks.md#how-a-hook-resolves) illustra come scriverlo.

101* **Le regole corrispondono al comando e al percorso come scritti.** `Bash(git push *)` non corrisponde a [`git -C . push`](https://code.claude.com/docs/it/permissions#bash-rule-limits). `Read(./.env)` da solo interrompe i file tool e i comandi che nominano il file, come `cat .env`, ma non [`grep -r` eseguito sulla directory](https://code.claude.com/docs/it/permissions#read-and-edit); il blocco `sandbox` in questo file colma questa lacuna, perché la sandbox [aggiunge i tuoi percorsi di negazione `Read`](https://code.claude.com/docs/it/settings-reference#sandbox-filesystem-denyread) a ciò che ogni comando in sandbox non può leggere.101* **Le regole corrispondono al comando e al percorso come scritti.** `Bash(git push *)` non corrisponde a [`git -C . push`](https://code.claude.com/docs/it/permissions#bash-rule-limits). `Read(./.env)` da solo interrompe i file tool e i comandi che nominano il file, come `cat .env`, ma non [`grep -r` eseguito sulla directory](https://code.claude.com/docs/it/permissions#read-and-edit); il blocco `sandbox` in questo file colma questa lacuna, perché la sandbox [aggiunge i tuoi percorsi di negazione `Read`](https://code.claude.com/docs/it/settings-reference#sandbox-filesystem-denyread) a ciò che ogni comando in sandbox non può leggere.

102 102 

103**Copyable settings file**103> [tab] Copyable settings file

104 104>

105Salva questo come `.claude/settings.json` nella parte superiore del repository e sottoponi a commit. È JSON valido senza commenti, quindi puoi incollarlo così com'è ed eliminare le chiavi che non desideri.105> Salva questo come `.claude/settings.json` nella parte superiore del repository e sottoponi a commit. È JSON valido senza commenti, quindi puoi incollarlo così com'è ed eliminare le chiavi che non desideri.

106 106>

107```json .claude/settings.json theme={null}107> ```json .claude/settings.json theme={null}

108{108> {

109 "permissions": {109> "permissions": {

110 "allow": [110> "allow": [

111 "Bash(npm run *)"111> "Bash(npm run *)"

112 ],112> ],

113 "ask": [113> "ask": [

114 "Bash(git push *)"114> "Bash(git push *)"

115 ],115> ],

116 "deny": [116> "deny": [

117 "Read(./.env)",117> "Read(./.env)",

118 "Read(./.env.*)",118> "Read(./.env.*)",

119 "Read(./secrets/**)"119> "Read(./secrets/**)"

120 ]120> ]

121 },121> },

122 "hooks": {122> "hooks": {

123 "PreToolUse": [123> "PreToolUse": [

124 {124> {

125 "matcher": "Bash",125> "matcher": "Bash",

126 "hooks": [126> "hooks": [

127 {127> {

128 "type": "command",128> "type": "command",

129 "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh"129> "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh"

130 }130> }

131 ]131> ]

132 }132> }

133 ]133> ]

134 },134> },

135 "extraKnownMarketplaces": {135> "extraKnownMarketplaces": {

136 "acme-tools": {136> "acme-tools": {

137 "source": {137> "source": {

138 "source": "github",138> "source": "github",

139 "repo": "acme-corp/claude-plugins"139> "repo": "acme-corp/claude-plugins"

140 }140> }

141 }141> }

142 },142> },

143 "enabledPlugins": {143> "enabledPlugins": {

144 "code-formatter@acme-tools": true144> "code-formatter@acme-tools": true

145 },145> },

146 "sandbox": {146> "sandbox": {

147 "enabled": true,147> "enabled": true,

148 "filesystem": {148> "filesystem": {

149 "allowWrite": [149> "allowWrite": [

150 "/tmp/build"150> "/tmp/build"

151 ]151> ]

152 },152> },

153 "network": {153> "network": {

154 "allowedDomains": [154> "allowedDomains": [

155 "registry.npmjs.org",155> "registry.npmjs.org",

156 "*.example.com"156> "*.example.com"

157 ]157> ]

158 }158> }

159 },159> },

160 "plansDirectory": "./plans"160> "plansDirectory": "./plans"

161}161> }

162```162> ```

163 163 

164**What each key does**164> [tab] What each key does

165 165>

166Lo stesso file con un commento sopra ogni chiave. Leggilo qui; copia dall'altra scheda, perché Claude Code non accetta commenti in un file di impostazioni.166> Lo stesso file con un commento sopra ogni chiave. Leggilo qui; copia dall'altra scheda, perché Claude Code non accetta commenti in un file di impostazioni.

167 167>

168```jsonc .claude/settings.json theme={null}168> ```jsonc .claude/settings.json theme={null}

169{169> {

170 "permissions": {170> "permissions": {

171 // Esegui gli script npm senza chiedere171> // Esegui gli script npm senza chiedere

172 "allow": [172> "allow": [

173 "Bash(npm run *)"173> "Bash(npm run *)"

174 ],174> ],

175 // Conferma prima dei comandi git push175> // Conferma prima dei comandi git push

176 "ask": [176> "ask": [

177 "Bash(git push *)"177> "Bash(git push *)"

178 ],178> ],

179 // Nega le letture dei file env e della cartella dei segreti da parte degli strumenti per i file e dei comandi che leggono i file179> // Nega le letture dei file env e della cartella dei segreti da parte degli strumenti per i file e dei comandi che leggono i file

180 "deny": [180> "deny": [

181 "Read(./.env)",181> "Read(./.env)",

182 "Read(./.env.*)",182> "Read(./.env.*)",

183 "Read(./secrets/**)"183> "Read(./secrets/**)"

184 ]184> ]

185 },185> },

186 // Prima di ogni comando Bash, esegui uno script nel repo che può bloccarlo186> // Prima di ogni comando Bash, esegui uno script nel repo che può bloccarlo

187 "hooks": {187> "hooks": {

188 "PreToolUse": [188> "PreToolUse": [

189 {189> {

190 "matcher": "Bash",190> "matcher": "Bash",

191 "hooks": [191> "hooks": [

192 {192> {

193 "type": "command",193> "type": "command",

194 "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh"194> "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-rm.sh"

195 }195> }

196 ]196> ]

197 }197> }

198 ]198> ]

199 },199> },

200 // Registra il marketplace di plugin del team su ogni clone200> // Registra il marketplace di plugin del team su ogni clone

201 "extraKnownMarketplaces": {201> "extraKnownMarketplaces": {

202 "acme-tools": {202> "acme-tools": {

203 "source": {203> "source": {

204 "source": "github",204> "source": "github",

205 "repo": "acme-corp/claude-plugins"205> "repo": "acme-corp/claude-plugins"

206 }206> }

207 }207> }

208 },208> },

209 // Abilita un plugin da quel marketplace; un plugin da una fonte esterna come un repository GitHub richiede comunque che ogni persona lo installi una volta209> // Abilita un plugin da quel marketplace; un plugin da una fonte esterna come un repository GitHub richiede comunque che ogni persona lo installi una volta

210 "enabledPlugins": {210> "enabledPlugins": {

211 "code-formatter@acme-tools": true211> "code-formatter@acme-tools": true

212 },212> },

213 // Comandi in sandbox: directory di build scrivibile; npm e example.com pre-autorizzati213> // Comandi in sandbox: directory di build scrivibile; npm e example.com pre-autorizzati

214 "sandbox": {214> "sandbox": {

215 "enabled": true,215> "enabled": true,

216 "filesystem": {216> "filesystem": {

217 "allowWrite": [217> "allowWrite": [

218 "/tmp/build"218> "/tmp/build"

219 ]219> ]

220 },220> },

221 "network": {221> "network": {

222 "allowedDomains": [222> "allowedDomains": [

223 "registry.npmjs.org",223> "registry.npmjs.org",

224 "*.example.com"224> "*.example.com"

225 ]225> ]

226 }226> }

227 },227> },

228 // Mantieni i file di piano all'interno del repo228> // Mantieni i file di piano all'interno del repo

229 "plansDirectory": "./plans"229> "plansDirectory": "./plans"

230}230> }

231```231> ```

232 232 

233## Le impostazioni gestite di un'organizzazione233## Le impostazioni gestite di un'organizzazione

234 234 

247 247 

248Gli amministratori distribuiscono un file come questo come `managed-settings.json`, o lo stesso JSON tramite MDM o [impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md). Un file distribuito si applica a ogni macchina o account che raggiunge. Per dare a un gruppo valori diversi, distribuisci un file o profilo diverso a quel gruppo, poiché [le impostazioni gestite dal server non supportano ancora la politica per gruppo](https://code.claude.com/docs/it/server-managed-settings.md#current-limitations).248Gli amministratori distribuiscono un file come questo come `managed-settings.json`, o lo stesso JSON tramite MDM o [impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md). Un file distribuito si applica a ogni macchina o account che raggiunge. Per dare a un gruppo valori diversi, distribuisci un file o profilo diverso a quel gruppo, poiché [le impostazioni gestite dal server non supportano ancora la politica per gruppo](https://code.claude.com/docs/it/server-managed-settings.md#current-limitations).

249 249 

250**Copyable settings file**250> [tab] Copyable settings file

251 251>

252Distribuisci questo come `managed-settings.json`, o lo stesso JSON tramite MDM o la console claude.ai. È JSON valido senza commenti; sostituisci l'UUID dell'organizzazione di esempio, l'URL del server e il marketplace con i tuoi e elimina le chiavi che non desideri.252> Distribuisci questo come `managed-settings.json`, o lo stesso JSON tramite MDM o la console claude.ai. È JSON valido senza commenti; sostituisci l'UUID dell'organizzazione di esempio, l'URL del server e il marketplace con i tuoi e elimina le chiavi che non desideri.

253 253>

254```json managed-settings.json theme={null}254> ```json managed-settings.json theme={null}

255{255> {

256 "forceLoginMethod": "claudeai",256> "forceLoginMethod": "claudeai",

257 "forceLoginOrgUUID": [257> "forceLoginOrgUUID": [

258 "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"258> "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

259 ],259> ],

260 "availableModels": [260> "availableModels": [

261 "opus",261> "opus",

262 "sonnet"262> "sonnet"

263 ],263> ],

264 "enforceAvailableModels": true,264> "enforceAvailableModels": true,

265 "permissions": {265> "permissions": {

266 "deny": [266> "deny": [

267 "Bash(curl *)",267> "Bash(curl *)",

268 "Read(./.env)",268> "Read(./.env)",

269 "Read(./secrets/**)"269> "Read(./secrets/**)"

270 ],270> ],

271 "disableBypassPermissionsMode": "disable"271> "disableBypassPermissionsMode": "disable"

272 },272> },

273 "allowManagedPermissionRulesOnly": true,273> "allowManagedPermissionRulesOnly": true,

274 "allowedMcpServers": [274> "allowedMcpServers": [

275 {275> {

276 "serverUrl": "https://api.githubcopilot.com/*"276> "serverUrl": "https://api.githubcopilot.com/*"

277 }277> }

278 ],278> ],

279 "allowManagedMcpServersOnly": true,279> "allowManagedMcpServersOnly": true,

280 "strictKnownMarketplaces": [280> "strictKnownMarketplaces": [

281 {281> {

282 "source": "github",282> "source": "github",

283 "repo": "acme-corp/approved-plugins"283> "repo": "acme-corp/approved-plugins"

284 }284> }

285 ],285> ],

286 "sandbox": {286> "sandbox": {

287 "enabled": true,287> "enabled": true,

288 "failIfUnavailable": true,288> "failIfUnavailable": true,

289 "allowUnsandboxedCommands": false,289> "allowUnsandboxedCommands": false,

290 "network": {290> "network": {

291 "allowedDomains": [291> "allowedDomains": [

292 "registry.npmjs.org",292> "registry.npmjs.org",

293 "github.com"293> "github.com"

294 ],294> ],

295 "allowManagedDomainsOnly": true295> "allowManagedDomainsOnly": true

296 }296> }

297 },297> },

298 "requiredMinimumVersion": "2.1.150",298> "requiredMinimumVersion": "2.1.150",

299 "cleanupPeriodDays": 7,299> "cleanupPeriodDays": 7,

300 "companyAnnouncements": [300> "companyAnnouncements": [

301 "Welcome to Acme Corp! Review our code guidelines at docs.example.com"301> "Welcome to Acme Corp! Review our code guidelines at docs.example.com"

302 ]302> ]

303}303> }

304```304> ```

305 305 

306**What each key does**306> [tab] What each key does

307 307>

308Lo stesso file con un commento sopra ogni chiave. Leggilo qui; copia dall'altra scheda, perché Claude Code non accetta commenti in un file di impostazioni.308> Lo stesso file con un commento sopra ogni chiave. Leggilo qui; copia dall'altra scheda, perché Claude Code non accetta commenti in un file di impostazioni.

309 309>

310```jsonc managed-settings.json theme={null}310> ```jsonc managed-settings.json theme={null}

311{311> {

312 // Solo accessi claude.ai, e solo in questa organizzazione312> // Solo accessi claude.ai, e solo in questa organizzazione

313 "forceLoginMethod": "claudeai",313> "forceLoginMethod": "claudeai",

314 "forceLoginOrgUUID": [314> "forceLoginOrgUUID": [

315 "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"315> "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

316 ],316> ],

317 // Solo modelli Opus e Sonnet; con enforceAvailableModels, l'opzione Predefinito obbedisce anche alla lista317> // Solo modelli Opus e Sonnet; con enforceAvailableModels, l'opzione Predefinito obbedisce anche alla lista

318 "availableModels": [318> "availableModels": [

319 "opus",319> "opus",

320 "sonnet"320> "sonnet"

321 ],321> ],

322 "enforceAvailableModels": true,322> "enforceAvailableModels": true,

323 "permissions": {323> "permissions": {

324 // Blocca curl, il file .env del progetto e la sua cartella dei segreti su ogni macchina324> // Blocca curl, il file .env del progetto e la sua cartella dei segreti su ogni macchina

325 "deny": [325> "deny": [

326 "Bash(curl *)",326> "Bash(curl *)",

327 "Read(./.env)",327> "Read(./.env)",

328 "Read(./secrets/**)"328> "Read(./secrets/**)"

329 ],329> ],

330 // Rimuovi la modalità di bypass delle autorizzazioni da ogni sessione330> // Rimuovi la modalità di bypass delle autorizzazioni da ogni sessione

331 "disableBypassPermissionsMode": "disable"331> "disableBypassPermissionsMode": "disable"

332 },332> },

333 // Ignora le regole di autorizzazione dalle impostazioni utente, progetto e locali333> // Ignora le regole di autorizzazione dalle impostazioni utente, progetto e locali

334 "allowManagedPermissionRulesOnly": true,334> "allowManagedPermissionRulesOnly": true,

335 // Solo il server MCP GitHub, abbinato per URL piuttosto che per nome, poiché un utente può335> // Solo il server MCP GitHub, abbinato per URL piuttosto che per nome, poiché un utente può

336 // nominare qualsiasi server "github". I server aggiunti dall'utente che non corrispondono non si caricano, incluso336> // nominare qualsiasi server "github". I server aggiunti dall'utente che non corrispondono non si caricano, incluso

337 // ogni server stdio quando la lista ha solo voci URL. La chiave allowManagedMcpServersOnly337> // ogni server stdio quando la lista ha solo voci URL. La chiave allowManagedMcpServersOnly

338 // sotto rende questa lista gestita l'unica lista di autorizzazione che si applica338> // sotto rende questa lista gestita l'unica lista di autorizzazione che si applica

339 "allowedMcpServers": [339> "allowedMcpServers": [

340 {340> {

341 "serverUrl": "https://api.githubcopilot.com/*"341> "serverUrl": "https://api.githubcopilot.com/*"

342 }342> }

343 ],343> ],

344 "allowManagedMcpServersOnly": true,344> "allowManagedMcpServersOnly": true,

345 // I plugin possono provenire solo da questo marketplace345> // I plugin possono provenire solo da questo marketplace

346 "strictKnownMarketplaces": [346> "strictKnownMarketplaces": [

347 {347> {

348 "source": "github",348> "source": "github",

349 "repo": "acme-corp/approved-plugins"349> "repo": "acme-corp/approved-plugins"

350 }350> }

351 ],351> ],

352 // Esegui il sandboxing di ogni comando che Claude esegue, rifiuta di avviare se il sandbox non può essere352> // Esegui il sandboxing di ogni comando che Claude esegue, rifiuta di avviare se il sandbox non può essere

353 // configurato, e non consentire mai a un comando bloccato di riprovare al di fuori del sandbox; la rete353> // configurato, e non consentire mai a un comando bloccato di riprovare al di fuori del sandbox; la rete

354 // limitata a npm e GitHub, e gli utenti non possono aggiungere domini354> // limitata a npm e GitHub, e gli utenti non possono aggiungere domini

355 "sandbox": {355> "sandbox": {

356 "enabled": true,356> "enabled": true,

357 "failIfUnavailable": true,357> "failIfUnavailable": true,

358 "allowUnsandboxedCommands": false,358> "allowUnsandboxedCommands": false,

359 "network": {359> "network": {

360 "allowedDomains": [360> "allowedDomains": [

361 "registry.npmjs.org",361> "registry.npmjs.org",

362 "github.com"362> "github.com"

363 ],363> ],

364 "allowManagedDomainsOnly": true364> "allowManagedDomainsOnly": true

365 }365> }

366 },366> },

367 // Rifiuta di avviare su versioni più vecchie di 2.1.150367> // Rifiuta di avviare su versioni più vecchie di 2.1.150

368 "requiredMinimumVersion": "2.1.150",368> "requiredMinimumVersion": "2.1.150",

369 // Elimina i trascritti delle sessioni e altri dati locali delle sessioni dopo 7 giorni369> // Elimina i trascritti delle sessioni e altri dati locali delle sessioni dopo 7 giorni

370 "cleanupPeriodDays": 7,370> "cleanupPeriodDays": 7,

371 // Un messaggio che ogni utente vede all'avvio371> // Un messaggio che ogni utente vede all'avvio

372 "companyAnnouncements": [372> "companyAnnouncements": [

373 "Welcome to Acme Corp! Review our code guidelines at docs.example.com"373> "Welcome to Acme Corp! Review our code guidelines at docs.example.com"

374 ]374> ]

375}375> }

376```376> ```

Details

3865* **Type**: Boolean3865* **Type**: Boolean

3866 * `true`: Claude Code consente i channel per la tua organizzazione3866 * `true`: Claude Code consente i channel per la tua organizzazione

3867 * `false`: lo stesso di non impostato; se i channel sono bloccati dipende dal tuo piano, come dice il Default3867 * `false`: lo stesso di non impostato; se i channel sono bloccati dipende dal tuo piano, come dice il Default

3868* **Default**: non impostato; i channel sono bloccati nei piani Team e Enterprise e negli account Console con impostazioni gestite, e consentiti nei piani Pro e Max e negli account Console senza impostazioni gestite3868* **Default**: non impostato; i canali sono bloccati nei piani Team e Enterprise e negli account Console con impostazioni gestite, e consentiti nei piani Pro, Max e Ultra e negli account Console senza impostazioni gestite

3869 3869 

3870```json managed-settings.json theme={null}3870```json managed-settings.json theme={null}

3871{3871{

setup.md +251 −251

Details

35 35 

36Per installare Claude Code, apri un terminale ed esegui il comando per il tuo sistema. Se non hai mai utilizzato un terminale prima, la [guida al terminale](https://code.claude.com/docs/it/terminal-guide) mostra come aprirne uno e incollare il comando.36Per installare Claude Code, apri un terminale ed esegui il comando per il tuo sistema. Se non hai mai utilizzato un terminale prima, la [guida al terminale](https://code.claude.com/docs/it/terminal-guide) mostra come aprirne uno e incollare il comando.

37 37 

38**Installazione nativa (consigliata)**38> [tab] Installazione nativa (consigliata)

39 

40**macOS, Linux, WSL:**

41 

42```bash theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}

43curl -fsSL https://claude.ai/install.sh | bash

44```

45 

46Su Windows, il tuo prompt mostra `PS C:\` quando sei in PowerShell e `C:\` senza il `PS` quando sei in CMD.

47 

48**Windows PowerShell:**

49 

50```powershell theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}

51irm https://claude.ai/install.ps1 | iex

52```

53 

54**Windows CMD:**

55 

56```batch theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}

57curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

58```

59 

60Il comando di installazione non mostra alcun avanzamento mentre scarica Claude Code. Quando il programma di installazione termina, apri una nuova finestra del terminale ed esegui `claude --version`. Un'installazione funzionante stampa un numero di versione. Se la tua shell dice che `claude` non è trovato o non è riconosciuto, la directory di installazione non è ancora nel tuo PATH: vedi [Correggi il tuo PATH](https://code.claude.com/docs/it/troubleshoot-install.md#command-not-found-claude-after-installation).

61 

62Se vedi `The token '&&' is not a valid statement separator`, sei in PowerShell, non in CMD. Se vedi `'irm' is not recognized as an internal or external command`, sei in CMD, non in PowerShell.

63 

64Se il comando di installazione non riesce con `syntax error near unexpected token '<'`, un `403` o qualsiasi altro errore, consulta [Risoluzione dei problemi di installazione](https://code.claude.com/docs/it/troubleshoot-install.md#find-your-error) per abbinare l'errore a una soluzione e per metodi di installazione alternativi.

65 

66[Git for Windows](https://git-scm.com/downloads/win) è consigliato su Windows nativo in modo che Claude Code possa utilizzare lo strumento Bash. Se Git for Windows non è installato, Claude Code utilizza PowerShell come strumento shell. Le configurazioni WSL non necessitano di Git for Windows.

67 

68> [!NOTE]

69>39>

70> Le installazioni native si aggiornano automaticamente in background per mantenerti sulla versione più recente.40> **macOS, Linux, WSL:**

71 

72**Homebrew**

73 

74```bash theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}

75brew install --cask claude-code

76```

77 

78Homebrew offre due cask. `claude-code` traccia il canale di rilascio stabile, che in genere è circa una settimana indietro e salta i rilasci con regressioni importanti. `claude-code@latest` traccia il canale più recente e riceve nuove versioni non appena vengono rilasciate.

79 

80> [!NOTE]

81>41>

82> Le installazioni Homebrew non si aggiornano automaticamente. Esegui `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask hai installato, per ottenere le funzionalità più recenti e le correzioni di sicurezza.42> ```bash theme={null}

83 43> curl -fsSL https://claude.ai/install.sh | bash

84**WinGet**44> ```

45>

46> Su Windows, il tuo prompt mostra `PS C:\` quando sei in PowerShell e `C:\` senza il `PS` quando sei in CMD.

47>

48> **Windows PowerShell:**

49>

50> ```powershell theme={null}

51> irm https://claude.ai/install.ps1 | iex

52> ```

53>

54> **Windows CMD:**

55>

56> ```batch theme={null}

57> curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

58> ```

59>

60> Il comando di installazione non mostra alcun avanzamento mentre scarica Claude Code. Quando il programma di installazione termina, apri una nuova finestra del terminale ed esegui `claude --version`. Un'installazione funzionante stampa un numero di versione. Se la tua shell dice che `claude` non è trovato o non è riconosciuto, la directory di installazione non è ancora nel tuo PATH: vedi [Correggi il tuo PATH](https://code.claude.com/docs/it/troubleshoot-install.md#command-not-found-claude-after-installation).

61>

62> Se vedi `The token '&&' is not a valid statement separator`, sei in PowerShell, non in CMD. Se vedi `'irm' is not recognized as an internal or external command`, sei in CMD, non in PowerShell.

63>

64> Se il comando di installazione non riesce con `syntax error near unexpected token '<'`, un `403` o qualsiasi altro errore, consulta [Risoluzione dei problemi di installazione](https://code.claude.com/docs/it/troubleshoot-install.md#find-your-error) per abbinare l'errore a una soluzione e per metodi di installazione alternativi.

65>

66> [Git for Windows](https://git-scm.com/downloads/win) è consigliato su Windows nativo in modo che Claude Code possa utilizzare lo strumento Bash. Se Git for Windows non è installato, Claude Code utilizza PowerShell come strumento shell. Le configurazioni WSL non necessitano di Git for Windows.

67>

68> > [!NOTE]

69> >

70> > Le installazioni native si aggiornano automaticamente in background per mantenerti sulla versione più recente.

85 71 

86```powershell theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null} theme={null}72> [tab] Homebrew

87winget install Anthropic.ClaudeCode73>

88```74> ```bash theme={null}

75> brew install --cask claude-code

76> ```

77>

78> Homebrew offre due cask. `claude-code` traccia il canale di rilascio stabile, che in genere è circa una settimana indietro e salta i rilasci con regressioni importanti. `claude-code@latest` traccia il canale più recente e riceve nuove versioni non appena vengono rilasciate.

79>

80> > [!NOTE]

81> >

82> > Le installazioni Homebrew non si aggiornano automaticamente. Esegui `brew upgrade claude-code` o `brew upgrade claude-code@latest`, a seconda di quale cask hai installato, per ottenere le funzionalità più recenti e le correzioni di sicurezza.

89 83 

90> [!NOTE]84> [tab] WinGet

85>

86> ```powershell theme={null}

87> winget install Anthropic.ClaudeCode

88> ```

91>89>

92> Le installazioni WinGet non si aggiornano automaticamente. Esegui `winget upgrade Anthropic.ClaudeCode` periodicamente per ottenere le funzionalità più recenti e le correzioni di sicurezza.90> > [!NOTE]

91> >

92> > Le installazioni WinGet non si aggiornano automaticamente. Esegui `winget upgrade Anthropic.ClaudeCode` periodicamente per ottenere le funzionalità più recenti e le correzioni di sicurezza.

93 93 

94Puoi anche installare con [apt, dnf, o apk](https://code.claude.com/docs/it/setup.md#install-with-linux-package-managers) su Debian, Fedora, RHEL e Alpine.94Puoi anche installare con [apt, dnf, o apk](https://code.claude.com/docs/it/setup.md#install-with-linux-package-managers) su Debian, Fedora, RHEL e Alpine.

95 95 

188 188 

189## Autenticazione189## Autenticazione

190 190 

191Claude Code richiede un account Pro, Max, Team, Enterprise o Console. Il piano gratuito di Claude.ai non include l'accesso a Claude Code. Potete anche utilizzare Claude Code con un provider API di terze parti come [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md) o [Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md).191Claude Code richiede un account Pro, Max, Ultra, Team, Enterprise o Console. Il piano gratuito di claude.ai non include l'accesso a Claude Code. Puoi anche utilizzare Claude Code con un provider API di terze parti come [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md), [Google Cloud's Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md) o [Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md).

192 192 

193Dopo l'installazione, accedi eseguendo `claude` e seguendo i prompt del browser. Se hai impostato la variabile d'ambiente `ANTHROPIC_API_KEY` e approvi la chiave quando Claude Code ti chiede se utilizzarla, Claude Code salta il prompt di accesso. Consulta [Autenticazione](https://code.claude.com/docs/it/authentication.md) per tutti i tipi di account e le opzioni di configurazione del team.193Dopo l'installazione, accedi eseguendo `claude` e seguendo i prompt del browser. Se hai impostato la variabile d'ambiente `ANTHROPIC_API_KEY` e approvi la chiave quando Claude Code ti chiede se utilizzarla, Claude Code salta il prompt di accesso. Consulta [Autenticazione](https://code.claude.com/docs/it/authentication.md) per tutti i tipi di account e le opzioni di configurazione del team.

194 194 

300 300 

301Per installare la versione più recente (predefinita):301Per installare la versione più recente (predefinita):

302 302 

303**macOS, Linux, WSL**303> [tab] macOS, Linux, WSL

304 304>

305```bash theme={null}305> ```bash theme={null}

306curl -fsSL https://claude.ai/install.sh | bash306> curl -fsSL https://claude.ai/install.sh | bash

307```307> ```

308 

309**Windows PowerShell**

310 

311```powershell theme={null}

312irm https://claude.ai/install.ps1 | iex

313```

314 308 

315**Windows CMD**309> [tab] Windows PowerShell

310>

311> ```powershell theme={null}

312> irm https://claude.ai/install.ps1 | iex

313> ```

316 314 

317```batch theme={null}315> [tab] Windows CMD

318curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd316>

319```317> ```batch theme={null}

318> curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

319> ```

320 320 

321Per installare la versione stabile:321Per installare la versione stabile:

322 322 

323**macOS, Linux, WSL**323> [tab] macOS, Linux, WSL

324 324>

325```bash theme={null}325> ```bash theme={null}

326curl -fsSL https://claude.ai/install.sh | bash -s stable326> curl -fsSL https://claude.ai/install.sh | bash -s stable

327```327> ```

328 

329**Windows PowerShell**

330 

331```powershell theme={null}

332& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) stable

333```

334 328 

335**Windows CMD**329> [tab] Windows PowerShell

330>

331> ```powershell theme={null}

332> & ([scriptblock]::Create((irm https://claude.ai/install.ps1))) stable

333> ```

336 334 

337```batch theme={null}335> [tab] Windows CMD

338curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd stable && del install.cmd336>

339```337> ```batch theme={null}

338> curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd stable && del install.cmd

339> ```

340 340 

341Per installare un numero di versione specifico:341Per installare un numero di versione specifico:

342 342 

343**macOS, Linux, WSL**343> [tab] macOS, Linux, WSL

344 344>

345```bash theme={null}345> ```bash theme={null}

346curl -fsSL https://claude.ai/install.sh | bash -s 2.1.89346> curl -fsSL https://claude.ai/install.sh | bash -s 2.1.89

347```347> ```

348 

349**Windows PowerShell**

350 

351```powershell theme={null}

352& ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 2.1.89

353```

354 348 

355**Windows CMD**349> [tab] Windows PowerShell

350>

351> ```powershell theme={null}

352> & ([scriptblock]::Create((irm https://claude.ai/install.ps1))) 2.1.89

353> ```

356 354 

357```batch theme={null}355> [tab] Windows CMD

358curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd 2.1.89 && del install.cmd356>

359```357> ```batch theme={null}

358> curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd 2.1.89 && del install.cmd

359> ```

360 360 

361Per confermare quale versione è stata installata, eseguite `claude --version`: il comando stampa la versione esatta che avete passato, come ad esempio `2.1.89 (Claude Code)`.361Per confermare quale versione è stata installata, eseguite `claude --version`: il comando stampa la versione esatta che avete passato, come ad esempio `2.1.89 (Claude Code)`.

362 362 

366 366 

367Tutti i repository sono firmati con la [chiave di firma del rilascio di Claude Code](#binary-integrity-and-code-signing). Prima di fidarvi della chiave, verificatela come descritto in ogni scheda.367Tutti i repository sono firmati con la [chiave di firma del rilascio di Claude Code](#binary-integrity-and-code-signing). Prima di fidarvi della chiave, verificatela come descritto in ogni scheda.

368 368 

369**apt**369> [tab] apt

370 370>

371Per Debian e Ubuntu. I comandi di installazione seguenti scaricano la chiave di firma con `curl` e la verificano con `gpg`, che le installazioni fresche di Debian e Ubuntu potrebbero non includere. Se uno dei due comandi riporta `command not found`, installate prima entrambi:371> Per Debian e Ubuntu. I comandi di installazione seguenti scaricano la chiave di firma con `curl` e la verificano con `gpg`, che le installazioni fresche di Debian e Ubuntu potrebbero non includere. Se uno dei due comandi riporta `command not found`, installate prima entrambi:

372 372>

373```bash theme={null}373> ```bash theme={null}

374sudo apt install curl gnupg374> sudo apt install curl gnupg

375```375> ```

376 376>

377Scaricate la chiave di firma:377> Scaricate la chiave di firma:

378 378>

379```bash theme={null}379> ```bash theme={null}

380sudo install -d -m 0755 /etc/apt/keyrings380> sudo install -d -m 0755 /etc/apt/keyrings

381sudo curl -fsSL https://downloads.claude.ai/keys/claude-code.asc \381> sudo curl -fsSL https://downloads.claude.ai/keys/claude-code.asc \

382 -o /etc/apt/keyrings/claude-code.asc382> -o /etc/apt/keyrings/claude-code.asc

383```383> ```

384 384>

385Se questo download fallisce, `apt update` in seguito fallisce con `NO_PUBKEY BAA929FF1A7ECACE`. Confermate che la chiave sia stata scaricata e appartenga ad Anthropic prima di continuare:385> Se questo download fallisce, `apt update` in seguito fallisce con `NO_PUBKEY BAA929FF1A7ECACE`. Confermate che la chiave sia stata scaricata e appartenga ad Anthropic prima di continuare:

386 386>

387```bash theme={null}387> ```bash theme={null}

388gpg --show-keys /etc/apt/keyrings/claude-code.asc388> gpg --show-keys /etc/apt/keyrings/claude-code.asc

389```389> ```

390 390>

391L'impronta digitale che gpg stampa dovrebbe essere `31DDDE24DDFAB679F42D7BD2BAA929FF1A7ECACE`. Se gpg riporta che il file non può essere aperto o non contiene dati OpenPGP validi, il download è fallito o ha restituito il contenuto sbagliato: confermate che la vostra rete possa raggiungere `downloads.claude.ai`, quindi rieseguite il comando di download.391> L'impronta digitale che gpg stampa dovrebbe essere `31DDDE24DDFAB679F42D7BD2BAA929FF1A7ECACE`. Se gpg riporta che il file non può essere aperto o non contiene dati OpenPGP validi, il download è fallito o ha restituito il contenuto sbagliato: confermate che la vostra rete possa raggiungere `downloads.claude.ai`, quindi rieseguite il comando di download.

392 392>

393Registrate il repository sul canale `stable` e installate:393> Registrate il repository sul canale `stable` e installate:

394 394>

395```bash theme={null}395> ```bash theme={null}

396echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/stable stable main" \396> echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/stable stable main" \

397 | sudo tee /etc/apt/sources.list.d/claude-code.list397> | sudo tee /etc/apt/sources.list.d/claude-code.list

398sudo apt update398> sudo apt update

399sudo apt install claude-code399> sudo apt install claude-code

400```400> ```

401 401>

402Per utilizzare il canale `latest` invece, sia il percorso dell'URL che il nome della suite cambiano. Utilizzate questa riga `deb`:402> Per utilizzare il canale `latest` invece, sia il percorso dell'URL che il nome della suite cambiano. Utilizzate questa riga `deb`:

403 403>

404```bash theme={null}404> ```bash theme={null}

405echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/latest latest main" \405> echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/latest latest main" \

406 | sudo tee /etc/apt/sources.list.d/claude-code.list406> | sudo tee /etc/apt/sources.list.d/claude-code.list

407```407> ```

408 408>

409Per aggiornare in seguito, eseguite `sudo apt update && sudo apt upgrade claude-code`.409> Per aggiornare in seguito, eseguite `sudo apt update && sudo apt upgrade claude-code`.

410 

411**dnf**

412 

413Per Fedora e RHEL. I comandi seguenti configurano il canale `stable`:

414 

415```bash theme={null}

416sudo tee /etc/yum.repos.d/claude-code.repo <<'EOF'

417[claude-code]

418name=Claude Code

419baseurl=https://downloads.claude.ai/claude-code/rpm/stable

420enabled=1

421gpgcheck=1

422gpgkey=https://downloads.claude.ai/keys/claude-code.asc

423EOF

424sudo dnf install claude-code

425```

426 

427Per utilizzare il canale `latest` invece, impostate `baseurl` al repository `latest`:

428 

429```ini theme={null}

430baseurl=https://downloads.claude.ai/claude-code/rpm/latest

431```

432 

433dnf scarica la chiave al primo install e vi chiede di confermare l'impronta digitale. Verificate che corrisponda a `31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE` prima di accettare.

434 

435Per aggiornare in seguito, eseguite `sudo dnf upgrade claude-code`.

436 

437**apk**

438 

439Per Alpine Linux. I comandi seguenti configurano il canale `stable`:

440 

441```sh theme={null}

442wget -O /etc/apk/keys/claude-code.rsa.pub \

443 https://downloads.claude.ai/keys/claude-code.rsa.pub

444echo "https://downloads.claude.ai/claude-code/apk/stable" >> /etc/apk/repositories

445apk add claude-code

446```

447 

448Per passare al canale `latest`, rimuovete la riga del repository `stable` e aggiungete il repository `latest`:

449 

450```sh theme={null}

451sed -i '\|downloads.claude.ai/claude-code/apk/stable|d' /etc/apk/repositories

452echo "https://downloads.claude.ai/claude-code/apk/latest" >> /etc/apk/repositories

453```

454 410 

455Verificate la chiave scaricata con `sha256sum /etc/apk/keys/claude-code.rsa.pub`, che dovrebbe riportare `395759c1f7449ef4cdef305a42e820f3c766d6090d142634ebdb049f113168b6`.411> [tab] dnf

412>

413> Per Fedora e RHEL. I comandi seguenti configurano il canale `stable`:

414>

415> ```bash theme={null}

416> sudo tee /etc/yum.repos.d/claude-code.repo <<'EOF'

417> [claude-code]

418> name=Claude Code

419> baseurl=https://downloads.claude.ai/claude-code/rpm/stable

420> enabled=1

421> gpgcheck=1

422> gpgkey=https://downloads.claude.ai/keys/claude-code.asc

423> EOF

424> sudo dnf install claude-code

425> ```

426>

427> Per utilizzare il canale `latest` invece, impostate `baseurl` al repository `latest`:

428>

429> ```ini theme={null}

430> baseurl=https://downloads.claude.ai/claude-code/rpm/latest

431> ```

432>

433> dnf scarica la chiave al primo install e vi chiede di confermare l'impronta digitale. Verificate che corrisponda a `31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE` prima di accettare.

434>

435> Per aggiornare in seguito, eseguite `sudo dnf upgrade claude-code`.

456 436 

457Per aggiornare in seguito, eseguite `apk update && apk upgrade claude-code`.437> [tab] apk

438>

439> Per Alpine Linux. I comandi seguenti configurano il canale `stable`:

440>

441> ```sh theme={null}

442> wget -O /etc/apk/keys/claude-code.rsa.pub \

443> https://downloads.claude.ai/keys/claude-code.rsa.pub

444> echo "https://downloads.claude.ai/claude-code/apk/stable" >> /etc/apk/repositories

445> apk add claude-code

446> ```

447>

448> Per passare al canale `latest`, rimuovete la riga del repository `stable` e aggiungete il repository `latest`:

449>

450> ```sh theme={null}

451> sed -i '\|downloads.claude.ai/claude-code/apk/stable|d' /etc/apk/repositories

452> echo "https://downloads.claude.ai/claude-code/apk/latest" >> /etc/apk/repositories

453> ```

454>

455> Verificate la chiave scaricata con `sha256sum /etc/apk/keys/claude-code.rsa.pub`, che dovrebbe riportare `395759c1f7449ef4cdef305a42e820f3c766d6090d142634ebdb049f113168b6`.

456>

457> Per aggiornare in seguito, eseguite `apk update && apk upgrade claude-code`.

458 458 

459### Installare con npm459### Installare con npm

460 460 

546 546 

547Confrontate il checksum SHA256 del binario con il valore elencato sotto `platforms.<platform>.checksum` in `manifest.json`. I comandi seguenti presuppongono un binario `claude` nella directory corrente. Per verificare un binario nativo installato invece, eseguite il comando rispetto a `~/.local/share/claude/versions/VERSION`, sostituendo VERSION con il rilascio che avete impostato nel Passaggio 2.547Confrontate il checksum SHA256 del binario con il valore elencato sotto `platforms.<platform>.checksum` in `manifest.json`. I comandi seguenti presuppongono un binario `claude` nella directory corrente. Per verificare un binario nativo installato invece, eseguite il comando rispetto a `~/.local/share/claude/versions/VERSION`, sostituendo VERSION con il rilascio che avete impostato nel Passaggio 2.

548 548 

549**Linux**549> [tab] Linux

550 550>

551```bash theme={null}551> ```bash theme={null}

552sha256sum claude552> sha256sum claude

553```553> ```

554 

555**macOS**

556 

557```bash theme={null}

558shasum -a 256 claude

559```

560 554 

561**Windows PowerShell**555> [tab] macOS

556>

557> ```bash theme={null}

558> shasum -a 256 claude

559> ```

562 560 

563```powershell theme={null}561> [tab] Windows PowerShell

564(Get-FileHash claude.exe -Algorithm SHA256).Hash.ToLower()562>

565```563> ```powershell theme={null}

564> (Get-FileHash claude.exe -Algorithm SHA256).Hash.ToLower()

565> ```

566 566 

567> [!NOTE]567> [!NOTE]

568>568>

584 584 

585Rimuovete il binario di Claude Code e i file di versione:585Rimuovete il binario di Claude Code e i file di versione:

586 586 

587**macOS, Linux, WSL**587> [tab] macOS, Linux, WSL

588 588>

589```bash theme={null}589> ```bash theme={null}

590rm -f ~/.local/bin/claude590> rm -f ~/.local/bin/claude

591rm -rf ~/.local/share/claude591> rm -rf ~/.local/share/claude

592```592> ```

593 

594**Windows PowerShell**

595 593 

596```powershell theme={null}594> [tab] Windows PowerShell

597Remove-Item -Path "$env:USERPROFILE\.local\bin\claude.exe" -Force595>

598Remove-Item -Path "$env:USERPROFILE\.local\share\claude" -Recurse -Force596> ```powershell theme={null}

599```597> Remove-Item -Path "$env:USERPROFILE\.local\bin\claude.exe" -Force

598> Remove-Item -Path "$env:USERPROFILE\.local\share\claude" -Recurse -Force

599> ```

600 600 

601### Disinstallare con Homebrew601### Disinstallare con Homebrew

602 602 

624 624 

625Rimuovete il pacchetto e la configurazione del repository:625Rimuovete il pacchetto e la configurazione del repository:

626 626 

627**apt**627> [tab] apt

628 628>

629```bash theme={null}629> ```bash theme={null}

630sudo apt remove claude-code630> sudo apt remove claude-code

631sudo rm /etc/apt/sources.list.d/claude-code.list /etc/apt/keyrings/claude-code.asc631> sudo rm /etc/apt/sources.list.d/claude-code.list /etc/apt/keyrings/claude-code.asc

632```632> ```

633 

634**dnf**

635 

636```bash theme={null}

637sudo dnf remove claude-code

638sudo rm /etc/yum.repos.d/claude-code.repo

639```

640 633 

641**apk**634> [tab] dnf

635>

636> ```bash theme={null}

637> sudo dnf remove claude-code

638> sudo rm /etc/yum.repos.d/claude-code.repo

639> ```

642 640 

643```sh theme={null}641> [tab] apk

644apk del claude-code642>

645sed -i '\|downloads.claude.ai/claude-code/apk|d' /etc/apk/repositories643> ```sh theme={null}

646rm /etc/apk/keys/claude-code.rsa.pub644> apk del claude-code

647```645> sed -i '\|downloads.claude.ai/claude-code/apk|d' /etc/apk/repositories

646> rm /etc/apk/keys/claude-code.rsa.pub

647> ```

648 648 

649### Disinstallare con npm649### Disinstallare con npm

650 650 

664 664 

665Per rimuovere le impostazioni di Claude Code e i dati memorizzati nella cache:665Per rimuovere le impostazioni di Claude Code e i dati memorizzati nella cache:

666 666 

667**macOS, Linux, WSL**667> [tab] macOS, Linux, WSL

668 668>

669```bash theme={null}669> ```bash theme={null}

670# Rimuovere le impostazioni utente e lo stato670> # Rimuovere le impostazioni utente e lo stato

671rm -rf ~/.claude671> rm -rf ~/.claude

672rm ~/.claude.json672> rm ~/.claude.json

673 673>

674# Rimuovere le impostazioni specifiche del progetto (eseguire dalla directory del progetto)674> # Rimuovere le impostazioni specifiche del progetto (eseguire dalla directory del progetto)

675rm -rf .claude675> rm -rf .claude

676rm -f .mcp.json676> rm -f .mcp.json

677```677> ```

678 

679**Windows PowerShell**

680 

681```powershell theme={null}

682# Rimuovere le impostazioni utente e lo stato

683Remove-Item -Path "$env:USERPROFILE\.claude" -Recurse -Force

684Remove-Item -Path "$env:USERPROFILE\.claude.json" -Force

685 678 

686# Rimuovere le impostazioni specifiche del progetto (eseguire dalla directory del progetto)679> [tab] Windows PowerShell

687Remove-Item -Path ".claude" -Recurse -Force680>

688Remove-Item -Path ".mcp.json" -Force681> ```powershell theme={null}

689```682> # Rimuovere le impostazioni utente e lo stato

683> Remove-Item -Path "$env:USERPROFILE\.claude" -Recurse -Force

684> Remove-Item -Path "$env:USERPROFILE\.claude.json" -Force

685>

686> # Rimuovere le impostazioni specifiche del progetto (eseguire dalla directory del progetto)

687> Remove-Item -Path ".claude" -Recurse -Force

688> Remove-Item -Path ".mcp.json" -Force

689> ```

skills.md +1 −1

Details

42* **Estensioni**: skill, server MCP e plugin inutilizzati confrontati con il loro costo in termini di contesto, e [hook](https://code.claude.com/docs/it/hooks.md) lenti42* **Estensioni**: skill, server MCP e plugin inutilizzati confrontati con il loro costo in termini di contesto, e [hook](https://code.claude.com/docs/it/hooks.md) lenti

43* **File `CLAUDE.md`**: file `CLAUDE.md` locali che duplicano quelli archiviati nel repository, [contenuto di `CLAUDE.md` archiviato che Claude potrebbe ricavare dal codebase](https://code.claude.com/docs/it/memory#my-claude-md-is-too-large) e le indicazioni sempre caricate che rimangono, che Claude propone di migrare in skill e in file `CLAUDE.md` annidati caricati su richiesta43* **File `CLAUDE.md`**: file `CLAUDE.md` locali che duplicano quelli archiviati nel repository, [contenuto di `CLAUDE.md` archiviato che Claude potrebbe ricavare dal codebase](https://code.claude.com/docs/it/memory#my-claude-md-is-too-large) e le indicazioni sempre caricate che rimangono, che Claude propone di migrare in skill e in file `CLAUDE.md` annidati caricati su richiesta

44* **Permessi**: una proposta per rendere la [modalità auto](https://code.claude.com/docs/it/permissions.md#permission-modes) la tua modalità di permesso predefinita e per [pre-approvare](https://code.claude.com/docs/it/permissions.md) i comandi di sola lettura che neghi frequentemente44* **Permessi**: una proposta per rendere la [modalità auto](https://code.claude.com/docs/it/permissions.md#permission-modes) la tua modalità di permesso predefinita e per [pre-approvare](https://code.claude.com/docs/it/permissions.md) i comandi di sola lettura che neghi frequentemente

45* **Utilizzo**: con un piano Pro, Max, Team o Enterprise, le [modifiche consigliate da `/usage`](https://code.claude.com/docs/it/costs#plan-usage-breakdown) per ridurre l'utilizzo del tuo piano, misurato negli ultimi 7 giorni. Claude propone le modifiche che può apportare autonomamente e riporta le altre come consigli, ad esempio un comando da eseguire. Il controllo dell'utilizzo richiede Claude Code v2.1.305 o versioni successive, e `/doctor` lo omette mentre [Remote Control](https://code.claude.com/docs/it/remote-control.md) è connesso.45* **Utilizzo**: con un piano Pro, Max, Ultra, Team o Enterprise, le [modifiche consigliate da `/usage`](https://code.claude.com/docs/it/costs#plan-usage-breakdown) per ridurre l'utilizzo del tuo piano, misurato negli ultimi 7 giorni. Claude propone le modifiche che può apportare autonomamente e riporta le altre come consigli, ad esempio un comando da eseguire. Il controllo dell'utilizzo richiede Claude Code v2.1.305 o versioni successive, e `/doctor` lo omette mentre [Remote Control](https://code.claude.com/docs/it/remote-control.md) è connesso.

46 46 

47Per una diagnostica dell'installazione di sola lettura senza avviare una sessione, esegui invece `claude doctor` nel terminale.47Per una diagnostica dell'installazione di sola lettura senza avviare una sessione, esegui invece `claude doctor` nel terminale.

48 48 

slack.md +11 −11

Details

4 4 

5# Claude Code in Slack5# Claude Code in Slack

6 6 

7> Delega i compiti di codifica da Slack. Questa versione precedente risponde alle menzioni nei canali solo da account Pro e Max in workspace non connessi a Claude Tag.7> Delega i compiti di codifica da Slack. Questa versione precedente risponde alle menzioni solo da account Pro, Max e Ultra in workspace non connessi a Claude Tag.

8 8 

9> [!WARNING]9> [!WARNING]

10>10>

11> Questa pagina documenta la versione precedente di Claude Code in Slack, che esegue ogni sessione con l'account di un singolo utente. Risponde alle @menzioni nei canali solo da account Pro e Max, e solo in un workspace Slack che nessuna organizzazione ha connesso a [Claude Tag](https://claude.com/product/tag). Claude Tag esegue @Claude come identità condivisa della tua organizzazione con accesso configurato dall'amministratore.11> Questa versione precedente di Claude Code in Slack risponde alle @menzioni nei canali solo da account Pro, Max e Ultra, e solo in un workspace Slack che nessuna organizzazione ha connesso a [Claude Tag](https://claude.com/product/tag). Ogni sessione viene eseguita con l'account di un singolo utente. Claude Tag esegue @Claude come identità condivisa della tua organizzazione con accesso configurato dall'amministratore.

12>12>

13> * **Piani Pro e Max:** Claude Tag non è disponibile sui piani individuali, quindi questa pagina rimane il percorso di configurazione in un workspace non connesso a Claude Tag.13> * **Piani Pro, Max e Ultra:** Claude Tag non è disponibile sui piani individuali, quindi [configura questa versione](#setting-up-claude-code-in-slack) in un workspace non connesso a Claude Tag.

14> * **Piani Team ed Enterprise:** la tua app Slack esistente e il tuo handle @Claude rimangono. [Configura Claude Tag](https://claude.com/docs/claude-tag/overview) per un nuovo workspace; per spostarne uno che utilizza già questa versione, vedi [Migra dalla versione precedente di Claude in Slack](https://claude.com/docs/claude-tag/admins/migrate-from-earlier).14> * **Piani Team ed Enterprise:** la tua app Slack esistente e il tuo handle @Claude rimangono. [Configura Claude Tag](https://claude.com/docs/claude-tag/overview) per un nuovo workspace; per spostarne uno che utilizza già questa versione, vedi [Migra dalla versione precedente di Claude in Slack](https://claude.com/docs/claude-tag/admins/migrate-from-earlier).

15> * **Un avviso invece di una risposta:** consulta l'[avviso di configurazione](#this-workspace-isnt-set-up-for-claude-tag-yet) o l'[avviso di ritiro](#the-legacy-claude-in-slack-bot-is-retired) con cui @Claude ha risposto.15> * **Un avviso invece di una risposta:** consulta l'[avviso di configurazione](#this-workspace-isnt-set-up-for-claude-tag-yet) o l'[avviso di ritiro](#the-legacy-claude-in-slack-bot-is-retired) con cui @Claude ha risposto.

16 16 

31 31 

32| Requisito | Dettagli |32| Requisito | Dettagli |

33| :- | :- |33| :- | :- |

34| Piano Claude | Pro o Max |34| Piano Claude | Pro, Max o Ultra |

35| Workspace Slack | Non connesso a [Claude Tag](https://claude.com/docs/claude-tag/overview) da nessuna organizzazione. Se @Claude risponde con l'[avviso di ritiro](#the-legacy-claude-in-slack-bot-is-retired), il workspace è connesso |35| Workspace Slack | Non connesso a [Claude Tag](https://claude.com/docs/claude-tag/overview) da nessuna organizzazione. Se @Claude risponde con l'[avviso di ritiro](#the-legacy-claude-in-slack-bot-is-retired), il workspace è connesso |

36| Sessioni cloud | Le [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) sono abilitate per il tuo account |36| Sessioni cloud | Le [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) sono abilitate per il tuo account |

37| Account GitHub | Connesso a [claude.ai/code](https://claude.ai/code) con almeno un repository autenticato |37| Account GitHub | Connesso a [claude.ai/code](https://claude.ai/code) con almeno un repository autenticato |

178@Claude risponde nel thread con questo avviso invece che con una risposta quando sono vere entrambe queste condizioni:178@Claude risponde nel thread con questo avviso invece che con una risposta quando sono vere entrambe queste condizioni:

179 179 

180* Nessuna organizzazione ha collegato il tuo workspace Slack a [Claude Tag](https://claude.com/docs/claude-tag/overview).180* Nessuna organizzazione ha collegato il tuo workspace Slack a [Claude Tag](https://claude.com/docs/claude-tag/overview).

181* L'account Claude che hai collegato in Slack non ha un piano Pro o Max.181* L'account Claude che hai collegato in Slack non ha un piano Pro, Max o Ultra.

182 182 

183Claude Tag è disponibile sui piani Team ed Enterprise. Per collegare il workspace, inizia con il comando `@Claude connect` indicato nell'avviso, poi segui [Configurare Claude Tag](https://claude.com/docs/claude-tag/overview).183Claude Tag è disponibile sui piani Team ed Enterprise. Per collegare il workspace, inizia con il comando `@Claude connect` indicato nell'avviso, poi segui [Configurare Claude Tag](https://claude.com/docs/claude-tag/overview).

184 184 

185### "The legacy Claude in Slack bot is retired"185### "The legacy Claude in Slack bot is retired"

186 186 

187L'avviso inizia con `The legacy Claude in Slack bot is retired effective October 5, 2026 and no longer responds in channels.` Il tuo workspace Slack è collegato a un'organizzazione Claude e la versione precedente è ancora selezionata per il canale, per il workspace o come predefinita dell'organizzazione nelle impostazioni di Claude Tag di quell'organizzazione. L'avviso non dipende dal tuo piano, quindi lo ricevono anche gli account Pro e Max.187L'avviso inizia con `The legacy Claude in Slack bot is retired effective October 5, 2026 and no longer responds in channels.` Il tuo workspace Slack è collegato a un'organizzazione Claude. La versione precedente è ancora selezionata per il canale, per il workspace o come predefinita dell'organizzazione nelle impostazioni di Claude Tag di quell'organizzazione. L'avviso non dipende dal tuo piano, quindi lo ricevono anche gli account Pro, Max e Ultra.

188 188 

189Se sei un Owner di quell'organizzazione, apri le [impostazioni di amministrazione di Claude](https://claude.ai/admin-settings/claude-tag) e attiva Claude Tag per il canale. Per correggere tutti i canali che ereditano l'impostazione, modificala invece sul workspace o sul predefinito dell'organizzazione. Per la migrazione completa, consulta [Migrare dalla versione precedente di Claude in Slack](https://claude.com/docs/claude-tag/admins/migrate-from-earlier). Se non sei un Owner, invia questa voce a uno.189Se sei un Owner di quell'organizzazione, apri le [impostazioni di amministrazione di Claude](https://claude.ai/admin-settings/claude-tag) e attiva Claude Tag per il canale. Per correggere tutti i canali che ereditano l'impostazione, modificala invece sul workspace o sul predefinito dell'organizzazione. Per la migrazione completa, consulta [Migrare dalla versione precedente di Claude in Slack](https://claude.com/docs/claude-tag/admins/migrate-from-earlier). Se non sei un Owner, invia questa voce a uno.

190 190 

235 235 

236## Risorse correlate236## Risorse correlate

237 237 

238> **[Claude Code nel cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md)**238> [card] [Claude Code nel cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md)

239>239>

240> Scopri di più sulle sessioni cloud240> Scopri di più sulle sessioni cloud

241 241 

242> **[Claude for Slack](https://claude.com/claude-and-slack)**242> [card] [Claude for Slack](https://claude.com/claude-and-slack)

243>243>

244> Documentazione generale di Claude for Slack244> Documentazione generale di Claude for Slack

245 245 

246> **[Claude Tag](https://claude.com/docs/claude-tag/overview)**246> [card] [Claude Tag](https://claude.com/docs/claude-tag/overview)

247>247>

248> @Claude gestito dall'organizzazione in Slack con accesso configurato dall'amministratore248> @Claude gestito dall'organizzazione in Slack con accesso configurato dall'amministratore

249 249 

250> **[Slack App Marketplace](https://slack.com/marketplace/A08SF47R6P4)**250> [card] [Slack App Marketplace](https://slack.com/marketplace/A08SF47R6P4)

251>251>

252> Installa l'app Claude dal Marketplace di Slack252> Installa l'app Claude dal Marketplace di Slack

253 253 

254> **[Claude Help Center](https://support.claude.com)**254> [card] [Claude Help Center](https://support.claude.com)

255>255>

256> Ottieni supporto aggiuntivo256> Ottieni supporto aggiuntivo

statusline.md +4 −4

Details

212| `worktree.original_cwd` | La directory in cui Claude si trovava prima di entrare nel worktree |212| `worktree.original_cwd` | La directory in cui Claude si trovava prima di entrare nel worktree |

213| `worktree.original_branch` | Ramo git estratto prima di entrare nel worktree. Assente per i worktree basati su hook |213| `worktree.original_branch` | Ramo git estratto prima di entrare nel worktree. Assente per i worktree basati su hook |

214 214 

215> **Schema JSON completo**215> [accordion] Schema JSON completo

216>216>

217> Il tuo comando della barra di stato riceve questa struttura JSON tramite stdin:217> Il tuo comando della barra di stato riceve questa struttura JSON tramite stdin:

218>218>

341> * `agent`: appare solo quando si esegue con il flag `--agent` o le impostazioni dell'agente configurate341> * `agent`: appare solo quando si esegue con il flag `--agent` o le impostazioni dell'agente configurate

342> * `pr`: appare solo mentre viene trovata una PR aperta o una merge request GitLab per il ramo corrente, e viene rimossa una volta che si unisce o si chiude. `pr.review_state` e `pr.kind` potrebbero essere indipendentemente assenti342> * `pr`: appare solo mentre viene trovata una PR aperta o una merge request GitLab per il ramo corrente, e viene rimossa una volta che si unisce o si chiude. `pr.review_state` e `pr.kind` potrebbero essere indipendentemente assenti

343> * `worktree`: appare solo durante una [sessione worktree](https://code.claude.com/docs/it/worktrees.md). Quando presente, `branch` e `original_branch` potrebbero anche essere assenti per i worktree basati su hook343> * `worktree`: appare solo durante una [sessione worktree](https://code.claude.com/docs/it/worktrees.md). Quando presente, `branch` e `original_branch` potrebbero anche essere assenti per i worktree basati su hook

344> * `rate_limits`: appare solo per gli abbonati Claude.ai Pro e Max, o dietro un gateway di app Claude che imposta un limite di spesa per te, e solo dopo la prima risposta API nella sessione. Ogni finestra (`five_hour`, `seven_day`, `spend_limit`) potrebbe essere indipendentemente assente, e Claude Code elimina una finestra una volta che il suo tempo `resets_at` passa. Usa `jq -r '.rate_limits.five_hour.used_percentage // empty'` per gestire l'assenza con eleganza.344> * `rate_limits`: appare solo per gli abbonati claude.ai Pro, Max e Ultra, o dietro un gateway di app Claude che imposta un limite di spesa per te. Anche in quel caso, appare solo dopo la prima risposta API nella sessione. Ogni finestra (`five_hour`, `seven_day`, `spend_limit`) potrebbe essere indipendentemente assente, e Claude Code elimina una finestra una volta che il suo tempo `resets_at` passa. Usa `jq -r '.rate_limits.five_hour.used_percentage // empty'` per gestire l'assenza con eleganza.

345> * `prompt_cache`: appare dopo la prima risposta API della conversazione principale. Vedi [campi della prompt cache](#prompt-cache-fields)345> * `prompt_cache`: appare dopo la prima risposta API della conversazione principale. Vedi [campi della prompt cache](#prompt-cache-fields)

346>346>

347> **Campi che potrebbero essere `null`**:347> **Campi che potrebbero essere `null`**:

819 819 

820### Utilizzo del limite di velocità820### Utilizzo del limite di velocità

821 821 

822Visualizza nella riga di stato l'utilizzo del rate limit dell'abbonamento claude.ai, oppure la tua spesa rispetto a un limite di spesa di un gateway di app Claude. Per gli abbonati, l'oggetto `rate_limits` contiene una finestra mobile `five_hour` e una finestra settimanale `seven_day`. Ogni finestra fornisce `used_percentage`, da 0 a 100, e `resets_at`, i secondi di epoca Unix quando la finestra si ripristina. Dietro un gateway, leggi l'oggetto `spend_limit`, descritto in [campi del limite di spesa](#spend-limit-fields).822Visualizza nella riga di stato l'utilizzo del rate limit dell'abbonamento claude.ai, oppure la tua spesa rispetto a un limite di spesa di un gateway di app Claude. Per gli abbonati, l'oggetto `rate_limits` può contenere una finestra mobile `five_hour` e una finestra settimanale `seven_day`. Ogni finestra fornisce `used_percentage`, da 0 a 100, e `resets_at`, i secondi di epoca Unix quando la finestra si ripristina. Dietro un gateway, leggi l'oggetto `spend_limit`, descritto in [campi del limite di spesa](#spend-limit-fields).

823 823 

824L'oggetto `rate_limits` è presente solo per gli abbonati claude.ai Pro e Max, o dietro un gateway di app Claude con limiti di spesa, e solo dopo la prima risposta API. Ogni script gestisce i campi assenti con eleganza e, dietro un gateway, stampa `spend: $314.12 / $500`, oppure `spend: 63%` quando i campi in dollari sono assenti:824L'oggetto `rate_limits` è presente solo per gli abbonati claude.ai Pro, Max e Ultra, o dietro un gateway di app Claude con limiti di spesa, e solo dopo la prima risposta API. Ogni script gestisce i campi assenti con eleganza e, dietro un gateway, stampa `spend: $314.12 / $500`, oppure `spend: 63%` quando i campi in dollari sono assenti:

825 825 

826```bash Bash theme={null}826```bash Bash theme={null}

827#!/bin/bash827#!/bin/bash

sub-agents.md +77 −77

Details

32 32 

33Explore e Plan si avviano senza i tuoi file CLAUDE.md e senza lo snapshot dello stato git per mantenere la ricerca veloce ed economica. Gli altri subagent integrati e i [subagent personalizzati](#configure-subagents) caricano entrambi, a meno che tu non imposti [`omitClaudeMd`](#supported-frontmatter-fields) nella definizione di un subagent personalizzato per avviarlo senza i file CLAUDE.md dell'utente, del progetto e locali. Per la suddivisione completa di ciò che raggiunge un subagent, consulta [cosa si carica all'avvio](#what-loads-at-startup).33Explore e Plan si avviano senza i tuoi file CLAUDE.md e senza lo snapshot dello stato git per mantenere la ricerca veloce ed economica. Gli altri subagent integrati e i [subagent personalizzati](#configure-subagents) caricano entrambi, a meno che tu non imposti [`omitClaudeMd`](#supported-frontmatter-fields) nella definizione di un subagent personalizzato per avviarlo senza i file CLAUDE.md dell'utente, del progetto e locali. Per la suddivisione completa di ciò che raggiunge un subagent, consulta [cosa si carica all'avvio](#what-loads-at-startup).

34 34 

35**Explore**35> [tab] Explore

36 36>

37Un agente veloce e di sola lettura ottimizzato per la ricerca e l'analisi delle basi di codice.37> Un agente veloce e di sola lettura ottimizzato per la ricerca e l'analisi delle basi di codice.

38 38>

39* **Model**: il modello della conversazione principale. Quando la conversazione principale usa Fable, il modello di Explore dipende da come ti connetti:39> * **Model**: il modello della conversazione principale. Quando la conversazione principale usa Fable, il modello di Explore dipende da come ti connetti:

40 * Con un abbonamento Claude, un account Anthropic Console o un [gateway LLM](https://code.claude.com/docs/it/llm-gateway) raggiunto tramite `ANTHROPIC_BASE_URL`, Explore viene eseguito sul modello Opus a cui si risolve l'[alias `opus`](https://code.claude.com/docs/it/model-config#model-aliases).40> * Con un abbonamento Claude, un account Anthropic Console o un [gateway LLM](https://code.claude.com/docs/it/llm-gateway) raggiunto tramite `ANTHROPIC_BASE_URL`, Explore viene eseguito sul modello Opus a cui si risolve l'[alias `opus`](https://code.claude.com/docs/it/model-config#model-aliases).

41 * Su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, [Claude Platform su AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md) o un [gateway delle app Claude](https://code.claude.com/docs/it/claude-apps-gateway), Explore resta sul modello della conversazione principale.41> * Su Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, [Claude Platform su AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md) o un [gateway delle app Claude](https://code.claude.com/docs/it/claude-apps-gateway), Explore resta sul modello della conversazione principale.

42* **Tools**: strumenti di sola lettura; Write e Edit sono negati42> * **Tools**: strumenti di sola lettura; Write e Edit sono negati

43* **Purpose**: scoperta di file, ricerca di codice, esplorazione del codebase43> * **Purpose**: scoperta di file, ricerca di codice, esplorazione del codebase

44 44>

45Un [subagent utente o progetto](#choose-the-subagent-scope) denominato `Explore` sovrascrive quello integrato e mantiene il proprio campo `model`, quindi definiscine uno con `model: haiku` per eseguire l'esplorazione su un modello a costo inferiore. Per forzare un unico modello su ogni subagent, Explore incluso, consulta [Eseguire ogni subagent su un modello](#run-every-subagent-on-one-model).45> Un [subagent utente o progetto](#choose-the-subagent-scope) denominato `Explore` sovrascrive quello integrato e mantiene il proprio campo `model`, quindi definiscine uno con `model: haiku` per eseguire l'esplorazione su un modello a costo inferiore. Per forzare un unico modello su ogni subagent, Explore incluso, consulta [Eseguire ogni subagent su un modello](#run-every-subagent-on-one-model).

46 46>

47Claude delega a Explore quando ha bisogno di cercare o comprendere una base di codice senza apportare modifiche. Questo mantiene i risultati dell'esplorazione fuori dal contesto della conversazione principale.47> Claude delega a Explore quando ha bisogno di cercare o comprendere una base di codice senza apportare modifiche. Questo mantiene i risultati dell'esplorazione fuori dal contesto della conversazione principale.

48 48>

49Quando invoca Explore, Claude specifica un livello di accuratezza: **quick** per ricerche mirate, **medium** per esplorazione equilibrata, o **very thorough** per analisi completa.49> Quando invoca Explore, Claude specifica un livello di accuratezza: **quick** per ricerche mirate, **medium** per esplorazione equilibrata, o **very thorough** per analisi completa.

50 

51**Plan**

52 

53Un agente di ricerca utilizzato durante la [Plan Mode](https://code.claude.com/docs/it/permission-modes.md#analyze-before-you-edit-with-plan-mode) per raccogliere contesto prima di presentare un piano.

54 

55* **Model**: eredita dalla conversazione principale, a meno che non impostiate `CLAUDE_CODE_SUBAGENT_MODEL` e [lo forziate su ogni subagent](#run-every-subagent-on-one-model)

56* **Tools**: strumenti di sola lettura; Write e Edit sono negati

57* **Purpose**: ricerca della base di codice per la pianificazione

58 

59Quando è in Plan Mode e Claude ha bisogno di comprendere la vostra base di codice, delega la ricerca al subagent Plan in modo che l'output dell'esplorazione rimanga in una finestra di contesto separata mentre la conversazione principale rimane di sola lettura.

60 

61**General-purpose**

62 

63Un agente capace per attività complesse e multi-step che richiedono sia esplorazione che azione.

64 

65* **Model**: il modello [`CLAUDE_CODE_SUBAGENT_MODEL`](#choose-a-model) se lo impostate e niente assegna un modello in un altro modo, altrimenti il modello della conversazione principale; [Scegliere un modello](#choose-a-model) indica l'ordine completo, e [Eseguire ogni subagent su un modello](#run-every-subagent-on-one-model) mostra come fare in modo che la variabile sostituisca quelle fonti

66* **Tools**: ogni strumento [disponibile per i subagent](#available-tools)

67* **Purpose**: ricerca complessa, operazioni multi-step, modifiche del codice

68 

69Claude delega a general-purpose quando l'attività richiede sia esplorazione che modifica, ragionamento complesso per interpretare i risultati, o più step dipendenti.

70 50 

71**Other**51> [tab] Plan

52>

53> Un agente di ricerca utilizzato durante la [Plan Mode](https://code.claude.com/docs/it/permission-modes.md#analyze-before-you-edit-with-plan-mode) per raccogliere contesto prima di presentare un piano.

54>

55> * **Model**: eredita dalla conversazione principale, a meno che non impostiate `CLAUDE_CODE_SUBAGENT_MODEL` e [lo forziate su ogni subagent](#run-every-subagent-on-one-model)

56> * **Tools**: strumenti di sola lettura; Write e Edit sono negati

57> * **Purpose**: ricerca della base di codice per la pianificazione

58>

59> Quando è in Plan Mode e Claude ha bisogno di comprendere la vostra base di codice, delega la ricerca al subagent Plan in modo che l'output dell'esplorazione rimanga in una finestra di contesto separata mentre la conversazione principale rimane di sola lettura.

72 60 

73Claude Code include agenti helper aggiuntivi per attività specifiche. Questi vengono generalmente invocati automaticamente, quindi non avete bisogno di utilizzarli direttamente.61> [tab] General-purpose

62>

63> Un agente capace per attività complesse e multi-step che richiedono sia esplorazione che azione.

64>

65> * **Model**: il modello [`CLAUDE_CODE_SUBAGENT_MODEL`](#choose-a-model) se lo impostate e niente assegna un modello in un altro modo, altrimenti il modello della conversazione principale; [Scegliere un modello](#choose-a-model) indica l'ordine completo, e [Eseguire ogni subagent su un modello](#run-every-subagent-on-one-model) mostra come fare in modo che la variabile sostituisca quelle fonti

66> * **Tools**: ogni strumento [disponibile per i subagent](#available-tools)

67> * **Purpose**: ricerca complessa, operazioni multi-step, modifiche del codice

68>

69> Claude delega a general-purpose quando l'attività richiede sia esplorazione che modifica, ragionamento complesso per interpretare i risultati, o più step dipendenti.

74 70 

75| Agent | Model | Quando Claude lo utilizza |71> [tab] Other

76| :- | :- | :- |72>

77| claude | Nessuno proprio; segue l'[ordine dei modelli](#choose-a-model) quando Claude lo genera come subagent | Quando un'attività non si adatta a un agente più specializzato. Un catch-all con ogni strumento [disponibile per i subagent](#available-tools). Anche l'agente predefinito per una [sessione in background](https://code.claude.com/docs/it/agent-view.md) inviata; [quale modalità di autorizzazione inizia](https://code.claude.com/docs/it/agent-view.md#permission-mode-model-and-effort) dipende da come è stata avviata la sessione |73> Claude Code include agenti helper aggiuntivi per attività specifiche. Questi vengono generalmente invocati automaticamente, quindi non avete bisogno di utilizzarli direttamente.

78| statusline-setup | Sonnet | Quando eseguite `/statusline` per configurare la vostra linea di stato |74>

79| claude-code-guide | Haiku | Quando fate domande sulle funzionalità di Claude Code |75> | Agent | Model | Quando Claude lo utilizza |

76> | :- | :- | :- |

77> | claude | Nessuno proprio; segue l'[ordine dei modelli](#choose-a-model) quando Claude lo genera come subagent | Quando un'attività non si adatta a un agente più specializzato. Un catch-all con ogni strumento [disponibile per i subagent](#available-tools). Anche l'agente predefinito per una [sessione in background](https://code.claude.com/docs/it/agent-view.md) inviata; [quale modalità di autorizzazione inizia](https://code.claude.com/docs/it/agent-view.md#permission-mode-model-and-effort) dipende da come è stata avviata la sessione |

78> | statusline-setup | Sonnet | Quando eseguite `/statusline` per configurare la vostra linea di stato |

79> | claude-code-guide | Haiku | Quando fate domande sulle funzionalità di Claude Code |

80 80 

81I subagent integrati sono registrati per impostazione predefinita nelle sessioni interattive. Per limitarli:81I subagent integrati sono registrati per impostazione predefinita nelle sessioni interattive. Per limitarli:

82 82 

179 179 

180I **subagent definiti da CLI** vengono passati come JSON quando avvia Claude Code. Esistono solo per quella sessione e non vengono salvati su disco, rendendoli utili per test rapidi o script di automazione. Può definire più subagent in una singola chiamata `--agents`:180I **subagent definiti da CLI** vengono passati come JSON quando avvia Claude Code. Esistono solo per quella sessione e non vengono salvati su disco, rendendoli utili per test rapidi o script di automazione. Può definire più subagent in una singola chiamata `--agents`:

181 181 

182**macOS, Linux, WSL**182> [tab] macOS, Linux, WSL

183 183>

184```bash theme={null}184> ```bash theme={null}

185claude --agents '{185> claude --agents '{

186 "code-reviewer": {186> "code-reviewer": {

187 "description": "Expert code reviewer. Use proactively after code changes.",187> "description": "Expert code reviewer. Use proactively after code changes.",

188 "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",188> "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",

189 "tools": ["Read", "Grep", "Glob", "Bash"],189> "tools": ["Read", "Grep", "Glob", "Bash"],

190 "model": "sonnet"190> "model": "sonnet"

191 },191> },

192 "debugger": {192> "debugger": {

193 "description": "Debugging specialist for errors and test failures.",193> "description": "Debugging specialist for errors and test failures.",

194 "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."194> "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."

195 }195> }

196}'196> }'

197```197> ```

198 198 

199**Windows PowerShell**199> [tab] Windows PowerShell

200 200>

201```powershell theme={null}201> ```powershell theme={null}

202claude --agents @'202> claude --agents @'

203{203> {

204 "code-reviewer": {204> "code-reviewer": {

205 "description": "Expert code reviewer. Use proactively after code changes.",205> "description": "Expert code reviewer. Use proactively after code changes.",

206 "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",206> "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",

207 "tools": ["Read", "Grep", "Glob", "Bash"],207> "tools": ["Read", "Grep", "Glob", "Bash"],

208 "model": "sonnet"208> "model": "sonnet"

209 },209> },

210 "debugger": {210> "debugger": {

211 "description": "Debugging specialist for errors and test failures.",211> "description": "Debugging specialist for errors and test failures.",

212 "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."212> "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."

213 }213> }

214}214> }

215'@215> '@

216```216> ```

217 217 

218In [modalità non interattiva](https://code.claude.com/docs/it/headless.md), `--agents` accetta anche il percorso di un file JSON che contiene lo stesso oggetto, per definizioni troppo grandi per passare sulla riga di comando. Ad esempio, `claude -p --agents ./agents.json "Review my changes"` legge le definizioni da quel file. In una sessione interattiva, Claude Code rifiuta un percorso di file. La forma di file richiede Claude Code v2.1.281 o successivo.218In [modalità non interattiva](https://code.claude.com/docs/it/headless.md), `--agents` accetta anche il percorso di un file JSON che contiene lo stesso oggetto, per definizioni troppo grandi per passare sulla riga di comando. Ad esempio, `claude -p --agents ./agents.json "Review my changes"` legge le definizioni da quel file. In una sessione interattiva, Claude Code rifiuta un percorso di file. La forma di file richiede Claude Code v2.1.281 o successivo.

219 219 

terminal-config.md +16 −16

Details

48 48 

49Alcune scorciatoie di Claude Code usano il tasto Option, come Option+Enter per andare a capo o Option+P per cambiare modello. Su macOS, la maggior parte dei terminali non invia Option come modificatore per impostazione predefinita, quindi queste scorciatoie non hanno alcun effetto finché non lo abiliti. L'impostazione del terminale per questo è solitamente denominata "Use Option as Meta Key"; Meta è il nome storico Unix del tasto ora etichettato Option o Alt.49Alcune scorciatoie di Claude Code usano il tasto Option, come Option+Enter per andare a capo o Option+P per cambiare modello. Su macOS, la maggior parte dei terminali non invia Option come modificatore per impostazione predefinita, quindi queste scorciatoie non hanno alcun effetto finché non lo abiliti. L'impostazione del terminale per questo è solitamente denominata "Use Option as Meta Key"; Meta è il nome storico Unix del tasto ora etichettato Option o Alt.

50 50 

51**Apple Terminal**51> [tab] Apple Terminal

52 52>

53Apri Settings → Profiles → Keyboard e seleziona "Use Option as Meta Key".53> Apri Settings → Profiles → Keyboard e seleziona "Use Option as Meta Key".

54 54>

55Se hai accettato il prompt di configurazione del terminale al primo avvio di Claude Code, questo è già fatto. Quel prompt esegue `/terminal-setup` per te, che abilita Option come Meta e disattiva il segnale acustico nel tuo profilo di Apple Terminal.55> Se hai accettato il prompt di configurazione del terminale al primo avvio di Claude Code, questo è già fatto. Quel prompt esegue `/terminal-setup` per te, che abilita Option come Meta e disattiva il segnale acustico nel tuo profilo di Apple Terminal.

56 56>

57In [modalità screen reader](https://code.claude.com/docs/it/accessibility.md), `/terminal-setup` lascia invariata l'impostazione del segnale acustico, così il segnale del terminale rimane udibile. Se un'esecuzione precedente ha disattivato il segnale acustico, riattivalo in Settings → Profiles → Advanced → "Audible bell".57> In [modalità screen reader](https://code.claude.com/docs/it/accessibility.md), `/terminal-setup` lascia invariata l'impostazione del segnale acustico, così il segnale del terminale rimane udibile. Se un'esecuzione precedente ha disattivato il segnale acustico, riattivalo in Settings → Profiles → Advanced → "Audible bell".

58 

59**iTerm2**

60 

61Apri Settings → Profiles → Keys → General e imposta Left Option key e Right Option key su "Esc+".

62 

63L'esecuzione di `/terminal-setup` in iTerm2 abilita "Applications in terminal may access clipboard" in Settings → General → Selection, così il comando `/copy` può scrivere negli appunti di sistema. Il comando rileva iTerm2 anche quando viene eseguito all'interno di tmux. Riavvia iTerm2 affinché la modifica abbia effetto.

64 58 

65**VS Code**59> [tab] iTerm2

60>

61> Apri Settings → Profiles → Keys → General e imposta Left Option key e Right Option key su "Esc+".

62>

63> L'esecuzione di `/terminal-setup` in iTerm2 abilita "Applications in terminal may access clipboard" in Settings → General → Selection, così il comando `/copy` può scrivere negli appunti di sistema. Il comando rileva iTerm2 anche quando viene eseguito all'interno di tmux. Riavvia iTerm2 affinché la modifica abbia effetto.

66 64 

67Aggiungi `"terminal.integrated.macOptionIsMeta": true` alle impostazioni di VS Code.65> [tab] VS Code

66>

67> Aggiungi `"terminal.integrated.macOptionIsMeta": true` alle impostazioni di VS Code.

68 68 

69Per Ghostty, Kitty e altri terminali, cerca un'impostazione Option-as-Alt o Option-as-Meta nel file di configurazione del terminale.69Per Ghostty, Kitty e altri terminali, cerca un'impostazione Option-as-Alt o Option-as-Meta nel file di configurazione del terminale.

70 70 

188 188 

189Il riferimento seguente descrive i token che puoi impostare in `overrides`. L'editor interattivo in `/theme` mostra gli stessi token con un'anteprima dal vivo, oltre ad alcuni accenti a scopo singolo, come i colori della schermata di onboarding, che qui sono omessi.189Il riferimento seguente descrive i token che puoi impostare in `overrides`. L'editor interattivo in `/theme` mostra gli stessi token con un'anteprima dal vivo, oltre ad alcuni accenti a scopo singolo, come i colori della schermata di onboarding, che qui sono omessi.

190 190 

191> **Riferimento dei token di colore**191> [accordion] Riferimento dei token di colore

192>192>

193> L'esempio seguente combina token di diversi gruppi elencati sotto: l'accento del brand, il bordo del plan mode, gli sfondi dei diff e lo sfondo dei messaggi.193> L'esempio seguente combina token di diversi gruppi elencati sotto: l'accento del brand, il bordo del plan mode, gli sfondi dei diff e lo sfondo dei messaggi.

194>194>

Details

19| Strumento | Descrizione | Autorizzazione richiesta |19| Strumento | Descrizione | Autorizzazione richiesta |

20| :- | :- | :- |20| :- | :- | :- |

21| `Agent` | Genera un [subagent](https://code.claude.com/docs/it/sub-agents.md) con la propria finestra di contesto per gestire un'attività. Con i [team di agenti](https://code.claude.com/docs/it/agent-teams.md) abilitati, una chiamata che porta un `name` può avviare un [compagno di squadra](https://code.claude.com/docs/it/agent-teams.md#how-claude-starts-agent-teams) invece. Vedi [Comportamento dello strumento Agent](#agent-tool-behavior) | No |21| `Agent` | Genera un [subagent](https://code.claude.com/docs/it/sub-agents.md) con la propria finestra di contesto per gestire un'attività. Con i [team di agenti](https://code.claude.com/docs/it/agent-teams.md) abilitati, una chiamata che porta un `name` può avviare un [compagno di squadra](https://code.claude.com/docs/it/agent-teams.md#how-claude-starts-agent-teams) invece. Vedi [Comportamento dello strumento Agent](#agent-tool-behavior) | No |

22| `Artifact` | Pubblica un file HTML o Markdown come [artifact](https://code.claude.com/docs/it/artifacts.md): una pagina privata e interattiva su claude.ai. Puoi condividerla con un link pubblico, o all'interno della tua organizzazione nei piani Team ed Enterprise, dove la condivisione pubblica richiede a un Owner di [abilitarla](https://code.claude.com/docs/it/artifacts.md#control-public-sharing). Richiede un piano Pro, Max, Team o Enterprise e autenticazione `/login`; vedi [Disponibilità](https://code.claude.com/docs/it/artifacts.md#availability) | Yes |22| `Artifact` | Pubblica un file HTML o Markdown su claude.ai come [artefatto](https://code.claude.com/docs/it/artifacts.md): una pagina privata e interattiva. Puoi condividerla con un link pubblico, o all'interno della tua organizzazione nei piani Team ed Enterprise, dove la condivisione pubblica richiede a un Owner di [abilitarla](https://code.claude.com/docs/it/artifacts.md#control-public-sharing). Richiede un piano Pro, Max, Ultra, Team o Enterprise e autenticazione `/login`; vedi [Disponibilità](https://code.claude.com/docs/it/artifacts.md#availability) | Yes |

23| `AskUserQuestion` | Pone domande a scelta multipla per raccogliere requisiti o chiarire ambiguità. Le domande rimangono aperte finché non le rispondi per impostazione predefinita. Vedi [Comportamento dello strumento AskUserQuestion](#askuserquestion-tool-behavior) | No |23| `AskUserQuestion` | Pone domande a scelta multipla per raccogliere requisiti o chiarire ambiguità. Le domande rimangono aperte finché non le rispondi per impostazione predefinita. Vedi [Comportamento dello strumento AskUserQuestion](#askuserquestion-tool-behavior) | No |

24| `Bash` | Esegue comandi shell nel tuo ambiente. Vedi [Comportamento dello strumento Bash](#bash-tool-behavior) | Yes |24| `Bash` | Esegue comandi shell nel tuo ambiente. Vedi [Comportamento dello strumento Bash](#bash-tool-behavior) | Yes |

25| `CronCreate` | Pianifica un prompt ricorrente o una tantum all'interno della sessione corrente. Le attività hanno ambito di sessione e vengono ripristinate su `--resume` o `--continue` se non scadute. Vedi [attività pianificate con ambito di sessione](https://code.claude.com/docs/it/scheduled-tasks.md) | No |25| `CronCreate` | Pianifica un prompt ricorrente o una tantum all'interno della sessione corrente. Le attività hanno ambito di sessione e vengono ripristinate su `--resume` o `--continue` se non scadute. Vedi [attività pianificate con ambito di sessione](https://code.claude.com/docs/it/scheduled-tasks.md) | No |

42| `PushNotification` | Invia una notifica desktop e, quando [Remote Control](https://code.claude.com/docs/it/remote-control.md) è connesso, una notifica push sul telefono, in modo che un'attività a lunga esecuzione o un'[attività pianificata con ambito di sessione](https://code.claude.com/docs/it/scheduled-tasks.md) possa raggiungerti quando ti allontani. La consegna push avviene tramite l'infrastruttura ospitata da Anthropic, che non è accessibile da Amazon Bedrock, Claude Platform su AWS, Google Cloud's Agent Platform o Microsoft Foundry | No |42| `PushNotification` | Invia una notifica desktop e, quando [Remote Control](https://code.claude.com/docs/it/remote-control.md) è connesso, una notifica push sul telefono, in modo che un'attività a lunga esecuzione o un'[attività pianificata con ambito di sessione](https://code.claude.com/docs/it/scheduled-tasks.md) possa raggiungerti quando ti allontani. La consegna push avviene tramite l'infrastruttura ospitata da Anthropic, che non è accessibile da Amazon Bedrock, Claude Platform su AWS, Google Cloud's Agent Platform o Microsoft Foundry | No |

43| `Read` | Legge il contenuto dei file. Vedi [Comportamento dello strumento Read](#read-tool-behavior) | No |43| `Read` | Legge il contenuto dei file. Vedi [Comportamento dello strumento Read](#read-tool-behavior) | No |

44| `ReadMcpResourceTool` | Legge una risorsa MCP specifica per URI | No |44| `ReadMcpResourceTool` | Legge una risorsa MCP specifica per URI | No |

45| `RemoteTrigger` | Crea, aggiorna, esegue ed elenca le [attività pianificate cloud](https://code.claude.com/docs/it/routines.md), in precedenza routine, su claude.ai. Supporta il comando `/schedule`. Il [riferimento di input di `RemoteTrigger`](https://code.claude.com/docs/it/agent-sdk/typescript#remotetrigger) documenta ogni azione e le policy dell'organizzazione che rimuovono lo strumento. Le attività pianificate cloud risiedono su claude.ai e richiedono un piano Pro, Max, Team o Enterprise. Questo strumento quindi non è accessibile da Amazon Bedrock, Claude Platform su AWS, Google Cloud's Agent Platform o Microsoft Foundry | No |45| `RemoteTrigger` | Crea, aggiorna, esegue ed elenca le [attività pianificate cloud](https://code.claude.com/docs/it/routines.md), in precedenza routine, su claude.ai. Supporta il comando `/schedule`. Il [riferimento di input di `RemoteTrigger`](https://code.claude.com/docs/it/agent-sdk/typescript#remotetrigger) documenta ogni azione e le policy dell'organizzazione che rimuovono lo strumento. Le attività pianificate cloud risiedono su claude.ai e richiedono un piano Pro, Max, Ultra, Team o Enterprise. Questo strumento quindi non è accessibile da Amazon Bedrock, Claude Platform su AWS, Google Cloud's Agent Platform o Microsoft Foundry | No |

46| `ReportFindings` | Segnala i risultati della code review come un elenco strutturato, con un file, un riepilogo e uno scenario di errore per ogni risultato, in modo che Claude Code possa renderizzarli invece di stamparli come testo. Claude lo chiama quando le istruzioni di code review attive glielo indicano. Un risultato può anche includere uno slug `category` opzionale, come `correctness` o `test-coverage`, mostrato accanto alla posizione del file nell'elenco renderizzato | No |46| `ReportFindings` | Segnala i risultati della code review come un elenco strutturato, con un file, un riepilogo e uno scenario di errore per ogni risultato, in modo che Claude Code possa renderizzarli invece di stamparli come testo. Claude lo chiama quando le istruzioni di code review attive glielo indicano. Un risultato può anche includere uno slug `category` opzionale, come `correctness` o `test-coverage`, mostrato accanto alla posizione del file nell'elenco renderizzato | No |

47| `ScheduleWakeup` | Riprogramma l'iterazione successiva di un [`/loop` auto-paced](https://code.claude.com/docs/it/scheduled-tasks#let-claude-choose-the-interval). Claude lo chiama alla fine di ogni iterazione per scegliere quando viene eseguita la successiva, tra un minuto e un'ora; non lo chiami direttamente. Per terminare invece il loop, Claude lo chiama con `stop: true`, che annulla il wakeup in sospeso. Il wakeup in sospeso appare in `session_crons` nell'[input Stop hook](https://code.claude.com/docs/it/hooks.md#stop-input) | No |47| `ScheduleWakeup` | Riprogramma l'iterazione successiva di un [`/loop` auto-paced](https://code.claude.com/docs/it/scheduled-tasks#let-claude-choose-the-interval). Claude lo chiama alla fine di ogni iterazione per scegliere quando viene eseguita la successiva, tra un minuto e un'ora; non lo chiami direttamente. Per terminare invece il loop, Claude lo chiama con `stop: true`, che annulla il wakeup in sospeso. Il wakeup in sospeso appare in `session_crons` nell'[input Stop hook](https://code.claude.com/docs/it/hooks.md#stop-input) | No |

48| `SendFeedback` | Redige un rapporto di feedback su Claude Code, coprendo un problema di prodotto o il comportamento di Claude stesso nella sessione, e lo mette in coda sulla tua macchina per te da rivedere. Claude Code non invia nulla finché non scegli di inviare la bozza. Vedi [Comportamento dello strumento SendFeedback](#sendfeedback-tool-behavior). Richiede Claude Code v2.1.238 o successivo | No |48| `SendFeedback` | Redige un rapporto di feedback su Claude Code, coprendo un problema di prodotto o il comportamento di Claude stesso nella sessione, e lo mette in coda sulla tua macchina per te da rivedere. Claude Code non invia nulla finché non scegli di inviare la bozza. Vedi [Comportamento dello strumento SendFeedback](#sendfeedback-tool-behavior). Richiede Claude Code v2.1.238 o successivo | No |

Details

75 75 

76Il programma di installazione scarica da `downloads.claude.ai`. Verifica di poterlo raggiungere:76Il programma di installazione scarica da `downloads.claude.ai`. Verifica di poterlo raggiungere:

77 77 

78**macOS/Linux**78> [tab] macOS/Linux

79 79>

80```bash theme={null}80> ```bash theme={null}

81curl -sI https://downloads.claude.ai/claude-code-releases/latest81> curl -sI https://downloads.claude.ai/claude-code-releases/latest

82```82> ```

83 

84**Windows PowerShell**

85 

86```powershell theme={null}

87curl.exe -sI https://downloads.claude.ai/claude-code-releases/latest

88```

89 83 

90PowerShell crea un alias di `curl` a `Invoke-WebRequest`, che rifiuta i flag `-sI`, quindi chiama `curl.exe` esplicitamente.84> [tab] Windows PowerShell

85>

86> ```powershell theme={null}

87> curl.exe -sI https://downloads.claude.ai/claude-code-releases/latest

88> ```

89>

90> PowerShell crea un alias di `curl` a `Invoke-WebRequest`, che rifiuta i flag `-sI`, quindi chiama `curl.exe` esplicitamente.

91 91 

92Hai raggiunto il server se la prima riga mostra uno stato `200`. Vedrai `HTTP/2 200` su macOS e Linux, e `HTTP/1.1 200 OK` da `curl.exe` incluso con Windows. Altri risultati indicano la causa:92Hai raggiunto il server se la prima riga mostra uno stato `200`. Vedrai `HTTP/2 200` su macOS e Linux, e `HTTP/1.1 200 OK` da `curl.exe` incluso con Windows. Altri risultati indicano la causa:

93 93 

104 104 

105Questo esempio imposta entrambe le variabili proxy, quindi esegue il programma di installazione attraverso il tuo proxy:105Questo esempio imposta entrambe le variabili proxy, quindi esegue il programma di installazione attraverso il tuo proxy:

106 106 

107**macOS/Linux**107> [tab] macOS/Linux

108 108>

109```bash theme={null}109> ```bash theme={null}

110export HTTP_PROXY=http://proxy.example.com:8080110> export HTTP_PROXY=http://proxy.example.com:8080

111export HTTPS_PROXY=http://proxy.example.com:8080111> export HTTPS_PROXY=http://proxy.example.com:8080

112curl -fsSL https://claude.ai/install.sh | bash112> curl -fsSL https://claude.ai/install.sh | bash

113```113> ```

114 

115**Windows PowerShell**

116 114 

117```powershell theme={null}115> [tab] Windows PowerShell

118$env:HTTP_PROXY = 'http://proxy.example.com:8080'116>

119$env:HTTPS_PROXY = 'http://proxy.example.com:8080'117> ```powershell theme={null}

120irm https://claude.ai/install.ps1 | iex118> $env:HTTP_PROXY = 'http://proxy.example.com:8080'

121```119> $env:HTTPS_PROXY = 'http://proxy.example.com:8080'

120> irm https://claude.ai/install.ps1 | iex

121> ```

122 122 

123### Verifica il tuo PATH123### Verifica il tuo PATH

124 124 

132 132 

133Per prima cosa controlla che il programma sia effettivamente presente, poi controlla se la sua cartella è nel tuo PATH. La correzione del PATH è permanente, quindi la applichi una sola volta. Scegli la scheda della tua piattaforma ed esegui lì i relativi comandi: nel tuo terminale su macOS e Linux, oppure in PowerShell o nel Prompt dei comandi su Windows.133Per prima cosa controlla che il programma sia effettivamente presente, poi controlla se la sua cartella è nel tuo PATH. La correzione del PATH è permanente, quindi la applichi una sola volta. Scegli la scheda della tua piattaforma ed esegui lì i relativi comandi: nel tuo terminale su macOS e Linux, oppure in PowerShell o nel Prompt dei comandi su Windows.

134 134 

135**macOS/Linux**135> [tab] macOS/Linux

136 136>

137Controlla che il programma di installazione abbia messo il programma al suo posto:137> Controlla che il programma di installazione abbia messo il programma al suo posto:

138 138>

139```bash theme={null}139> ```bash theme={null}

140ls -la ~/.local/bin/claude140> ls -la ~/.local/bin/claude

141```141> ```

142 142>

143* **`No such file or directory`**: non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm, Homebrew o un gestore di pacchetti Linux, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code). Se lo hai installato in un altro modo, vedi [Controlla le installazioni in conflitto](#check-for-conflicting-installations).143> * **`No such file or directory`**: non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm, Homebrew o un gestore di pacchetti Linux, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code). Se lo hai installato in un altro modo, vedi [Controlla le installazioni in conflitto](#check-for-conflicting-installations).

144* **Un elenco per il file**: il programma è presente. Controlla poi il tuo PATH.144> * **Un elenco per il file**: il programma è presente. Controlla poi il tuo PATH.

145 145>

146Elenca le tue voci PATH e filtra per la cartella di installazione:146> Elenca le tue voci PATH e filtra per la cartella di installazione:

147 147>

148```bash theme={null}148> ```bash theme={null}

149echo $PATH | tr ':' '\n' | grep -Fx "$HOME/.local/bin"149> echo $PATH | tr ':' '\n' | grep -Fx "$HOME/.local/bin"

150```150> ```

151 151>

152Se questo stampa `/Users/you/.local/bin` o `/home/you/.local/bin`, la directory è nel tuo PATH e puoi saltare a [Controlla le installazioni in conflitto](#check-for-conflicting-installations). Se non c'è output, aggiungila alla tua configurazione della shell con i due comandi per la tua shell. Il comando `echo` salva l'impostazione per ogni nuovo terminale, e `source` la applica alla finestra in cui ti trovi. Il comando `echo` non stampa nulla quando riesce.152> Se questo stampa `/Users/you/.local/bin` o `/home/you/.local/bin`, la directory è nel tuo PATH e puoi saltare a [Controlla le installazioni in conflitto](#check-for-conflicting-installations). Se non c'è output, aggiungila alla tua configurazione della shell con i due comandi per la tua shell. Il comando `echo` salva l'impostazione per ogni nuovo terminale, e `source` la applica alla finestra in cui ti trovi. Il comando `echo` non stampa nulla quando riesce.

153 153>

154Per Zsh, il default su macOS:154> Per Zsh, il default su macOS:

155 155>

156```bash theme={null}156> ```bash theme={null}

157echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc157> echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc

158source ~/.zshrc158> source ~/.zshrc

159```159> ```

160 160>

161Per Bash su Linux, dove è il default sulla maggior parte delle distribuzioni:161> Per Bash su Linux, dove è il default sulla maggior parte delle distribuzioni:

162 162>

163```bash theme={null}163> ```bash theme={null}

164echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc164> echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc

165source ~/.bashrc165> source ~/.bashrc

166```166> ```

167 167>

168Per Bash su macOS, aggiungi la riga a `~/.bash_profile` invece. Terminal su macOS avvia Bash come shell di login, che ignora `~/.bashrc` e legge solo il primo di `~/.bash_profile`, `~/.bash_login`, o `~/.profile` che esiste. Se hai già un `~/.bash_login` o `~/.profile` e nessun `~/.bash_profile`, metti la riga in quel file piuttosto che creare `~/.bash_profile`:168> Per Bash su macOS, aggiungi la riga a `~/.bash_profile` invece. Terminal su macOS avvia Bash come shell di login, che ignora `~/.bashrc` e legge solo il primo di `~/.bash_profile`, `~/.bash_login`, o `~/.profile` che esiste. Se hai già un `~/.bash_login` o `~/.profile` e nessun `~/.bash_profile`, metti la riga in quel file piuttosto che creare `~/.bash_profile`:

169 169>

170```bash theme={null}170> ```bash theme={null}

171echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bash_profile171> echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bash_profile

172source ~/.bash_profile172> source ~/.bash_profile

173```173> ```

174 174>

175In alternativa, chiudi e riapri il tuo terminale.175> In alternativa, chiudi e riapri il tuo terminale.

176 176>

177Se il comando `echo` stampa `permission denied`, vedi [`permission denied` quando aggiungi al tuo PATH](#permission-denied-when-adding-to-your-path).177> Se il comando `echo` stampa `permission denied`, vedi [`permission denied` quando aggiungi al tuo PATH](#permission-denied-when-adding-to-your-path).

178 178>

179Per altre shell come fish o Nushell, aggiungi `~/.local/bin` al tuo PATH usando la sintassi di configurazione della tua shell, quindi riavvia il tuo terminale.179> Per altre shell come fish o Nushell, aggiungi `~/.local/bin` al tuo PATH usando la sintassi di configurazione della tua shell, quindi riavvia il tuo terminale.

180 180>

181Verifica che la correzione abbia funzionato:181> Verifica che la correzione abbia funzionato:

182 182>

183```bash theme={null}183> ```bash theme={null}

184claude --version184> claude --version

185```185> ```

186 186>

187Se `claude` non viene ancora trovato, controlla queste cause:187> Se `claude` non viene ancora trovato, controlla queste cause:

188 188>

189* **Il terminale è precedente alla modifica**: una finestra già aperta mantiene il suo vecchio PATH, e un terminale all'interno di un editor prende il suo PATH dall'editor. Apri una nuova finestra, oppure chiudi e riapri l'editor.189> * **Il terminale è precedente alla modifica**: una finestra già aperta mantiene il suo vecchio PATH, e un terminale all'interno di un editor prende il suo PATH dall'editor. Apri una nuova finestra, oppure chiudi e riapri l'editor.

190* **La riga non è stata salvata**: esegui `grep -n '.local/bin' ~/.zshrc`, usando il nome del file della tua shell. Se la riga è presente, la stampa con il suo numero di riga. Se non stampa nulla, esegui di nuovo i due comandi PATH.190> * **La riga non è stata salvata**: esegui `grep -n '.local/bin' ~/.zshrc`, usando il nome del file della tua shell. Se la riga è presente, la stampa con il suo numero di riga. Se non stampa nulla, esegui di nuovo i due comandi PATH.

191* **La riga è finita nel file di un'altra shell**: esegui `echo $0` per vedere la tua shell, quindi esegui i due comandi PATH per quella shell.191> * **La riga è finita nel file di un'altra shell**: esegui `echo $0` per vedere la tua shell, quindi esegui i due comandi PATH per quella shell.

192 

193**Windows PowerShell**

194 

195Controlla che il programma di installazione abbia messo il programma al suo posto:

196 

197```powershell theme={null}

198Test-Path "$env:USERPROFILE\.local\bin\claude.exe"

199```

200 

201* **`False`**: non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm o WinGet, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code). Se lo hai installato in un altro modo, vedi [Controlla le installazioni in conflitto](#check-for-conflicting-installations).

202* **`True`**: il programma è presente. Controlla poi il tuo PATH.

203 

204Elenca le tue voci PATH e filtra per la cartella di installazione:

205 

206```powershell theme={null}

207$env:PATH -split ';' | Select-String '\.local\\bin'

208```

209 

210Se questo stampa `C:\Users\you\.local\bin`, la directory è nel tuo PATH e puoi saltare a [Controlla le installazioni in conflitto](#check-for-conflicting-installations). Se non c'è output, aggiungi la directory di installazione al tuo User PATH:

211 

212```powershell theme={null}

213$currentPath = [Environment]::GetEnvironmentVariable('PATH', 'User')

214[Environment]::SetEnvironmentVariable('PATH', "$currentPath;$env:USERPROFILE\.local\bin", 'User')

215```

216 

217Riavvia il tuo terminale affinché la modifica abbia effetto.

218 

219Verifica che la correzione abbia funzionato:

220 

221```powershell theme={null}

222claude --version

223```

224 

225Se `claude` non viene ancora trovato in un nuovo terminale, controlla queste cause:

226 

227* **Il terminale viene eseguito all'interno di un editor**: prende il suo PATH dall'editor, quindi chiudi e riapri l'editor.

228* **La modifica non è stata salvata**: esegui `[Environment]::GetEnvironmentVariable('PATH', 'User')` e cerca `.local\bin` nel PATH che stampa. Se manca, esegui di nuovo i due comandi.

229 

230**Windows CMD**

231 

232Controlla che il programma di installazione abbia messo il programma al suo posto:

233 

234```batch theme={null}

235dir "%USERPROFILE%\.local\bin\claude.exe"

236```

237 

238* **`File Not Found` o `The system cannot find the path specified.`**: non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm o WinGet, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code). Se lo hai installato in un altro modo, vedi [Controlla le installazioni in conflitto](#check-for-conflicting-installations).

239* **Un elenco per `claude.exe`**: il programma è presente. Controlla poi il tuo PATH.

240 

241Elenca le tue voci PATH e filtra per la cartella di installazione:

242 

243```batch theme={null}

244echo %PATH% | findstr /i "local\bin"

245```

246 

247Se non c'è output, apri Impostazioni di sistema, vai a Variabili di ambiente, e aggiungi `%USERPROFILE%\.local\bin` alla tua variabile User PATH. Riavvia il tuo terminale.

248 

249Verifica che la correzione abbia funzionato:

250 192 

251```batch theme={null}193> [tab] Windows PowerShell

252claude --version194>

253```195> Controlla che il programma di installazione abbia messo il programma al suo posto:

196>

197> ```powershell theme={null}

198> Test-Path "$env:USERPROFILE\.local\bin\claude.exe"

199> ```

200>

201> * **`False`**: non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm o WinGet, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code). Se lo hai installato in un altro modo, vedi [Controlla le installazioni in conflitto](#check-for-conflicting-installations).

202> * **`True`**: il programma è presente. Controlla poi il tuo PATH.

203>

204> Elenca le tue voci PATH e filtra per la cartella di installazione:

205>

206> ```powershell theme={null}

207> $env:PATH -split ';' | Select-String '\.local\\bin'

208> ```

209>

210> Se questo stampa `C:\Users\you\.local\bin`, la directory è nel tuo PATH e puoi saltare a [Controlla le installazioni in conflitto](#check-for-conflicting-installations). Se non c'è output, aggiungi la directory di installazione al tuo User PATH:

211>

212> ```powershell theme={null}

213> $currentPath = [Environment]::GetEnvironmentVariable('PATH', 'User')

214> [Environment]::SetEnvironmentVariable('PATH', "$currentPath;$env:USERPROFILE\.local\bin", 'User')

215> ```

216>

217> Riavvia il tuo terminale affinché la modifica abbia effetto.

218>

219> Verifica che la correzione abbia funzionato:

220>

221> ```powershell theme={null}

222> claude --version

223> ```

224>

225> Se `claude` non viene ancora trovato in un nuovo terminale, controlla queste cause:

226>

227> * **Il terminale viene eseguito all'interno di un editor**: prende il suo PATH dall'editor, quindi chiudi e riapri l'editor.

228> * **La modifica non è stata salvata**: esegui `[Environment]::GetEnvironmentVariable('PATH', 'User')` e cerca `.local\bin` nel PATH che stampa. Se manca, esegui di nuovo i due comandi.

254 229 

255Se `claude` non viene ancora trovato in un nuovo terminale, tieni presente che un terminale all'interno di un editor prende il suo PATH dall'editor, quindi chiudi e riapri anche l'editor.230> [tab] Windows CMD

231>

232> Controlla che il programma di installazione abbia messo il programma al suo posto:

233>

234> ```batch theme={null}

235> dir "%USERPROFILE%\.local\bin\claude.exe"

236> ```

237>

238> * **`File Not Found` o `The system cannot find the path specified.`**: non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm o WinGet, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code). Se lo hai installato in un altro modo, vedi [Controlla le installazioni in conflitto](#check-for-conflicting-installations).

239> * **Un elenco per `claude.exe`**: il programma è presente. Controlla poi il tuo PATH.

240>

241> Elenca le tue voci PATH e filtra per la cartella di installazione:

242>

243> ```batch theme={null}

244> echo %PATH% | findstr /i "local\bin"

245> ```

246>

247> Se non c'è output, apri Impostazioni di sistema, vai a Variabili di ambiente, e aggiungi `%USERPROFILE%\.local\bin` alla tua variabile User PATH. Riavvia il tuo terminale.

248>

249> Verifica che la correzione abbia funzionato:

250>

251> ```batch theme={null}

252> claude --version

253> ```

254>

255> Se `claude` non viene ancora trovato in un nuovo terminale, tieni presente che un terminale all'interno di un editor prende il suo PATH dall'editor, quindi chiudi e riapri anche l'editor.

256 256 

257### Controlla le installazioni in conflitto257### Controlla le installazioni in conflitto

258 258 

259Più installazioni di Claude Code possono causare mancate corrispondenze di versione o comportamenti inaspettati. Controlla cosa è installato:259Più installazioni di Claude Code possono causare mancate corrispondenze di versione o comportamenti inaspettati. Controlla cosa è installato:

260 260 

261**macOS/Linux**261> [tab] macOS/Linux

262 262>

263Elenca tutti i binari `claude` trovati nel tuo PATH:263> Elenca tutti i binari `claude` trovati nel tuo PATH:

264 264>

265```bash theme={null}265> ```bash theme={null}

266which -a claude266> which -a claude

267```267> ```

268 268>

269Se questo stampa `claude not found`, una riga `no claude in`, o nulla, nessun `claude` è nel tuo PATH. I controlli successivi mostrano se ne è installato almeno uno.269> Se questo stampa `claude not found`, una riga `no claude in`, o nulla, nessun `claude` è nel tuo PATH. I controlli successivi mostrano se ne è installato almeno uno.

270 270>

271Controlla le tre posizioni da cui un binario `claude` può provenire. `~/.local/bin/claude` è il programma di installazione nativo, `~/.claude/local/` è un'installazione npm locale legacy creata da versioni precedenti di Claude Code, e l'elenco npm globale mostra un'installazione `-g`:271> Controlla le tre posizioni da cui un binario `claude` può provenire. `~/.local/bin/claude` è il programma di installazione nativo, `~/.claude/local/` è un'installazione npm locale legacy creata da versioni precedenti di Claude Code, e l'elenco npm globale mostra un'installazione `-g`:

272 272>

273```bash theme={null}273> ```bash theme={null}

274ls -la ~/.local/bin/claude274> ls -la ~/.local/bin/claude

275```275> ```

276 276>

277Un'installazione nativa mostra un collegamento simbolico in `~/.local/share/claude/versions/`. Uno script o un collegamento simbolico che hai creato tu stesso in questo percorso è un launcher personalizzato, che [l'aggiornamento automatico lascia in posizione](https://code.claude.com/docs/it/setup.md#auto-updates).277> Un'installazione nativa mostra un collegamento simbolico in `~/.local/share/claude/versions/`. Uno script o un collegamento simbolico che hai creato tu stesso in questo percorso è un launcher personalizzato, che [l'aggiornamento automatico lascia in posizione](https://code.claude.com/docs/it/setup.md#auto-updates).

278 278>

279Se uno dei comandi `ls` stampa `No such file or directory`, non è un errore. Significa che nulla è installato in quella posizione, quindi passa al controllo successivo.279> Se uno dei comandi `ls` stampa `No such file or directory`, non è un errore. Significa che nulla è installato in quella posizione, quindi passa al controllo successivo.

280 280>

281```bash theme={null}281> ```bash theme={null}

282ls -la ~/.claude/local/282> ls -la ~/.claude/local/

283```283> ```

284 284>

285```bash theme={null}285> ```bash theme={null}

286npm -g ls @anthropic-ai/claude-code 2>/dev/null286> npm -g ls @anthropic-ai/claude-code 2>/dev/null

287```287> ```

288 288>

289Se `ls -la ~/.local/bin/claude` ha stampato `No such file or directory`, non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm, Homebrew o un gestore di pacchetti Linux, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code). Se `~/.local/bin/claude` esiste ma `which -a claude` non lo ha elencato, la cartella non è nel tuo PATH: vedi [Verifica il tuo PATH](#verify-your-path).289> Se `ls -la ~/.local/bin/claude` ha stampato `No such file or directory`, non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm, Homebrew o un gestore di pacchetti Linux, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code). Se `~/.local/bin/claude` esiste ma `which -a claude` non lo ha elencato, la cartella non è nel tuo PATH: vedi [Verifica il tuo PATH](#verify-your-path).

290 

291**Windows PowerShell**

292 

293Elenca tutti i binari `claude` trovati nel tuo PATH:

294 

295```powershell theme={null}

296where.exe claude

297```

298 

299Se questo stampa `INFO: Could not find files for the given pattern(s).`, nessun `claude` è nel tuo PATH.

300 

301Controlla se il programma di installazione nativo ha posizionato un binario:

302 

303```powershell theme={null}

304Test-Path "$env:USERPROFILE\.local\bin\claude.exe"

305```

306 290 

307* **`True`**: l'installazione nativa è presente. Se `where.exe` non ha trovato nulla, la sua cartella non è nel tuo PATH: vedi [Verifica il tuo PATH](#verify-your-path).291> [tab] Windows PowerShell

308* **`False`**: non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm o WinGet, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code).292>

293> Elenca tutti i binari `claude` trovati nel tuo PATH:

294>

295> ```powershell theme={null}

296> where.exe claude

297> ```

298>

299> Se questo stampa `INFO: Could not find files for the given pattern(s).`, nessun `claude` è nel tuo PATH.

300>

301> Controlla se il programma di installazione nativo ha posizionato un binario:

302>

303> ```powershell theme={null}

304> Test-Path "$env:USERPROFILE\.local\bin\claude.exe"

305> ```

306>

307> * **`True`**: l'installazione nativa è presente. Se `where.exe` non ha trovato nulla, la sua cartella non è nel tuo PATH: vedi [Verifica il tuo PATH](#verify-your-path).

308> * **`False`**: non c'è un'installazione nativa. Se non hai installato Claude Code in un altro modo, ad esempio con npm o WinGet, [installa Claude Code](https://code.claude.com/docs/it/setup.md#install-claude-code).

309 309 

310Se trovi più installazioni, mantieni solo una. L'installazione nativa in `~/.local/bin/claude` su macOS/Linux o `%USERPROFILE%\.local\bin\claude.exe` su Windows è consigliata. Rimuovi le altre:310Se trovi più installazioni, mantieni solo una. L'installazione nativa in `~/.local/bin/claude` su macOS/Linux o `%USERPROFILE%\.local\bin\claude.exe` su Windows è consigliata. Rimuovi le altre:

311 311 

317 317 

318Rimuovi l'installazione npm locale legacy:318Rimuovi l'installazione npm locale legacy:

319 319 

320**macOS/Linux**320> [tab] macOS/Linux

321 321>

322```bash theme={null}322> ```bash theme={null}

323rm -rf ~/.claude/local323> rm -rf ~/.claude/local

324```324> ```

325 

326**Windows PowerShell**

327 325 

328```powershell theme={null}326> [tab] Windows PowerShell

329Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\local"327>

330```328> ```powershell theme={null}

329> Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\local"

330> ```

331 331 

332Rimuovi un'installazione Homebrew su macOS. Se hai installato il cask `claude-code@latest`, sostituisci quel nome:332Rimuovi un'installazione Homebrew su macOS. Se hai installato il cask `claude-code@latest`, sostituisci quel nome:

333 333 

376 376 

377Conferma che il binario esiste ed è eseguibile:377Conferma che il binario esiste ed è eseguibile:

378 378 

379**macOS/Linux**379> [tab] macOS/Linux

380 380>

381```bash theme={null}381> ```bash theme={null}

382ls -la "$(command -v claude)"382> ls -la "$(command -v claude)"

383```383> ```

384 

385**Windows PowerShell**

386 384 

387```powershell theme={null}385> [tab] Windows PowerShell

388Get-Command claude | Select-Object Source386>

389```387> ```powershell theme={null}

388> Get-Command claude | Select-Object Source

389> ```

390 390 

391Su Linux, controlla le librerie condivise mancanti. Se `ldd` mostra librerie mancanti, potrebbe essere necessario installare pacchetti di sistema. Su Alpine Linux e altre distribuzioni basate su musl, vedi [Configurazione di Alpine Linux](https://code.claude.com/docs/it/setup.md#alpine-linux-and-musl-based-distributions).391Su Linux, controlla le librerie condivise mancanti. Se `ldd` mostra librerie mancanti, potrebbe essere necessario installare pacchetti di sistema. Su Alpine Linux e altre distribuzioni basate su musl, vedi [Configurazione di Alpine Linux](https://code.claude.com/docs/it/setup.md#alpine-linux-and-musl-based-distributions).

392 392 

568 568 

5693. **Verifica l'interferenza di proxy o firewall**: i proxy aziendali che eseguono l'ispezione TLS possono causare questi errori, inclusi `unable to get local issuer certificate` e `SELF_SIGNED_CERT_IN_CHAIN`. Per il passaggio di installazione, fai in modo che il download di installazione si fidi della CA del proxy aziendale:5693. **Verifica l'interferenza di proxy o firewall**: i proxy aziendali che eseguono l'ispezione TLS possono causare questi errori, inclusi `unable to get local issuer certificate` e `SELF_SIGNED_CERT_IN_CHAIN`. Per il passaggio di installazione, fai in modo che il download di installazione si fidi della CA del proxy aziendale:

570 570 

571 **macOS/Linux**571 > [tab] macOS/Linux

572 >

573 > ```bash theme={null}

574 > curl --cacert /path/to/corporate-ca.pem -fsSL https://claude.ai/install.sh | bash

575 > ```

572 576 

573 ```bash theme={null}577 > [tab] Windows PowerShell

574 curl --cacert /path/to/corporate-ca.pem -fsSL https://claude.ai/install.sh | bash578 >

575 ```579 > Il programma di installazione PowerShell scarica tramite .NET, che convalida TLS rispetto all'archivio certificati di Windows. Chiedi al tuo team IT di aggiungere il certificato CA del proxy all'archivio di Windows se non è già presente, quindi esegui il programma di installazione:

576 580 >

577 **Windows PowerShell**581 > ```powershell theme={null}

578 582 > irm https://claude.ai/install.ps1 | iex

579 Il programma di installazione PowerShell scarica tramite .NET, che convalida TLS rispetto all'archivio certificati di Windows. Chiedi al tuo team IT di aggiungere il certificato CA del proxy all'archivio di Windows se non è già presente, quindi esegui il programma di installazione:583 > ```

580 

581 ```powershell theme={null}

582 irm https://claude.ai/install.ps1 | iex

583 ```

584 584 

585 Per Claude Code stesso una volta installato, imposta `NODE_EXTRA_CA_CERTS` in modo che le richieste API si fidino dello stesso bundle:585 Per Claude Code stesso una volta installato, imposta `NODE_EXTRA_CA_CERTS` in modo che le richieste API si fidino dello stesso bundle:

586 586 

587 **macOS/Linux**587 > [tab] macOS/Linux

588 588 >

589 ```bash theme={null}589 > ```bash theme={null}

590 export NODE_EXTRA_CA_CERTS=/path/to/corporate-ca.pem590 > export NODE_EXTRA_CA_CERTS=/path/to/corporate-ca.pem

591 ```591 > ```

592 

593 **Windows PowerShell**

594 592 

595 ```powershell theme={null}593 > [tab] Windows PowerShell

596 $env:NODE_EXTRA_CA_CERTS = 'C:\path\to\corporate-ca.pem'594 >

597 ```595 > ```powershell theme={null}

596 > $env:NODE_EXTRA_CA_CERTS = 'C:\path\to\corporate-ca.pem'

597 > ```

598 598 

599 Chiedi al tuo team IT il file del certificato se non ce l'hai. Puoi anche provare su una connessione diretta per confermare che la causa è il proxy.599 Chiedi al tuo team IT il file del certificato se non ce l'hai. Puoi anche provare su una connessione diretta per confermare che la causa è il proxy.

600 600 

827 827 

828In ogni altra configurazione, rieseguire il programma di installazione supera questo errore, perché lo script esegue il comando `install` della versione più recente anche quando chiedi di installare una versione precedente. Riesegui il comando per la tua piattaforma:828In ogni altra configurazione, rieseguire il programma di installazione supera questo errore, perché lo script esegue il comando `install` della versione più recente anche quando chiedi di installare una versione precedente. Riesegui il comando per la tua piattaforma:

829 829 

830**macOS/Linux**830> [tab] macOS/Linux

831 831>

832```bash theme={null}832> ```bash theme={null}

833curl -fsSL https://claude.ai/install.sh | bash833> curl -fsSL https://claude.ai/install.sh | bash

834```834> ```

835 

836**Windows PowerShell**

837 835 

838```powershell theme={null}836> [tab] Windows PowerShell

839irm https://claude.ai/install.ps1 | iex837>

840```838> ```powershell theme={null}

839> irm https://claude.ai/install.ps1 | iex

840> ```

841 841 

842`claude --version` stampa la versione installata dalla riesecuzione.842`claude --version` stampa la versione installata dalla riesecuzione.

843 843 

1108 1108 

1109La riga `npm error path` indica la directory che npm non è riuscito a spostare. Elimina quella directory e qualsiasi directory `.claude-code-*` rimasta accanto ad essa, che esecuzioni interrotte in precedenza possono lasciare. I comandi seguenti trovano la tua directory globale dei pacchetti con `npm root -g`; se la directory indicata dalla riga `npm error path` non si trova sotto la directory stampata da `npm root -g`, ad esempio perché hai cambiato versione di Node con nvm, elimina invece le directory indicate dall'errore:1109La riga `npm error path` indica la directory che npm non è riuscito a spostare. Elimina quella directory e qualsiasi directory `.claude-code-*` rimasta accanto ad essa, che esecuzioni interrotte in precedenza possono lasciare. I comandi seguenti trovano la tua directory globale dei pacchetti con `npm root -g`; se la directory indicata dalla riga `npm error path` non si trova sotto la directory stampata da `npm root -g`, ad esempio perché hai cambiato versione di Node con nvm, elimina invece le directory indicate dall'errore:

1110 1110 

1111**macOS/Linux**1111> [tab] macOS/Linux

1112 1112>

1113```bash theme={null}1113> ```bash theme={null}

1114rm -rf "$(npm root -g)/@anthropic-ai/claude-code"1114> rm -rf "$(npm root -g)/@anthropic-ai/claude-code"

1115```1115> ```

1116 1116>

1117Quindi rimuovi eventuali directory temporanee rimaste. Se Zsh stampa `no matches found`, non ce n'erano da rimuovere:1117> Quindi rimuovi eventuali directory temporanee rimaste. Se Zsh stampa `no matches found`, non ce n'erano da rimuovere:

1118 1118>

1119```bash theme={null}1119> ```bash theme={null}

1120rm -rf "$(npm root -g)/@anthropic-ai/.claude-code-"*1120> rm -rf "$(npm root -g)/@anthropic-ai/.claude-code-"*

1121```1121> ```

1122 

1123**Windows PowerShell**

1124 1122 

1125```powershell theme={null}1123> [tab] Windows PowerShell

1126Remove-Item -Recurse -Force "$(npm root -g)/@anthropic-ai/claude-code", "$(npm root -g)/@anthropic-ai/.claude-code-*"1124>

1127```1125> ```powershell theme={null}

1126> Remove-Item -Recurse -Force "$(npm root -g)/@anthropic-ai/claude-code", "$(npm root -g)/@anthropic-ai/.claude-code-*"

1127> ```

1128 1128 

1129Quindi reinstalla. Su npm 12, segui [Correggere un'installazione con npm 12](#fix-an-npm-12-install). Altrimenti, esegui:1129Quindi reinstalla. Su npm 12, segui [Correggere un'installazione con npm 12](#fix-an-npm-12-install). Altrimenti, esegui:

1130 1130 

1162 1162 

1163Se vedi `API Error: 403 Request not allowed` dopo aver effettuato l'accesso:1163Se vedi `API Error: 403 Request not allowed` dopo aver effettuato l'accesso:

1164 1164 

1165* **Utenti Claude Pro/Max**: verifica che il tuo abbonamento sia attivo su [claude.ai/settings](https://claude.ai/settings)1165* **Utenti Claude Pro/Max/Ultra**: verifica che il tuo abbonamento sia attivo su [claude.ai/settings](https://claude.ai/settings)

1166* **Utenti di Anthropic Console**: conferma che il tuo account abbia il ruolo "Claude Code" o "Developer". Gli amministratori lo assegnano nella pagina Members della Console su [platform.claude.com/settings/members](https://platform.claude.com/settings/members).1166* **Utenti di Anthropic Console**: conferma che il tuo account abbia il ruolo "Claude Code" o "Developer". Gli amministratori lo assegnano nella pagina Members della Console su [platform.claude.com/settings/members](https://platform.claude.com/settings/members).

1167* **Dietro un proxy**: i proxy aziendali possono interferire con le richieste API. Consulta [configurazione di rete](https://code.claude.com/docs/it/network-config.md) per la configurazione del proxy.1167* **Dietro un proxy**: i proxy aziendali possono interferire con le richieste API. Consulta [configurazione di rete](https://code.claude.com/docs/it/network-config.md) per la configurazione del proxy.

1168 1168 

1183 1183 

1184Per usare invece il tuo abbonamento, rimuovi l'impostazione della variabile d'ambiente ed eliminala dal profilo della tua shell:1184Per usare invece il tuo abbonamento, rimuovi l'impostazione della variabile d'ambiente ed eliminala dal profilo della tua shell:

1185 1185 

1186**macOS/Linux**1186> [tab] macOS/Linux

1187 1187>

1188```bash theme={null}1188> ```bash theme={null}

1189unset ANTHROPIC_API_KEY1189> unset ANTHROPIC_API_KEY

1190claude1190> claude

1191```1191> ```

1192 

1193**Windows PowerShell**

1194 1192 

1195```powershell theme={null}1193> [tab] Windows PowerShell

1196Remove-Item Env:ANTHROPIC_API_KEY1194>

1197claude1195> ```powershell theme={null}

1198```1196> Remove-Item Env:ANTHROPIC_API_KEY

1197> claude

1198> ```

1199 1199 

1200Controlla `~/.zshrc`, `~/.bashrc` o `~/.profile` per righe `export ANTHROPIC_API_KEY=...` e rimuovile per rendere permanente la modifica. Su Windows, controlla il tuo profilo PowerShell in `$PROFILE` e le variabili d'ambiente utente per `ANTHROPIC_API_KEY`. Esegui `/status` all'interno di Claude Code per confermare quale metodo di autenticazione è attivo.1200Controlla `~/.zshrc`, `~/.bashrc` o `~/.profile` per righe `export ANTHROPIC_API_KEY=...` e rimuovile per rendere permanente la modifica. Su Windows, controlla il tuo profilo PowerShell in `$PROFILE` e le variabili d'ambiente utente per `ANTHROPIC_API_KEY`. Esegui `/status` all'interno di Claude Code per confermare quale metodo di autenticazione è attivo.

1201 1201 

troubleshooting.md +27 −27

Details

134 134 

135Se lo strumento Search, le menzioni `@file`, gli agenti personalizzati o le skill personalizzate non trovano file, il binario `ripgrep` in bundle potrebbe non funzionare sul tuo sistema. Installa il pacchetto `ripgrep` della tua piattaforma e dì a Claude Code di usarlo:135Se lo strumento Search, le menzioni `@file`, gli agenti personalizzati o le skill personalizzate non trovano file, il binario `ripgrep` in bundle potrebbe non funzionare sul tuo sistema. Installa il pacchetto `ripgrep` della tua piattaforma e dì a Claude Code di usarlo:

136 136 

137**macOS**137> [tab] macOS

138 138>

139```bash theme={null}139> ```bash theme={null}

140brew install ripgrep140> brew install ripgrep

141```141> ```

142 

143**Ubuntu/Debian**

144 

145```bash theme={null}

146sudo apt install ripgrep

147```

148 

149**Alpine**

150 

151```bash theme={null}

152apk add ripgrep

153```

154 

155`ripgrep` è nel repository community di Alpine. Se `apk` segnala che il pacchetto è mancante, vedi [Alpine Linux setup](https://code.claude.com/docs/it/setup.md#alpine-linux-and-musl-based-distributions).

156 142 

157**Arch**143> [tab] Ubuntu/Debian

144>

145> ```bash theme={null}

146> sudo apt install ripgrep

147> ```

158 148 

159```bash theme={null}149> [tab] Alpine

160pacman -S ripgrep150>

161```151> ```bash theme={null}

152> apk add ripgrep

153> ```

154>

155> `ripgrep` è nel repository community di Alpine. Se `apk` segnala che il pacchetto è mancante, vedi [Alpine Linux setup](https://code.claude.com/docs/it/setup.md#alpine-linux-and-musl-based-distributions).

162 156 

163**Windows**157> [tab] Arch

158>

159> ```bash theme={null}

160> pacman -S ripgrep

161> ```

164 162 

165```powershell theme={null}163> [tab] Windows

166winget install BurntSushi.ripgrep.MSVC164>

167```165> ```powershell theme={null}

166> winget install BurntSushi.ripgrep.MSVC

167> ```

168 168 

169Quindi imposta `USE_BUILTIN_RIPGREP` su `0`, sia nel tuo [environment](https://code.claude.com/docs/it/env-vars.md) della shell che nel blocco `env` del tuo [`settings.json`](https://code.claude.com/docs/it/settings-reference#all-settings):169Quindi imposta `USE_BUILTIN_RIPGREP` su `0`, sia nel tuo [environment](https://code.claude.com/docs/it/env-vars.md) della shell che nel blocco `env` del tuo [`settings.json`](https://code.claude.com/docs/it/settings-reference#all-settings):

170 170 

ultrareview.md +2 −1

Details

120| - | - | - |120| - | - | - |

121| Pro | 3 run gratuiti | fatturato come [utilizzo extra](https://support.claude.com/it/articles/12429409-extra-usage-for-paid-claude-plans) |121| Pro | 3 run gratuiti | fatturato come [utilizzo extra](https://support.claude.com/it/articles/12429409-extra-usage-for-paid-claude-plans) |

122| Max | 3 run gratuiti | fatturato come [utilizzo extra](https://support.claude.com/it/articles/12429409-extra-usage-for-paid-claude-plans) |122| Max | 3 run gratuiti | fatturato come [utilizzo extra](https://support.claude.com/it/articles/12429409-extra-usage-for-paid-claude-plans) |

123| Ultra | 3 run gratuiti | fatturato come [crediti di utilizzo](https://support.claude.com/it/articles/12429409-extra-usage-for-paid-claude-plans) |

123 124 

124* **Run gratuiti**: i tre run Pro e Max sono un'allocazione una tantum per account e non si rinnovano.125* **Run gratuiti**: i tre run Pro, Max e Ultra sono un'allocazione una tantum per account e non si rinnovano.

125* **Costo per revisione**: dopo aver utilizzato i run gratuiti, in genere da \$5 a \$25 in crediti di utilizzo a seconda della dimensione della modifica, corrispondente alla stima che la finestra di dialogo di avvio mostra prima di ogni run.126* **Costo per revisione**: dopo aver utilizzato i run gratuiti, in genere da \$5 a \$25 in crediti di utilizzo a seconda della dimensione della modifica, corrispondente alla stima che la finestra di dialogo di avvio mostra prima di ogni run.

126* **Quando un run viene conteggiato**: una volta che la sessione cloud inizia. Una revisione che interrompete anticipatamente o che non riesce a completarsi utilizza comunque un run gratuito; una revisione a pagamento viene fatturata solo per la parte che è stata eseguita.127* **Quando un run viene conteggiato**: una volta che la sessione cloud inizia. Una revisione che interrompete anticipatamente o che non riesce a completarsi utilizza comunque un run gratuito; una revisione a pagamento viene fatturata solo per la parte che è stata eseguita.

127 128 

Details

105 105 

106La dettatura vocale utilizza la stessa [impostazione `language`](https://code.claude.com/docs/it/settings-reference#language) che controlla la lingua di risposta di Claude. Se tale impostazione è vuota, la dettatura predefinita è l'inglese. Nell'estensione VS Code, se `language` è vuoto, la dettatura utilizza l'impostazione `accessibility.voice.speechLanguage` di VS Code prima di predefinire l'inglese.106La dettatura vocale utilizza la stessa [impostazione `language`](https://code.claude.com/docs/it/settings-reference#language) che controlla la lingua di risposta di Claude. Se tale impostazione è vuota, la dettatura predefinita è l'inglese. Nell'estensione VS Code, se `language` è vuoto, la dettatura utilizza l'impostazione `accessibility.voice.speechLanguage` di VS Code prima di predefinire l'inglese.

107 107 

108> **Lingue di dettatura supportate**108> [accordion] Lingue di dettatura supportate

109>109>

110> | Lingua | Codice |110> | Lingua | Codice |

111> | :- | :- |111> | :- | :- |

vs-code.md +33 −29

Details

23Prima di installare, assicurati di avere:23Prima di installare, assicurati di avere:

24 24 

25* VS Code 1.94.0 o superiore25* VS Code 1.94.0 o superiore

26* Un account Anthropic: qualsiasi abbonamento Claude a pagamento (Pro, Max, Team o Enterprise) o un account Claude Console funziona, e non è richiesta alcuna chiave API. Accederai [con questo account](https://code.claude.com/docs/it/authentication.md#log-in-to-claude-code) quando aprirai l'estensione per la prima volta. Se accedi a Claude tramite un provider di terze parti come Amazon Bedrock o Google Cloud's Agent Platform, consulta [Usa provider di terze parti](#use-third-party-providers) per le istruzioni di configurazione.26* Un account Anthropic: qualsiasi abbonamento Claude a pagamento (Pro, Max, Ultra, Team o Enterprise) o un account Claude Console funziona, e non è richiesta alcuna chiave API. Accederai [con questo account](https://code.claude.com/docs/it/authentication.md#log-in-to-claude-code) quando aprirai l'estensione per la prima volta. Se accedi a Claude tramite un provider di terze parti come Amazon Bedrock o Google Cloud's Agent Platform, consulta [Usa provider di terze parti](#use-third-party-providers) per le istruzioni di configurazione.

27 27 

28> [!TIP]28> [!TIP]

29>29>

38 38 

39Oppure in VS Code, premi `Cmd+Shift+X` (Mac) o `Ctrl+Shift+X` (Windows/Linux) per aprire la vista Estensioni, cerca "Claude Code" e fai clic su **Install**.39Oppure in VS Code, premi `Cmd+Shift+X` (Mac) o `Ctrl+Shift+X` (Windows/Linux) per aprire la vista Estensioni, cerca "Claude Code" e fai clic su **Install**.

40 40 

41> [!NOTE]

42>

43> I marketplace di estensioni sono software di terze parti, che Anthropic non approva, non gestisce e non verifica. Anthropic invia le estensioni per la pubblicazione al Visual Studio Marketplace e all'Open VSX Registry.

44 

41Il numero di versione dell'estensione corrisponde alla versione di Claude Code che include. Ad esempio, una funzionalità che richiede Claude Code v2.1.286 o successiva necessita della versione 2.1.286 o successiva dell'estensione, indicata nella vista Estensioni.45Il numero di versione dell'estensione corrisponde alla versione di Claude Code che include. Ad esempio, una funzionalità che richiede Claude Code v2.1.286 o successiva necessita della versione 2.1.286 o successiva dell'estensione, indicata nella vista Estensioni.

42 46 

43Claude Code funziona anche in altri editor e container:47Claude Code funziona anche in altri editor e container:

117 121 

118La casella del prompt supporta diverse funzionalità:122La casella del prompt supporta diverse funzionalità:

119 123 

120* **Modalità di permesso**: fai clic sull'indicatore della modalità in fondo alla casella del prompt per cambiare modalità di permesso. Con Claude Code v2.1.283 o versioni successive, Auto è la modalità di permesso iniziale predefinita, mentre nelle versioni precedenti lo è solo sui piani Pro, Max e Team. Consulta [come l'estensione sceglie la modalità di permesso iniziale](https://code.claude.com/docs/it/permission-modes.md#switch-permission-modes) per sapere cosa la modifica e per conoscere tutte le modalità di permesso offerte dall'indicatore.124* **Modalità di permesso**: fai clic sull'indicatore della modalità in fondo alla casella del prompt per cambiare modalità di permesso. Con Claude Code v2.1.283 o versioni successive, Auto è la modalità di permesso iniziale predefinita, mentre nelle versioni precedenti lo è solo sui piani Pro, Max, Ultra e Team. Consulta [come l'estensione sceglie la modalità di permesso iniziale](https://code.claude.com/docs/it/permission-modes.md#switch-permission-modes) per sapere cosa la modifica e per conoscere tutte le modalità di permesso offerte dall'indicatore.

121 * **Auto**: un classificatore esamina la maggior parte delle azioni invece di chiedertelo. Consulta [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) per sapere cosa esamina e blocca.125 * **Auto**: un classificatore esamina la maggior parte delle azioni invece di chiedertelo. Consulta [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) per sapere cosa esamina e blocca.

122 * **Manual**: Claude chiede il permesso prima di modificare i file e di eseguire la maggior parte dei comandi della shell.126 * **Manual**: Claude chiede il permesso prima di modificare i file e di eseguire la maggior parte dei comandi della shell.

123 * **Plan**: Claude descrive cosa farà e attende l'approvazione prima di apportare modifiche. VS Code apre automaticamente il piano come documento Markdown completo in cui puoi aggiungere commenti inline per dare feedback prima che Claude inizi.127 * **Plan**: Claude descrive cosa farà e attende l'approvazione prima di apportare modifiche. VS Code apre automaticamente il piano come documento Markdown completo in cui puoi aggiungere commenti inline per dare feedback prima che Claude inizi.

656 660 

657Invoca il gestore con l'apertura di URL del tuo sistema operativo.661Invoca il gestore con l'apertura di URL del tuo sistema operativo.

658 662 

659**macOS**663> [tab] macOS

660 664>

661```bash theme={null}665> ```bash theme={null}

662open "vscode://anthropic.claude-code/open"666> open "vscode://anthropic.claude-code/open"

663```667> ```

664 

665**Linux**

666 

667```bash theme={null}

668xdg-open "vscode://anthropic.claude-code/open"

669```

670 

671Il comando `xdg-open` proviene dal pacchetto `xdg-utils`. Se la shell segnala che non viene trovato, consulta [xdg-open is not found on Linux](https://code.claude.com/docs/it/deep-links.md#xdg-open-is-not-found-on-linux).

672 

673**Windows**

674 

675In PowerShell:

676 

677```powershell theme={null}

678Start-Process "vscode://anthropic.claude-code/open"

679```

680 668 

681In `cmd.exe`, `start` tratta il primo argomento tra virgolette come titolo della finestra, quindi passa un titolo vuoto prima dell'URL:669> [tab] Linux

670>

671> ```bash theme={null}

672> xdg-open "vscode://anthropic.claude-code/open"

673> ```

674>

675> Il comando `xdg-open` proviene dal pacchetto `xdg-utils`. Se la shell segnala che non viene trovato, consulta [xdg-open is not found on Linux](https://code.claude.com/docs/it/deep-links.md#xdg-open-is-not-found-on-linux).

682 676 

683```cmd theme={null}677> [tab] Windows

684start "" "vscode://anthropic.claude-code/open"678>

685```679> In PowerShell:

680>

681> ```powershell theme={null}

682> Start-Process "vscode://anthropic.claude-code/open"

683> ```

684>

685> In `cmd.exe`, `start` tratta il primo argomento tra virgolette come titolo della finestra, quindi passa un titolo vuoto prima dell'URL:

686>

687> ```cmd theme={null}

688> start "" "vscode://anthropic.claude-code/open"

689> ```

686 690 

687Il gestore accetta due parametri di query facoltativi:691Il gestore accetta due parametri di query facoltativi:

688 692 

704L'estensione si configura in due punti, le impostazioni dell'estensione di VS Code e il file delle impostazioni di Claude Code:708L'estensione si configura in due punti, le impostazioni dell'estensione di VS Code e il file delle impostazioni di Claude Code:

705 709 

706* **Impostazioni dell'estensione** in VS Code: controllano il comportamento dell'estensione all'interno di VS Code. Aprile con `Cmd+,` (Mac) o `Ctrl+,` (Windows/Linux), poi vai su **Extensions > Claude Code**. Puoi anche digitare `/` e selezionare **General config…** per aprire le impostazioni.710* **Impostazioni dell'estensione** in VS Code: controllano il comportamento dell'estensione all'interno di VS Code. Aprile con `Cmd+,` (Mac) o `Ctrl+,` (Windows/Linux), poi vai su **Extensions > Claude Code**. Puoi anche digitare `/` e selezionare **General config…** per aprire le impostazioni.

707* **Impostazioni di Claude Code** in `~/.claude/settings.json`: condivise tra l'estensione e la CLI. Usale per i comandi consentiti, le variabili d'ambiente, gli hook e i server MCP. Con Claude Code v2.1.283 o successive, sono anche uno degli input che determinano la modalità di permesso con cui iniziano le conversazioni, mentre nelle versioni precedenti lo sono solo nei piani Pro, Max e Team. [Cambiare modalità di permesso](https://code.claude.com/docs/it/permission-modes.md#switch-permission-modes) elenca l'ordine. Consulta [Impostazioni](https://code.claude.com/docs/it/settings.md) per i dettagli.711* **Impostazioni di Claude Code** in `~/.claude/settings.json`: condivise tra l'estensione e la CLI. Usale per i comandi consentiti, le variabili d'ambiente, gli hook e i server MCP. Con Claude Code v2.1.283 o successive, sono anche uno degli input che determinano la modalità di permesso con cui iniziano le conversazioni, mentre nelle versioni precedenti lo sono solo nei piani Pro, Max, Ultra e Team. [Cambiare modalità di permesso](https://code.claude.com/docs/it/permission-modes.md#switch-permission-modes) elenca l'ordine. Consulta [Impostazioni](https://code.claude.com/docs/it/settings.md) per i dettagli.

708 712 

709> [!TIP]713> [!TIP]

710>714>

933 937 

934* Assicurati di avere una versione compatibile di VS Code (1.94.0 o successiva)938* Assicurati di avere una versione compatibile di VS Code (1.94.0 o successiva)

935* Verifica che VS Code abbia il permesso di installare estensioni939* Verifica che VS Code abbia il permesso di installare estensioni

936* Prova a installarla direttamente dal [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code)940* Prova a installarla direttamente dal [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code)

937 941 

938### Icona Spark non visibile942### Icona Spark non visibile

939 943 

Details

8 8 

9> [!NOTE]9> [!NOTE]

10>10>

11> Le sessioni cloud sono disponibili sui piani Pro, Max e Team, e per gli utenti Enterprise con posti premium o posti Chat + Claude Code.11> Le sessioni cloud sono disponibili sui piani Pro, Max, Ultra e Team, e per gli utenti Enterprise con posti premium o posti Chat + Claude Code.

12 12 

13Una sessione cloud esegue Claude Code su un'infrastruttura cloud invece che sulla tua macchina, gestita da Anthropic per impostazione predefinita. Questo quickstart ne avvia una da [claude.ai/code](https://claude.ai/code) nel tuo browser. Puoi anche avviarne una dall'app mobile Claude, dall'app Desktop o dal tuo terminale con `claude --cloud`.13Una sessione cloud esegue Claude Code su un'infrastruttura cloud invece che sulla tua macchina, gestita da Anthropic per impostazione predefinita. Questo quickstart ne avvia una da [claude.ai/code](https://claude.ai/code) nel tuo browser. Puoi anche avviarne una dall'app mobile Claude, dall'app Desktop o dal tuo terminale con `claude --cloud`.

14 14 

77 77 

78Un [cloud environment](https://code.claude.com/docs/it/cloud-environments.md) è la configurazione salvata che controlla quale accesso di rete Claude ha durante le sessioni e cosa viene eseguito quando una sessione si avvia. Quello che accade dopo che connetti GitHub dipende dal tuo piano:78Un [cloud environment](https://code.claude.com/docs/it/cloud-environments.md) è la configurazione salvata che controlla quale accesso di rete Claude ha durante le sessioni e cosa viene eseguito quando una sessione si avvia. Quello che accade dopo che connetti GitHub dipende dal tuo piano:

79 79 

80* **Pro e Max**: l'onboarding crea un ambiente denominato **Default** per te.80* **Pro, Max e Ultra**: ricevi automaticamente un ambiente denominato **Default**.

81* **Team ed Enterprise**: l'onboarding mostra un modulo **Create your first cloud environment**. Lascia il nome precompilato e l'accesso alla rete invariati e fai clic su **Create & finish** per creare l'ambiente **Default**. Se un Owner ha attivato [Quick setup](https://code.claude.com/docs/it/claude-code-on-the-web.md#quick-setup-for-team-and-enterprise), l'onboarding crea **Default** per te invece.81* **Team ed Enterprise**: l'onboarding mostra un modulo **Create your first cloud environment**. Lascia il nome precompilato e l'accesso alla rete invariati e fai clic su **Create & finish** per creare l'ambiente **Default**. Se un Owner ha attivato [Quick setup](https://code.claude.com/docs/it/claude-code-on-the-web.md#quick-setup-for-team-and-enterprise), l'onboarding crea **Default** per te invece.

82 82 

83**Default** utilizza [`Trusted` network access](https://code.claude.com/docs/it/cloud-environments#access-levels): le sessioni raggiungono [registri di pacchetti comuni](https://code.claude.com/docs/it/cloud-environments.md#default-allowed-domains) e altri domini nella lista di autorizzazione, e nient'altro attraverso la rete della sessione. Vedi [Installed tools](https://code.claude.com/docs/it/cloud-environments.md#installed-tools) per quello che è disponibile senza alcuna configurazione.83**Default** utilizza [`Trusted` network access](https://code.claude.com/docs/it/cloud-environments#access-levels): le sessioni raggiungono [registri di pacchetti comuni](https://code.claude.com/docs/it/cloud-environments.md#default-allowed-domains) e altri domini nella lista di autorizzazione, e nient'altro attraverso la rete della sessione. Vedi [Installed tools](https://code.claude.com/docs/it/cloud-environments.md#installed-tools) per quello che è disponibile senza alcuna configurazione.