1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Flussi di lavoro comuni

6 

7> Guide passo dopo passo per esplorare basi di codice, correggere bug, effettuare refactoring, testare e altri compiti quotidiani con Claude Code.

8 

9Questa pagina copre flussi di lavoro pratici per lo sviluppo quotidiano: esplorare codice non familiare, eseguire il debug, effettuare refactoring, scrivere test, creare PR e gestire sessioni. Ogni sezione include prompt di esempio che puoi adattare ai tuoi progetti. Per modelli e suggerimenti di livello superiore, vedi [Best practices](/it/best-practices).

10 

11## Comprendere nuove basi di codice

12 

13### Ottenere una rapida panoramica della base di codice

14 

15Supponiamo che tu abbia appena aderito a un nuovo progetto e debba comprendere rapidamente la sua struttura.

16 

17<Steps>

18 <Step title="Navigare alla directory radice del progetto">

19 ```bash theme={null}

20 cd /path/to/project

21 ```

22 </Step>

23 

24 <Step title="Avviare Claude Code">

25 ```bash theme={null}

26 claude

27 ```

28 </Step>

29 

30 <Step title="Chiedere una panoramica di alto livello">

31 ```text theme={null}

32 give me an overview of this codebase

33 ```

34 </Step>

35 

36 <Step title="Approfondire componenti specifici">

37 ```text theme={null}

38 explain the main architecture patterns used here

39 ```

40 

41 ```text theme={null}

42 what are the key data models?

43 ```

44 

45 ```text theme={null}

46 how is authentication handled?

47 ```

48 </Step>

49</Steps>

50 

51<Tip>

52 Suggerimenti:

53 

54 * Inizia con domande ampie, quindi restringi a aree specifiche

55 * Chiedi informazioni sulle convenzioni di codifica e sui modelli utilizzati nel progetto

56 * Richiedi un glossario di termini specifici del progetto

57</Tip>

58 

59### Trovare codice rilevante

60 

61Supponiamo che tu debba individuare il codice relativo a una funzionalità o funzione specifica.

62 

63<Steps>

64 <Step title="Chiedere a Claude di trovare file rilevanti">

65 ```text theme={null}

66 find the files that handle user authentication

67 ```

68 </Step>

69 

70 <Step title="Ottenere contesto su come i componenti interagiscono">

71 ```text theme={null}

72 how do these authentication files work together?

73 ```

74 </Step>

75 

76 <Step title="Comprendere il flusso di esecuzione">

77 ```text theme={null}

78 trace the login process from front-end to database

79 ```

80 </Step>

81</Steps>

82 

83<Tip>

84 Suggerimenti:

85 

86 * Sii specifico su ciò che stai cercando

87 * Usa il linguaggio del dominio dal progetto

88 * Installa un [plugin di code intelligence](/it/discover-plugins#code-intelligence) per il tuo linguaggio per dare a Claude una navigazione precisa "go to definition" e "find references"

89</Tip>

90 

91***

92 

93## Correggere bug in modo efficiente

94 

95Supponiamo che tu abbia riscontrato un messaggio di errore e debba trovare e correggere la sua fonte.

96 

97<Steps>

98 <Step title="Condividere l'errore con Claude">

99 ```text theme={null}

100 I'm seeing an error when I run npm test

101 ```

102 </Step>

103 

104 <Step title="Chiedere raccomandazioni per la correzione">

105 ```text theme={null}

106 suggest a few ways to fix the @ts-ignore in user.ts

107 ```

108 </Step>

109 

110 <Step title="Applicare la correzione">

111 ```text theme={null}

112 update user.ts to add the null check you suggested

113 ```

114 </Step>

115</Steps>

116 

117<Tip>

118 Suggerimenti:

119 

120 * Comunica a Claude il comando per riprodurre il problema e ottenere una stack trace

121 * Menziona eventuali passaggi per riprodurre l'errore

122 * Fai sapere a Claude se l'errore è intermittente o coerente

123</Tip>

124 

125***

126 

127## Effettuare refactoring del codice

128 

129Supponiamo che tu debba aggiornare il codice precedente per utilizzare modelli e pratiche moderne.

130 

131<Steps>

132 <Step title="Identificare il codice legacy per il refactoring">

133 ```text theme={null}

134 find deprecated API usage in our codebase

135 ```

136 </Step>

137 

138 <Step title="Ottenere raccomandazioni per il refactoring">

139 ```text theme={null}

140 suggest how to refactor utils.js to use modern JavaScript features

141 ```

142 </Step>

143 

144 <Step title="Applicare le modifiche in modo sicuro">

145 ```text theme={null}

146 refactor utils.js to use ES2024 features while maintaining the same behavior

147 ```

148 </Step>

149 

150 <Step title="Verificare il refactoring">

151 ```text theme={null}

152 run tests for the refactored code

153 ```

154 </Step>

155</Steps>

156 

157<Tip>

158 Suggerimenti:

159 

160 * Chiedi a Claude di spiegare i vantaggi dell'approccio moderno

161 * Richiedi che le modifiche mantengano la compatibilità all'indietro quando necessario

162 * Effettua il refactoring in piccoli incrementi testabili

163</Tip>

164 

165***

166 

167## Utilizzare subagent specializzati

168 

169Supponiamo che tu voglia utilizzare subagent AI specializzati per gestire attività specifiche in modo più efficace.

170 

171<Steps>

172 <Step title="Visualizzare i subagent disponibili">

173 ```text theme={null}

174 /agents

175 ```

176 

177 Questo mostra tutti i subagent disponibili e ti consente di crearne di nuovi.

178 </Step>

179 

180 <Step title="Utilizzare i subagent automaticamente">

181 Claude Code delega automaticamente le attività appropriate ai subagent specializzati:

182 

183 ```text theme={null}

184 review my recent code changes for security issues

185 ```

186 

187 ```text theme={null}

188 run all tests and fix any failures

189 ```

190 </Step>

191 

192 <Step title="Richiedere esplicitamente subagent specifici">

193 ```text theme={null}

194 use the code-reviewer subagent to check the auth module

195 ```

196 

197 ```text theme={null}

198 have the debugger subagent investigate why users can't log in

199 ```

200 </Step>

201 

202 <Step title="Creare subagent personalizzati per il tuo flusso di lavoro">

203 ```text theme={null}

204 /agents

205 ```

206 

207 Quindi seleziona "Create New subagent" e segui i prompt per definire:

208 

209 * Un identificatore univoco che descrive lo scopo del subagent (ad esempio, `code-reviewer`, `api-designer`).

210 * Quando Claude dovrebbe utilizzare questo agente

211 * Quali strumenti può accedere

212 * Un prompt di sistema che descrive il ruolo e il comportamento dell'agente

213 </Step>

214</Steps>

215 

216<Tip>

217 Suggerimenti:

218 

219 * Crea subagent specifici del progetto in `.claude/agents/` per la condivisione del team

220 * Usa campi `description` descrittivi per abilitare la delegazione automatica

221 * Limita l'accesso agli strumenti a ciò di cui ogni subagent ha effettivamente bisogno

222 * Controlla la [documentazione dei subagent](/it/sub-agents) per esempi dettagliati

223</Tip>

224 

225***

226 

227## Utilizzare Plan Mode per l'analisi sicura del codice

228 

229Plan Mode istruisce Claude a creare un piano analizzando la base di codice con operazioni di sola lettura, perfetto per esplorare basi di codice, pianificare modifiche complesse o rivedere il codice in modo sicuro. In Plan Mode, Claude utilizza [`AskUserQuestion`](/it/tools-reference) per raccogliere requisiti e chiarire i tuoi obiettivi prima di proporre un piano.

230 

231### Quando utilizzare Plan Mode

232 

233* **Implementazione multi-step**: Quando la tua funzionalità richiede di apportare modifiche a molti file

234* **Esplorazione del codice**: Quando desideri ricercare a fondo la base di codice prima di modificare qualsiasi cosa

235* **Sviluppo interattivo**: Quando desideri iterare sulla direzione con Claude

236 

237### Come utilizzare Plan Mode

238 

239**Attivare Plan Mode durante una sessione**

240 

241Puoi passare a Plan Mode durante una sessione utilizzando **Shift+Tab** per scorrere le modalità di autorizzazione.

242 

243Se sei in Normal Mode, **Shift+Tab** passa prima a Auto-Accept Mode, indicato da `⏵⏵ accept edits on` nella parte inferiore del terminale. Un successivo **Shift+Tab** passerà a Plan Mode, indicato da `⏸ plan mode on`.

244 

245**Avviare una nuova sessione in Plan Mode**

246 

247Per avviare una nuova sessione in Plan Mode, usa il flag `--permission-mode plan`:

248 

249```bash theme={null}

250claude --permission-mode plan

251```

252 

253**Eseguire query "headless" in Plan Mode**

254 

255Puoi anche eseguire una query in Plan Mode direttamente con `-p` (cioè in ["headless mode"](/it/headless)):

256 

257```bash theme={null}

258claude --permission-mode plan -p "Analyze the authentication system and suggest improvements"

259```

260 

261### Esempio: Pianificazione di un refactoring complesso

262 

263```bash theme={null}

264claude --permission-mode plan

265```

266 

267```text theme={null}

268I need to refactor our authentication system to use OAuth2. Create a detailed migration plan.

269```

270 

271Claude analizza l'implementazione attuale e crea un piano completo. Affina con follow-up:

272 

273```text theme={null}

274What about backward compatibility?

275```

276 

277```text theme={null}

278How should we handle database migration?

279```

280 

281<Tip>Premi `Ctrl+G` per aprire il piano nel tuo editor di testo predefinito, dove puoi modificarlo direttamente prima che Claude proceda.</Tip>

282 

283Quando accetti un piano, Claude denomina automaticamente la sessione dal contenuto del piano. Il nome appare sulla barra del prompt e nel selettore di sessione. Se hai già impostato un nome con `--name` o `/rename`, accettare un piano non lo sovrascriverà.

284 

285### Configurare Plan Mode come predefinito

286 

287```json theme={null}

288// .claude/settings.json

289{

290 "permissions": {

291 "defaultMode": "plan"

292 }

293}

294```

295 

296Vedi la [documentazione delle impostazioni](/it/settings#available-settings) per ulteriori opzioni di configurazione.

297 

298***

299 

300## Lavorare con i test

301 

302Supponiamo che tu debba aggiungere test per il codice non coperto.

303 

304<Steps>

305 <Step title="Identificare il codice non testato">

306 ```text theme={null}

307 find functions in NotificationsService.swift that are not covered by tests

308 ```

309 </Step>

310 

311 <Step title="Generare lo scaffolding dei test">

312 ```text theme={null}

313 add tests for the notification service

314 ```

315 </Step>

316 

317 <Step title="Aggiungere casi di test significativi">

318 ```text theme={null}

319 add test cases for edge conditions in the notification service

320 ```

321 </Step>

322 

323 <Step title="Eseguire e verificare i test">

324 ```text theme={null}

325 run the new tests and fix any failures

326 ```

327 </Step>

328</Steps>

329 

330Claude può generare test che seguono i modelli e le convenzioni esistenti del tuo progetto. Quando chiedi test, sii specifico sul comportamento che desideri verificare. Claude esamina i tuoi file di test esistenti per abbinare lo stile, i framework e i modelli di asserzione già in uso.

331 

332Per una copertura completa, chiedi a Claude di identificare i casi limite che potresti aver perso. Claude può analizzare i tuoi percorsi di codice e suggerire test per condizioni di errore, valori limite e input inaspettati che sono facili da trascurare.

333 

334***

335 

336## Creare pull request

337 

338Puoi creare pull request chiedendo direttamente a Claude ("create a pr for my changes"), oppure guidare Claude attraverso i passaggi:

339 

340<Steps>

341 <Step title="Riassumere le tue modifiche">

342 ```text theme={null}

343 summarize the changes I've made to the authentication module

344 ```

345 </Step>

346 

347 <Step title="Generare una pull request">

348 ```text theme={null}

349 create a pr

350 ```

351 </Step>

352 

353 <Step title="Rivedere e affinare">

354 ```text theme={null}

355 enhance the PR description with more context about the security improvements

356 ```

357 </Step>

358</Steps>

359 

360Quando crei una PR utilizzando `gh pr create`, la sessione viene automaticamente collegata a quella PR. Puoi riprenderla in seguito con `claude --from-pr <number>`.

361 

362<Tip>

363 Rivedi la PR generata da Claude prima di inviarla e chiedi a Claude di evidenziare i rischi potenziali o le considerazioni.

364</Tip>

365 

366## Gestire la documentazione

367 

368Supponiamo che tu debba aggiungere o aggiornare la documentazione per il tuo codice.

369 

370<Steps>

371 <Step title="Identificare il codice non documentato">

372 ```text theme={null}

373 find functions without proper JSDoc comments in the auth module

374 ```

375 </Step>

376 

377 <Step title="Generare la documentazione">

378 ```text theme={null}

379 add JSDoc comments to the undocumented functions in auth.js

380 ```

381 </Step>

382 

383 <Step title="Rivedere e migliorare">

384 ```text theme={null}

385 improve the generated documentation with more context and examples

386 ```

387 </Step>

388 

389 <Step title="Verificare la documentazione">

390 ```text theme={null}

391 check if the documentation follows our project standards

392 ```

393 </Step>

394</Steps>

395 

396<Tip>

397 Suggerimenti:

398 

399 * Specifica lo stile di documentazione che desideri (JSDoc, docstrings, ecc.)

400 * Chiedi esempi nella documentazione

401 * Richiedi documentazione per API pubbliche, interfacce e logica complessa

402</Tip>

403 

404***

405 

406## Lavorare in note e cartelle non di codice

407 

408Claude Code funziona in qualsiasi directory. Eseguilo all'interno di un vault di note, una cartella di documentazione o qualsiasi raccolta di file markdown per cercare, modificare e riorganizzare il contenuto nello stesso modo in cui faresti con il codice.

409 

410La directory `.claude/` e `CLAUDE.md` si trovano insieme alle directory di configurazione di altri strumenti senza conflitti. Claude legge i file freschi ad ogni chiamata dello strumento, quindi vede le modifiche che fai in un'altra applicazione la prossima volta che legge quel file.

411 

412***

413 

414## Lavorare con le immagini

415 

416Supponiamo che tu debba lavorare con immagini nella tua base di codice e desideri l'aiuto di Claude nell'analizzare il contenuto dell'immagine.

417 

418<Steps>

419 <Step title="Aggiungere un'immagine alla conversazione">

420 Puoi utilizzare uno di questi metodi:

421 

422 1. Trascina e rilascia un'immagine nella finestra di Claude Code

423 2. Copia un'immagine e incollala nella CLI con ctrl+v (Non usare cmd+v)

424 3. Fornisci un percorso di immagine a Claude. Ad esempio, "Analyze this image: /path/to/your/image.png"

425 </Step>

426 

427 <Step title="Chiedere a Claude di analizzare l'immagine">

428 ```text theme={null}

429 What does this image show?

430 ```

431 

432 ```text theme={null}

433 Describe the UI elements in this screenshot

434 ```

435 

436 ```text theme={null}

437 Are there any problematic elements in this diagram?

438 ```

439 </Step>

440 

441 <Step title="Utilizzare le immagini per il contesto">

442 ```text theme={null}

443 Here's a screenshot of the error. What's causing it?

444 ```

445 

446 ```text theme={null}

447 This is our current database schema. How should we modify it for the new feature?

448 ```

449 </Step>

450 

451 <Step title="Ottenere suggerimenti di codice dal contenuto visivo">

452 ```text theme={null}

453 Generate CSS to match this design mockup

454 ```

455 

456 ```text theme={null}

457 What HTML structure would recreate this component?

458 ```

459 </Step>

460</Steps>

461 

462<Tip>

463 Suggerimenti:

464 

465 * Usa le immagini quando le descrizioni di testo sarebbero poco chiare o ingombranti

466 * Includi screenshot di errori, design dell'interfaccia utente o diagrammi per un contesto migliore

467 * Puoi lavorare con più immagini in una conversazione

468 * L'analisi delle immagini funziona con diagrammi, screenshot, mockup e altro

469 * Quando Claude fa riferimento a immagini (ad esempio, `[Image #1]`), `Cmd+Click` (Mac) o `Ctrl+Click` (Windows/Linux) il collegamento per aprire l'immagine nel tuo visualizzatore predefinito

470</Tip>

471 

472***

473 

474## Fare riferimento a file e directory

475 

476Usa @ per includere rapidamente file o directory senza aspettare che Claude li legga.

477 

478<Steps>

479 <Step title="Fare riferimento a un singolo file">

480 ```text theme={null}

481 Explain the logic in @src/utils/auth.js

482 ```

483 

484 Questo include il contenuto completo del file nella conversazione.

485 </Step>

486 

487 <Step title="Fare riferimento a una directory">

488 ```text theme={null}

489 What's the structure of @src/components?

490 ```

491 

492 Questo fornisce un elenco di directory con informazioni sui file.

493 </Step>

494 

495 <Step title="Fare riferimento alle risorse MCP">

496 ```text theme={null}

497 Show me the data from @github:repos/owner/repo/issues

498 ```

499 

500 Questo recupera i dati dai server MCP connessi utilizzando il formato @server:resource. Vedi [risorse MCP](/it/mcp#use-mcp-resources) per i dettagli.

501 </Step>

502</Steps>

503 

504<Tip>

505 Suggerimenti:

506 

507 * I percorsi dei file possono essere relativi o assoluti

508 * I riferimenti ai file @ aggiungono `CLAUDE.md` nella directory del file e nelle directory padre al contesto

509 * I riferimenti alle directory mostrano elenchi di file, non contenuti

510 * Puoi fare riferimento a più file in un singolo messaggio (ad esempio, "@file1.js and @file2.js")

511</Tip>

512 

513***

514 

515## Utilizzare il pensiero esteso (Thinking Mode)

516 

517[Extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking) è abilitato per impostazione predefinita, dando a Claude lo spazio per ragionare attraverso problemi complessi passo dopo passo prima di rispondere. Questo ragionamento è visibile in modalità verbose, che puoi attivare con `Ctrl+O`. Durante il pensiero esteso, lo spinner mostra suggerimenti di progresso inline come "still thinking" e "almost done thinking" per indicare che Claude sta lavorando attivamente.

518 

519Inoltre, i [modelli che supportano lo sforzo](/it/model-config#adjust-effort-level) utilizzano il ragionamento adattivo: invece di un budget di token di pensiero fisso, il modello decide dinamicamente se e quanto pensare in base alla tua impostazione di livello di sforzo e al compito in questione. Il ragionamento adattivo consente a Claude di rispondere più velocemente ai prompt di routine e di riservare un pensiero più profondo ai passaggi che ne traggono beneficio.

520 

521Extended thinking è particolarmente prezioso per decisioni architettoniche complesse, bug impegnativi, pianificazione dell'implementazione multi-step e valutazione dei compromessi tra diversi approcci.

522 

523<Note>

524 Frasi come "think", "think hard" e "think more" sono interpretate come istruzioni di prompt regolari e non allocano token di pensiero.

525</Note>

526 

527### Configurare Thinking Mode

528 

529Il pensiero è abilitato per impostazione predefinita, ma puoi regolarlo o disabilitarlo.

530 

531| Ambito | Come configurare | Dettagli |

532| --------------------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

533| **Livello di sforzo** | Esegui `/effort`, regola in `/model`, o imposta [`CLAUDE_CODE_EFFORT_LEVEL`](/it/env-vars) | Controlla la profondità del pensiero su [modelli supportati](/it/model-config#adjust-effort-level) |

534| **Parola chiave `ultrathink`** | Includi "ultrathink" in qualsiasi punto del tuo prompt | Aggiunge un'istruzione in-context che dice al modello di ragionare di più su quel turno. Non cambia il livello di sforzo stesso; vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) per questo |

535| **Scorciatoia di attivazione/disattivazione** | Premi `Option+T` (macOS) o `Alt+T` (Windows/Linux) | Attiva/disattiva il pensiero per la sessione corrente (tutti i modelli). Potrebbe richiedere la [configurazione del terminale](/it/terminal-config) per abilitare le scorciatoie da tastiera Option |

536| **Predefinito globale** | Usa `/config` per attivare/disattivare Thinking Mode | Imposta il tuo predefinito in tutti i progetti (tutti i modelli).<br />Salvato come `alwaysThinkingEnabled` in `~/.claude/settings.json` |

537| **Limitare il budget dei token** | Imposta la variabile di ambiente [`MAX_THINKING_TOKENS`](/it/env-vars) | Limita il budget di pensiero a un numero specifico di token. Su modelli con ragionamento adattivo, solo `0` si applica a meno che il ragionamento adattivo non sia disabilitato. Esempio: `export MAX_THINKING_TOKENS=10000` |

538 

539Per visualizzare il processo di pensiero di Claude, premi `Ctrl+O` per attivare la modalità verbose e vedi il ragionamento interno visualizzato come testo grigio in corsivo.

540 

541### Come funziona il pensiero esteso

542 

543Extended thinking controlla quanto ragionamento interno Claude esegue prima di rispondere. Più pensiero fornisce più spazio per esplorare soluzioni, analizzare casi limite e autocorreggersi gli errori.

544 

545Su [modelli che supportano lo sforzo](/it/model-config#adjust-effort-level), il pensiero utilizza il ragionamento adattivo: il modello alloca dinamicamente i token di pensiero in base al livello di sforzo che selezioni. Questo è il modo consigliato per sintonizzare il compromesso tra velocità e profondità di ragionamento. Se desideri che Claude pensi più o meno spesso di quanto il tuo livello di sforzo produrrebbe altrimenti, puoi anche dirlo direttamente nel tuo prompt o in `CLAUDE.md`.

546 

547Con modelli più vecchi, il pensiero utilizza un budget fisso di token prelevato dalla tua allocazione di output. Il budget varia in base al modello; vedi [`MAX_THINKING_TOKENS`](/it/env-vars) per i massimali per modello. Puoi limitare il budget con quella variabile di ambiente, o disabilitare completamente il pensiero tramite `/config` o l'attivazione/disattivazione `Option+T`/`Alt+T`.

548 

549Su modelli con ragionamento adattivo, `MAX_THINKING_TOKENS` si applica solo quando impostato su `0` per disabilitare il pensiero, o quando `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` ripristina il modello al budget fisso. `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` si applica solo a Opus 4.6 e Sonnet 4.6. Opus 4.7 utilizza sempre il ragionamento adattivo e non supporta un budget di pensiero fisso. Vedi [variabili di ambiente](/it/env-vars).

550 

551<Warning>

552 Ti viene addebitato per tutti i token di pensiero utilizzati anche quando i riassunti di pensiero sono redatti. In modalità interattiva, il pensiero appare come uno stub compresso per impostazione predefinita. Imposta `showThinkingSummaries: true` in `settings.json` per mostrare riassunti completi.

553</Warning>

554 

555***

556 

557## Riprendere conversazioni precedenti

558 

559Quando avvii Claude Code, puoi riprendere una sessione precedente:

560 

561* `claude --continue` continua la conversazione più recente nella directory corrente

562* `claude --resume` apre un selettore di conversazione o riprende per nome

563* `claude --from-pr 123` riprende le sessioni collegate a una pull request specifica

564 

565Da una sessione attiva, usa `/resume` per passare a una conversazione diversa.

566 

567Quando la sessione selezionata è vecchia e abbastanza grande che rileggere la richiederebbe una quota sostanziale dei tuoi limiti di utilizzo, `--resume`, `--continue` e `/resume` offrono di riprendere da un riassunto invece di caricare la trascrizione completa. Questo prompt non è disponibile su Amazon Bedrock, Google Cloud Vertex AI o Microsoft Foundry.

568 

569Le sessioni vengono archiviate per directory di progetto. Per impostazione predefinita, il selettore `/resume` mostra le sessioni interattive dal worktree corrente, con scorciatoie da tastiera per ampliare l'elenco ad altri worktree o progetti, cercare, visualizzare l'anteprima e rinominare. Vedi [Utilizzare il selettore di sessione](#use-the-session-picker) di seguito per il riferimento completo delle scorciatoie.

570 

571Quando selezioni una sessione da un altro worktree dello stesso repository, Claude Code la riprende direttamente senza richiedere di cambiare directory prima. Selezionare una sessione da un progetto non correlato copia un comando `cd` e resume negli appunti.

572 

573La ripresa per nome si risolve nel repository corrente e nei suoi worktree. Sia `claude --resume <name>` che `/resume <name>` cercano una corrispondenza esatta e la riprendono direttamente, anche se la sessione si trova in un worktree diverso.

574 

575Quando il nome è ambiguo, `claude --resume <name>` apre il selettore con il nome pre-compilato come termine di ricerca. `/resume <name>` da una sessione attiva segnala un errore, quindi esegui `/resume` senza argomenti per aprire il selettore e scegliere.

576 

577Le sessioni create da `claude -p` o da invocazioni SDK non appaiono nel selettore, ma puoi comunque riprenderne una passando il suo ID di sessione direttamente a `claude --resume <session-id>`.

578 

579### Denominare le tue sessioni

580 

581Dai alle sessioni nomi descrittivi per trovarle in seguito. Questa è una best practice quando lavori su più attività o funzionalità.

582 

583<Steps>

584 <Step title="Denominare la sessione">

585 Denomina una sessione all'avvio con `-n`:

586 

587 ```bash theme={null}

588 claude -n auth-refactor

589 ```

590 

591 Oppure usa `/rename` durante una sessione, che mostra anche il nome sulla barra del prompt:

592 

593 ```text theme={null}

594 /rename auth-refactor

595 ```

596 

597 Puoi anche rinominare qualsiasi sessione dal selettore: esegui `/resume`, naviga a una sessione e premi `Ctrl+R`.

598 </Step>

599 

600 <Step title="Riprendere per nome in seguito">

601 Dalla riga di comando:

602 

603 ```bash theme={null}

604 claude --resume auth-refactor

605 ```

606 

607 O da una sessione attiva:

608 

609 ```text theme={null}

610 /resume auth-refactor

611 ```

612 </Step>

613</Steps>

614 

615### Utilizzare il selettore di sessione

616 

617Il comando `/resume` (o `claude --resume` senza argomenti) apre un selettore di sessione interattivo con queste funzionalità:

618 

619**Scorciatoie da tastiera nel selettore:**

620 

621| Scorciatoia | Azione |

622| :------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

623| `↑` / `↓` | Navigare tra le sessioni |

624| `→` / `←` | Espandere o comprimere le sessioni raggruppate |

625| `Enter` | Selezionare e riprendere la sessione evidenziata |

626| `Space` | Visualizzare l'anteprima del contenuto della sessione. `Ctrl+V` funziona anche su terminali che non lo catturano come incolla |

627| `Ctrl+R` | Rinominare la sessione evidenziata |

628| `/` o qualsiasi carattere stampabile diverso da `Space` | Entrare in modalità di ricerca e filtrare le sessioni |

629| `Ctrl+A` | Mostrare le sessioni da tutti i progetti su questa macchina. Premi di nuovo per ripristinare il repository corrente |

630| `Ctrl+W` | Mostrare le sessioni da tutti i worktree del repository corrente. Premi di nuovo per ripristinare il worktree corrente. Mostrato solo in repository con più worktree |

631| `Ctrl+B` | Filtrare le sessioni dal tuo ramo git corrente. Premi di nuovo per mostrare le sessioni da tutti i rami |

632| `Esc` | Uscire dal selettore o dalla modalità di ricerca |

633 

634**Organizzazione della sessione:**

635 

636Il selettore visualizza le sessioni con metadati utili:

637 

638* Nome della sessione se impostato, altrimenti il riassunto della conversazione o il primo prompt dell'utente

639* Tempo trascorso dall'ultima attività

640* Conteggio dei messaggi

641* Ramo Git (se applicabile)

642* Percorso del progetto, mostrato dopo l'ampliamento a tutti i progetti con `Ctrl+A`

643 

644Le sessioni fork (create con `/branch`, `/rewind`, o `--fork-session`) sono raggruppate insieme sotto la loro sessione radice, rendendo più facile trovare conversazioni correlate.

645 

646<Tip>

647 Suggerimenti:

648 

649 * **Denominare le sessioni in anticipo**: Usa `/rename` quando inizi a lavorare su un'attività distinta: è molto più facile trovare "payment-integration" che "explain this function" in seguito

650 * Usa `--continue` per un accesso rapido alla tua conversazione più recente nella directory corrente

651 * Usa `--resume session-name` quando sai quale sessione ti serve

652 * Usa `--resume` (senza un nome) quando hai bisogno di sfogliare e selezionare

653 * Per gli script, usa `claude --continue --print "prompt"` per riprendere in modalità non interattiva

654 * Premi `Space` nel selettore per visualizzare l'anteprima di una sessione prima di riprenderla

655 * La conversazione ripresa inizia con lo stesso modello e configurazione dell'originale

656 

657 Come funziona:

658 

659 1. **Archiviazione della conversazione**: Tutte le conversazioni vengono salvate automaticamente localmente con la loro cronologia completa dei messaggi

660 2. **Deserializzazione dei messaggi**: Quando si riprende, l'intera cronologia dei messaggi viene ripristinata per mantenere il contesto

661 3. **Stato dello strumento**: L'utilizzo dello strumento e i risultati della conversazione precedente vengono preservati

662 4. **Ripristino del contesto**: La conversazione riprende con tutto il contesto precedente intatto

663</Tip>

664 

665***

666 

667## Eseguire sessioni parallele di Claude Code con Git worktrees

668 

669Quando lavori su più attività contemporaneamente, hai bisogno che ogni sessione di Claude abbia la sua copia della base di codice in modo che le modifiche non si scontrino. I worktree Git risolvono questo creando directory di lavoro separate che hanno ciascuna i propri file e ramo, mentre condividono la stessa cronologia del repository e le connessioni remote. Ciò significa che puoi avere Claude che lavora su una funzionalità in un worktree mentre corregge un bug in un altro, senza che nessuna sessione interferisca con l'altra.

670 

671Usa il flag `--worktree` (`-w`) per creare un worktree isolato e avviare Claude in esso. Il valore che passi diventa il nome della directory del worktree e il nome del ramo:

672 

673```bash theme={null}

674# Avviare Claude in un worktree denominato "feature-auth"

675# Crea .claude/worktrees/feature-auth/ con un nuovo ramo

676claude --worktree feature-auth

677 

678# Avviare un'altra sessione in un worktree separato

679claude --worktree bugfix-123

680```

681 

682Se ometti il nome, Claude ne genera uno casuale automaticamente:

683 

684```bash theme={null}

685# Genera automaticamente un nome come "bright-running-fox"

686claude --worktree

687```

688 

689I worktree vengono creati in `<repo>/.claude/worktrees/<name>` e si diramano dal ramo remoto predefinito, che è dove `origin/HEAD` punta. Il ramo del worktree è denominato `worktree-<name>`.

690 

691Il ramo di base non è configurabile tramite un flag o un'impostazione di Claude Code. `origin/HEAD` è un riferimento archiviato nella tua directory `.git` locale che Git ha impostato una volta quando hai clonato. Se il ramo predefinito del repository cambia successivamente su GitHub o GitLab, il tuo `origin/HEAD` locale continua a puntare a quello vecchio, e i worktree si diramano da lì. Per risincronizzare il tuo riferimento locale con quello che il remoto considera attualmente il suo predefinito:

692 

693```bash theme={null}

694git remote set-head origin -a

695```

696 

697Questo è un comando Git standard che aggiorna solo la tua directory `.git` locale. Nulla sul server remoto cambia. Se desideri che i worktree si basino su un ramo specifico piuttosto che sul predefinito del remoto, impostalo esplicitamente con `git remote set-head origin your-branch-name`.

698 

699Per il controllo completo su come vengono creati i worktree, inclusa la scelta di una base diversa per invocazione, configura un [hook WorktreeCreate](/it/hooks#worktreecreate). L'hook sostituisce completamente la logica predefinita di `git worktree` di Claude Code, quindi puoi recuperare e diramati da qualsiasi ref di cui hai bisogno.

700 

701Puoi anche chiedere a Claude di "work in a worktree" o "start a worktree" durante una sessione, e creerà uno automaticamente.

702 

703### Worktree dei subagent

704 

705I subagent possono anche utilizzare l'isolamento del worktree per lavorare in parallelo senza conflitti. Chiedi a Claude di "use worktrees for your agents" o configuralo in un [subagent personalizzato](/it/sub-agents#supported-frontmatter-fields) aggiungendo `isolation: worktree` al frontmatter dell'agente. Ogni subagent ottiene il suo worktree che viene automaticamente pulito quando il subagent finisce senza modifiche.

706 

707### Pulizia del worktree

708 

709Quando esci da una sessione di worktree, Claude gestisce la pulizia in base al fatto che tu abbia apportato modifiche:

710 

711* **Nessuna modifica**: il worktree e il suo ramo vengono rimossi automaticamente

712* **Modifiche o commit esistenti**: Claude ti chiede se mantenere o rimuovere il worktree. Mantenere preserva la directory e il ramo in modo da poter tornare in seguito. Rimuovere elimina la directory del worktree e il suo ramo, scartando tutte le modifiche non sottoposte a commit e i commit

713 

714I worktree dei subagent orfani da un crash o da un'esecuzione parallela interrotta vengono rimossi automaticamente all'avvio una volta che sono più vecchi della tua impostazione [`cleanupPeriodDays`](/it/settings#available-settings), a condizione che non abbiano modifiche non sottoposte a commit, nessun file non tracciato e nessun commit non sottoposto a push. I worktree che crei con `--worktree` non vengono mai rimossi da questa pulizia.

715 

716Per pulire i worktree al di fuori di una sessione di Claude, usa la [gestione manuale del worktree](#manage-worktrees-manually).

717 

718<Tip>

719 Aggiungi `.claude/worktrees/` al tuo `.gitignore` per evitare che il contenuto del worktree appaia come file non tracciati nel tuo repository principale.

720</Tip>

721 

722### Copiare file ignorati da git nei worktree

723 

724I worktree Git sono checkout freschi, quindi non includono file non tracciati come `.env` o `.env.local` dal tuo repository principale. Per copiare automaticamente questi file quando Claude crea un worktree, aggiungi un file `.worktreeinclude` alla radice del tuo progetto.

725 

726Il file utilizza la sintassi `.gitignore` per elencare quali file copiare. Solo i file che corrispondono a un modello e sono anche ignorati da git vengono copiati, quindi i file tracciati non vengono mai duplicati.

727 

728```text .worktreeinclude theme={null}

729.env

730.env.local

731config/secrets.json

732```

733 

734Questo si applica ai worktree creati con `--worktree`, ai worktree dei subagent e alle sessioni parallele nell'[app desktop](/it/desktop#work-in-parallel-with-sessions).

735 

736### Gestire i worktree manualmente

737 

738Per un maggiore controllo sulla posizione del worktree e sulla configurazione del ramo, crea i worktree direttamente con Git. Questo è utile quando hai bisogno di controllare un ramo esistente specifico o posizionare il worktree al di fuori del repository.

739 

740```bash theme={null}

741# Creare un worktree con un nuovo ramo

742git worktree add ../project-feature-a -b feature-a

743 

744# Creare un worktree con un ramo esistente

745git worktree add ../project-bugfix bugfix-123

746 

747# Avviare Claude nel worktree

748cd ../project-feature-a && claude

749 

750# Pulire al termine

751git worktree list

752git worktree remove ../project-feature-a

753```

754 

755Scopri di più nella [documentazione ufficiale di Git worktree](https://git-scm.com/docs/git-worktree).

756 

757<Tip>

758 Ricorda di inizializzare il tuo ambiente di sviluppo in ogni nuovo worktree secondo la configurazione del tuo progetto. A seconda del tuo stack, questo potrebbe includere l'esecuzione dell'installazione delle dipendenze (`npm install`, `yarn`), la configurazione di ambienti virtuali o il seguire il processo di configurazione standard del tuo progetto.

759</Tip>

760 

761### Controllo della versione non git

762 

763L'isolamento del worktree funziona con git per impostazione predefinita. Per altri sistemi di controllo della versione come SVN, Perforce o Mercurial, configura gli hook [WorktreeCreate e WorktreeRemove](/it/hooks#worktreecreate) per fornire logica personalizzata di creazione e pulizia del worktree. Quando configurati, questi hook sostituiscono il comportamento git predefinito quando usi `--worktree`, quindi [`.worktreeinclude`](#copy-gitignored-files-to-worktrees) non viene elaborato. Copia qualsiasi file di configurazione locale all'interno dello script del tuo hook.

764 

765Per il coordinamento automatizzato di sessioni parallele con attività condivise e messaggistica, vedi [team di agenti](/it/agent-teams).

766 

767***

768 

769## Ricevere notifiche quando Claude ha bisogno della tua attenzione

770 

771Quando avvii un'attività a lunga esecuzione e passi a un'altra finestra, puoi configurare notifiche desktop in modo da sapere quando Claude finisce o ha bisogno del tuo input. Questo utilizza l'evento `Notification` [hook](/it/hooks-guide#get-notified-when-claude-needs-input), che si attiva ogni volta che Claude è in attesa di autorizzazione, inattivo e pronto per un nuovo prompt, o completando l'autenticazione.

772 

773<Steps>

774 <Step title="Aggiungere l'hook alle tue impostazioni">

775 Apri `~/.claude/settings.json` e aggiungi un hook `Notification` che chiama il comando di notifica nativa della tua piattaforma:

776 

777 <Tabs>

778 <Tab title="macOS">

779 ```json theme={null}

780 {

781 "hooks": {

782 "Notification": [

783 {

784 "matcher": "",

785 "hooks": [

786 {

787 "type": "command",

788 "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"

789 }

790 ]

791 }

792 ]

793 }

794 }

795 ```

796 </Tab>

797 

798 <Tab title="Linux">

799 ```json theme={null}

800 {

801 "hooks": {

802 "Notification": [

803 {

804 "matcher": "",

805 "hooks": [

806 {

807 "type": "command",

808 "command": "notify-send 'Claude Code' 'Claude Code needs your attention'"

809 }

810 ]

811 }

812 ]

813 }

814 }

815 ```

816 </Tab>

817 

818 <Tab title="Windows">

819 ```json theme={null}

820 {

821 "hooks": {

822 "Notification": [

823 {

824 "matcher": "",

825 "hooks": [

826 {

827 "type": "command",

828 "command": "powershell.exe -Command \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('Claude Code needs your attention', 'Claude Code')\""

829 }

830 ]

831 }

832 ]

833 }

834 }

835 ```

836 </Tab>

837 </Tabs>

838 

839 Se il tuo file di impostazioni ha già una chiave `hooks`, unisci la voce `Notification` in essa piuttosto che sovrascrivere. Puoi anche chiedere a Claude di scrivere l'hook per te descrivendo ciò che desideri nella CLI.

840 </Step>

841 

842 <Step title="Facoltativamente restringere il matcher">

843 Per impostazione predefinita l'hook si attiva su tutti i tipi di notifica. Per attivarsi solo per eventi specifici, imposta il campo `matcher` su uno di questi valori:

844 

845 | Matcher | Si attiva quando |

846 | :--------------------- | :----------------------------------------------------------- |

847 | `permission_prompt` | Claude ha bisogno che tu approvi un utilizzo dello strumento |

848 | `idle_prompt` | Claude ha finito ed è in attesa del tuo prossimo prompt |

849 | `auth_success` | L'autenticazione si completa |

850 | `elicitation_dialog` | Un server MCP apre un modulo di elicitazione |

851 | `elicitation_complete` | Un modulo di elicitazione MCP viene inviato o chiuso |

852 | `elicitation_response` | Una risposta di elicitazione MCP viene inviata al server |

853 </Step>

854 

855 <Step title="Verificare l'hook">

856 Digita `/hooks` e seleziona `Notification` per confermare che l'hook appare. Selezionarlo mostra il comando che verrà eseguito. Per testarlo end-to-end, chiedi a Claude di eseguire un comando che richiede autorizzazione e passa a un'altra finestra, oppure chiedi a Claude di attivare una notifica direttamente.

857 </Step>

858</Steps>

859 

860Per lo schema completo dell'evento e i tipi di notifica, vedi il [riferimento Notification](/it/hooks#notification).

861 

862***

863 

864## Utilizzare Claude come utilità di tipo unix

865 

866### Aggiungere Claude al tuo processo di verifica

867 

868Supponiamo che tu voglia utilizzare Claude Code come linter o revisore del codice.

869 

870**Aggiungere Claude al tuo script di build:**

871 

872```json theme={null}

873// package.json

874{

875 ...

876 "scripts": {

877 ...

878 "lint:claude": "claude -p 'you are a linter. please look at the changes vs. main and report any issues related to typos. report the filename and line number on one line, and a description of the issue on the second line. do not return any other text.'"

879 }

880}

881```

882 

883<Tip>

884 Suggerimenti:

885 

886 * Usa Claude per la revisione automatica del codice nella tua pipeline CI/CD

887 * Personalizza il prompt per verificare i problemi specifici rilevanti per il tuo progetto

888 * Considera di creare più script per diversi tipi di verifica

889</Tip>

890 

891### Pipe in, pipe out

892 

893Supponiamo che tu voglia inviare dati a Claude e ottenere dati in un formato strutturato.

894 

895**Inviare dati attraverso Claude:**

896 

897```bash theme={null}

898cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt

899```

900 

901<Tip>

902 Suggerimenti:

903 

904 * Usa i pipe per integrare Claude negli script shell esistenti

905 * Combina con altri strumenti Unix per flussi di lavoro potenti

906 * Considera di utilizzare `--output-format` per output strutturato

907</Tip>

908 

909### Controllare il formato di output

910 

911Supponiamo che tu abbia bisogno dell'output di Claude in un formato specifico, specialmente quando integri Claude Code in script o altri strumenti.

912 

913<Steps>

914 <Step title="Utilizzare il formato testo (predefinito)">

915 ```bash theme={null}

916 cat data.txt | claude -p 'summarize this data' --output-format text > summary.txt

917 ```

918 

919 Questo restituisce solo la risposta di testo semplice di Claude (comportamento predefinito).

920 </Step>

921 

922 <Step title="Utilizzare il formato JSON">

923 ```bash theme={null}

924 cat code.py | claude -p 'analyze this code for bugs' --output-format json > analysis.json

925 ```

926 

927 Questo restituisce un array JSON di messaggi con metadati inclusi costo e durata.

928 </Step>

929 

930 <Step title="Utilizzare il formato JSON in streaming">

931 ```bash theme={null}

932 cat log.txt | claude -p 'parse this log file for errors' --output-format stream-json

933 ```

934 

935 Questo restituisce una serie di oggetti JSON in tempo reale mentre Claude elabora la richiesta. Ogni messaggio è un oggetto JSON valido, ma l'intero output non è JSON valido se concatenato.

936 </Step>

937</Steps>

938 

939<Tip>

940 Suggerimenti:

941 

942 * Usa `--output-format text` per integrazioni semplici dove hai solo bisogno della risposta di Claude

943 * Usa `--output-format json` quando hai bisogno del registro completo della conversazione

944 * Usa `--output-format stream-json` per l'output in tempo reale di ogni turno di conversazione

945</Tip>

946 

947***

948 

949## Eseguire Claude su una pianificazione

950 

951Supponiamo che tu voglia che Claude gestisca un'attività automaticamente su base ricorrente, come rivedere le PR aperte ogni mattina, controllare le dipendenze settimanalmente o verificare i fallimenti di CI durante la notte.

952 

953Scegli un'opzione di pianificazione in base a dove desideri che l'attività venga eseguita:

954 

955| Opzione | Dove viene eseguita | Migliore per |

956| :---------------------------------------------------------- | :------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

957| [Routines](/it/routines) | Infrastruttura gestita da Anthropic | Attività che dovrebbero essere eseguite anche quando il tuo computer è spento. Possono anche attivarsi su chiamate API o eventi GitHub oltre a una pianificazione. Configura su [claude.ai/code/routines](https://claude.ai/code/routines). |

958| [Attività pianificate desktop](/it/desktop-scheduled-tasks) | La tua macchina, tramite l'app desktop | Attività che hanno bisogno di accesso diretto a file locali, strumenti o modifiche non sottoposte a commit. |

959| [GitHub Actions](/it/github-actions) | La tua pipeline CI | Attività legate a eventi del repository come PR aperte, o pianificazioni cron che dovrebbero vivere insieme alla tua configurazione del flusso di lavoro. |

960| [`/loop`](/it/scheduled-tasks) | La sessione CLI corrente | Polling rapido mentre una sessione è aperta. Le attività si fermano quando inizi una nuova conversazione; `--resume` e `--continue` ripristinano quelle non scadute. |

961 

962<Tip>

963 Quando scrivi prompt per attività pianificate, sii esplicito su cosa significhi il successo e cosa fare con i risultati. L'attività viene eseguita autonomamente, quindi non può fare domande di chiarimento. Ad esempio: "Review open PRs labeled `needs-review`, leave inline comments on any issues, and post a summary in the `#eng-reviews` Slack channel."

964</Tip>

965 

966***

967 

968## Chiedere a Claude delle sue capacità

969 

970Claude ha accesso integrato alla sua documentazione e può rispondere a domande sulle sue stesse funzionalità e limitazioni.

971 

972### Domande di esempio

973 

974```text theme={null}

975can Claude Code create pull requests?

976```

977 

978```text theme={null}

979how does Claude Code handle permissions?

980```

981 

982```text theme={null}

983what skills are available?

984```

985 

986```text theme={null}

987how do I use MCP with Claude Code?

988```

989 

990```text theme={null}

991how do I configure Claude Code for Amazon Bedrock?

992```

993 

994```text theme={null}

995what are the limitations of Claude Code?

996```

997 

998<Note>

999 Claude fornisce risposte basate sulla documentazione a queste domande. Per dimostrazioni pratiche, esegui `/powerup` per lezioni interattive con demo animate, o fai riferimento alle sezioni di flusso di lavoro specifiche sopra.

1000</Note>

1001 

1002<Tip>

1003 Suggerimenti:

1004 

1005 * Claude ha sempre accesso alla documentazione più recente di Claude Code, indipendentemente dalla versione che stai utilizzando

1006 * Fai domande specifiche per ottenere risposte dettagliate

1007 * Claude può spiegare funzionalità complesse come integrazione MCP, configurazioni aziendali e flussi di lavoro avanzati

1008</Tip>

1009 

1010***

1011 

1012## Passaggi successivi

1013 

1014<CardGroup cols={2}>

1015 <Card title="Best practices" icon="lightbulb" href="/it/best-practices">

1016 Modelli per ottenere il massimo da Claude Code

1017 </Card>

1018 

1019 <Card title="Come funziona Claude Code" icon="gear" href="/it/how-claude-code-works">

1020 Comprendi il ciclo agentico e la gestione del contesto

1021 </Card>

1022 

1023 <Card title="Estendere Claude Code" icon="puzzle-piece" href="/it/features-overview">

1024 Aggiungi skills, hooks, MCP, subagent e plugin

1025 </Card>

1026 

1027 <Card title="Implementazione di riferimento" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">

1028 Clona l'implementazione di riferimento del contenitore di sviluppo

1029 </Card>

1030</CardGroup>