> ## Documentation Index > Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Lascia che Claude coordini il lavoro in corso con Projects > Fornisci a Claude un corpo di lavoro correlato in una conversazione e lascia che coordini sessioni cloud parallele che condividono repository, istruzioni e memoria. Projects è in beta pubblica sui piani Pro e Max e sta venendo implementato gradualmente, a partire da account che hanno utilizzato [sessioni cloud](/docs/it/claude-code-on-the-web) e non hanno progetti esistenti in claude.ai chat o Cowork. Non sono ancora disponibili sui piani Team o Enterprise. Se **Projects** non appare nella barra laterale su [claude.ai/code](https://claude.ai/code) o nella scheda Code dell'[app desktop](/docs/it/desktop), l'implementazione non ha ancora raggiunto il tuo account, e puoi [unirti alla lista d'attesa](https://claude.com/form/projects). [Esegui agenti in parallelo](/docs/it/agents) elenca cosa puoi utilizzare nel frattempo. Un progetto è una conversazione in corso dove Claude coordina un flusso di lavoro correlato per te. Gli dici cosa deve essere fatto e lui avvia un thread per ogni attività. Ogni thread è una [sessione cloud](/docs/it/claude-code-on-the-web): Claude Code in esecuzione nel cloud piuttosto che sulla tua macchina. I thread vengono eseguiti in parallelo e continuano dopo che chiudi il laptop. Senza un progetto, eseguire più sessioni significa fare il coordinamento da solo: decidi su cosa lavora ciascuno, ripeti lo stesso contesto all'inizio di ciascuno, e controlli indietro per vedere quale è terminato o ha bisogno di una risposta. Con un progetto, invece: * **Invia il lavoro in un unico posto**: incolla una segnalazione di bug, una traccia dello stack, o un elenco di attività nella conversazione ogni volta che ne viene fuori una. Claude avvia un thread per ogni pezzo di lavoro o lo passa al thread già al lavoro in quell'area, e risponde a domande rapide sul posto. * **Imposta il contesto una volta**: ogni nuovo thread inizia con i repository, le istruzioni e la memoria del progetto, quindi una regola che dichiari una volta, come quale branch scegliere come target, raggiunge tutti loro. * **Allontanati e torna al lavoro finito**: quando torni un'ora dopo o la mattina successiva, il riquadro **Overview** mostra quali thread sono terminati, quali pull request sono pronte per la revisione, e quale thread sta aspettando la tua risposta. Se conosci già il lavoro che desideri che un progetto esegua, vai direttamente a [Crea un progetto](#create-a-project).

Quando creare un progetto

Un progetto vale la pena crearlo quando il lavoro ha un obiettivo che va oltre una singola sessione e continua a generare attività. Questi tipi di lavoro si adattano bene a un progetto: * **Un obiettivo su molti repository**: "Portare ogni servizio alla nuova configurazione lint." Claude può eseguire un thread per repository, ognuno con la propria pull request, e il riquadro [**Overview**](#see-what-needs-you-in-overview) mostra quali sono pronti per la revisione. * **Un'area che continui ad alimentare**: i bug, le stack trace e le richieste di revisione per un servizio, incollati nella conversazione man mano che li ricevi. Un errore che dici a Claude di ricordare dopo una correzione è nella [memoria del progetto](#give-a-project-standing-context) per il prossimo. * **Una build o migrazione più grande di una sessione**: "Costruisci quello che `docs/spec.md` descrive" o "Sposta l'app dal vecchio ORM deprecato." Il lavoro si divide in thread che affrontano ciascuno una parte, le decisioni che chiedi a Claude di ricordare all'inizio raggiungono i thread successivi, e le specifiche e i bug che trovi durante la build vanno nella stessa conversazione. * **Lavoro che non è codice**: una cartella di contratti o un'esportazione di ticket di supporto a cui continui a tornare con nuove domande, come "trova i dieci errori di integrazione più comuni in questi ticket." Carica i documenti invece di aggiungere un repository, e i thread consegnano ogni relazione come file nella scheda [**Library**](#see-what-needs-you-in-overview) del progetto. In ognuno di essi puoi inviare un batch di attività, dire a Claude di iniziare senza chiederti di confermare, allontanarti e trovare i thread che hanno bisogno di te sotto [**Waiting on you**](#see-what-needs-you-in-overview) quando torni, oppure chiedere a Claude di mettere parte del lavoro in un programma come [routine](/docs/it/routines). Se una di queste è la tua situazione, [crea un progetto](#create-a-project).

Quando qualcos'altro si adatta meglio

I thread funzionano su repository GitHub e sui file, cartelle e cartelle Google Drive che carichi nel progetto, non su file o strumenti che esistono solo sulla tua macchina. Qualcos'altro si adatta meglio in questi casi: * **Un'attività che rientra in una sessione**: "Correggi il test di login instabile." Avvia una [cloud session](/docs/it/claude-code-on-the-web) tu stesso. * **Lavoro che ha bisogno di strumenti o servizi che solo la tua macchina può raggiungere**: un database locale, un emulatore di dispositivo, un'API dietro il tuo VPN. Usa una sessione locale, o [agent view](/docs/it/agent-view) per eseguirne diversi contemporaneamente. Se il lavoro ha bisogno solo di file locali, caricali nel progetto invece. * **Un'attività che si ripete in un programma senza conversazione intorno**: "Pubblica un rapporto di dipendenza ogni lunedì." Crea una [routine](/docs/it/routines) da sola. * **Più persone che danno a Claude lavoro e lo guidano insieme in un canale Slack**: vedi [Claude Tag](https://claude.com/docs/claude-tag/overview). Un progetto attinge ai stessi limiti di piano delle tue altre sessioni Claude Code e li utilizza più velocemente. [Usage and cost](#usage-and-cost) copre cosa attinge al tuo piano e come mantenerlo basso.

Come è organizzato un project

Un project è una conversazione di coordinamento con Claude più i thread che avvia per fare il lavoro. Queste sono le sue parti: * **La conversazione del project**: una sessione di lunga durata dove Claude agisce come coordinatore. Prende quello che invii, decide cosa diventa un thread e tiene traccia di ogni thread che ha avviato. Vede cosa i thread riportano, non ogni passo che compiono. * **Thread**: i lavoratori. Ognuno è una [sessione cloud](/docs/it/claude-code-on-the-web) separata con la propria finestra di contesto che fa un pezzo di lavoro sul proprio branch, apre una pull request quando il lavoro lo richiede, e riporta alla conversazione quando finisce. * **Quello con cui ogni thread inizia**: * I repository e i file del project, più le sue [istruzioni e memoria](#give-a-project-standing-context) * Il `CLAUDE.md`, le skills e i plugins in [ognuno dei repository del project](#what-threads-pick-up-from-your-repositories), e in un project con un repository, anche le regole di permesso e gli hook di quel repository * I [connectors](#get-skills-plugins-connectors-and-tools-into-threads) sul tuo account claude.ai * Un [cloud environment](#choose-an-environment-for-threads) che imposta il suo accesso di rete, le variabili di ambiente, le credenziali API e gli strumenti installati * **Il riquadro Overview**: dove [vedi tutti i thread contemporaneamente](#see-what-needs-you-in-overview) e quali di loro ti servono. Le sue altre schede sono **Library** per i file che hai aggiunto e i file che i thread hanno prodotto, **Pull requests** per quelli che i thread hanno aperto, e **Routines** per il lavoro programmato nel project. I thread non raccolgono nulla dalla configurazione Claude Code sulla tua macchina. [Ottieni skills, plugins, connectors e strumenti nei thread](#get-skills-plugins-connectors-and-tools-into-threads) copre come dargli quello che altrimenti mancherebbe. Ecco come quelle parti si collegano, da te attraverso la conversazione ai thread che fanno il lavoro, con **Overview** che traccia il loro stato: Diagramma di un project. Scrivi nella conversazione del project, dove Claude risponde o avvia un thread. Ogni thread è una sessione cloud che lavora sul proprio branch e pull request. Il riquadro Overview elenca i thread per stato, come pronto per la revisione, in attesa di te e in lavoro. Diagramma di un project. Scrivi nella conversazione del project, dove Claude risponde o avvia un thread. Ogni thread è una sessione cloud che lavora sul proprio branch e pull request. Il riquadro Overview elenca i thread per stato, come pronto per la revisione, in attesa di te e in lavoro.

Crea un project

Crei e usi i project su [claude.ai/code](https://claude.ai/code) o nella scheda Code dell'app desktop. Ci sono due modi per iniziarne uno: * **Da zero**, quando conosci il flusso di lavoro che vuoi che Claude esegua: apri la finestra di dialogo **New project** e assegnagli un nome. [Avvia un nuovo project da zero](#start-a-new-project-from-scratch) ti guida attraverso la finestra di dialogo. * **Da una sessione cloud che sta già facendo il lavoro**: scegli **Continue as a project** dal menu di quella sessione, e Claude propone la configurazione del project da quello che la sessione stava facendo. Vedi [Avvia da una sessione cloud esistente](#start-from-an-existing-cloud-session). In entrambi i casi, [controlla i prerequisiti](#check-the-prerequisites) prima.

Controlla i prerequisiti

Prima di creare un project, controlla il tuo piano, la tua configurazione GitHub e cosa il lavoro ha bisogno di raggiungere: * **Piano**: sei su Pro o Max e **Projects** appare nella tua barra laterale. * **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`](/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. * **Rete, credenziali e strumenti**: questi provengono dal [cloud environment](#choose-an-environment-for-threads) del project. L'ambiente predefinito raggiunge già [registri di pacchetti comuni](/docs/it/cloud-environments#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 [connectors claude.ai](https://claude.ai/customize/connectors).

Avvia un nuovo project da zero

Avviare un project da zero significa aprire la finestra di dialogo **New project**, assegnare un nome al flusso di lavoro e facoltativamente dargli un obiettivo e i repository e i file su cui lavora. Solo il nome è obbligatorio, quindi puoi creare il project prima e riempire il resto mentre il lavoro prende forma. Su [claude.ai/code](https://claude.ai/code) o nella scheda Code dell'app desktop, seleziona **Projects** nella barra laterale sinistra, quindi seleziona **New project**. In un browser puoi anche andare direttamente a [claude.ai/code/projects/browse](https://claude.ai/code/projects/browse). Limita il project a un flusso di lavoro che continuerai ad aggiungere, come tutto quello che serve per mantenere un'API sotto il suo obiettivo di latenza. [Quando usare un project](#when-to-use-a-project) ha più esempi. Quindi compila i campi della finestra di dialogo: * **Name**: come il project appare nell'elenco **Projects**. * **Goal** (facoltativo): una riga di quello che stai cercando di realizzare, come "Mantieni la latenza API p95 sotto 200 ms". Claude nella conversazione lavora verso di esso. Senza un obiettivo, Claude lavora dai compiti che invii, e puoi aggiungere un obiettivo in seguito in **Project settings > General**. * **Context** (facoltativo): i repository GitHub su cui questo project lavora, più eventuali file, cartelle o cartelle Google Drive che i thread dovrebbero leggere. Fai clic su **Add** per ognuno. Aggiungi i repository di cui la maggior parte dei compiti ha bisogno piuttosto che ogni uno che il lavoro potrebbe toccare; [Decidi quali repository aggiungere](#decide-which-repositories-to-add) copre la scelta, e puoi aggiungerne altri in seguito in **Project settings > Environment**. Le regole permanenti su come i thread dovrebbero funzionare vanno in [project instructions](#give-a-project-standing-context), che imposti dopo che il project esiste. Fai clic su **Create project**. La conversazione del project si apre con una casella di messaggio in basso, dove descrivi il lavoro per Claude. Nel tuo primo project, Claude prende un turno da solo non appena il project viene creato, a meno che tu non invii un messaggio per primo. Quel turno usa il tuo piano. In esso, Claude potrebbe: * Avviare un thread che esplora il repository senza cambiare nulla e propone i prossimi passi, se il project ha un repository che può leggere. * Pubblicare **Setup recommendations** tratte dalle tue recenti sessioni cloud: repository da aggiungere, routine da creare e thread che potrebbe avviare. Ogni repository e routine consigliati iniziano attivati. Disattiva quelli che non vuoi, quindi fai clic su **Update setup** per aggiungere il resto, o ignora le raccomandazioni e descrivi il lavoro da solo. Il project è ora elencato sotto **Projects** nella barra laterale, e la sua conversazione è aperta. [Il tuo primo batch](#your-first-batch) copre cosa configurare prima di inviargli il lavoro.

Avvia da una sessione cloud esistente

Se hai già una sessione cloud che sta facendo lavoro che appartiene a un project, apri il menu della sessione nella barra laterale e scegli **Continue as a project** o **Move to project**: * **Continue as a project** crea un nuovo project denominato dopo la sessione e lo apre. Claude legge la sessione e pubblica **Setup recommendations** nella conversazione per te da confermare. La sessione originale rimane nel tuo elenco di sessioni, e se era nel mezzo di un turno continua a funzionare, quindi fermala da solo se non vuoi che entrambi funzionino contemporaneamente. Se usi il banner **Set up project** che può apparire sopra la casella di messaggio della sessione cloud, il risultato è lo stesso, tranne che il turno in esecuzione della sessione si ferma una volta che il project si apre. * **Move to project** porta il lavoro della sessione in un project esistente. Pubblica un messaggio in quella conversazione del project chiedendo a Claude di leggere la sessione e riprendere da dove l'ha lasciata, e il nuovo lavoro continua nei propri thread del project. La sessione originale rimane nel tuo elenco di sessioni, invariata.

Configura l'accesso a GitHub

La maggior parte della configurazione di GitHub accade una volta, non per project. Connetti il tuo account GitHub a Claude una volta, e l'app Claude GitHub è installata una volta per repository, o una volta per un'intera organizzazione GitHub se le dai tutti i repository. Torni a questi passaggi quando aggiungi un repository che l'app Claude GitHub non copre ancora o uno in un'organizzazione GitHub che applica SSO. Se non hai mai usato claude.ai/code prima, la tua prima visita ti guida attraverso la connessione di GitHub; vedi [Connetti GitHub](/docs/it/web-quickstart#connect-github). Altrimenti usa una delle [opzioni di autenticazione GitHub](/docs/it/claude-code-on-the-web#github-authentication-options). Installa l'[app Claude GitHub](https://github.com/apps/claude) e concedile i repository che il project userà. Su un repository di proprietà di un'organizzazione GitHub, solo un proprietario dell'organizzazione può completare l'installazione; se non lo sei, GitHub invia al proprietario una richiesta di installazione e il project non può usare il repository fino a quando non la approva. Se un'organizzazione GitHub applica SAML SSO, riconnetti GitHub e autorizza l'app Claude per quell'organizzazione. Fino a quando non lo fai, i repository privati di quell'organizzazione non appaiono nella finestra di dialogo **New project** o **Project settings > Environment**. Quando uno di questi passaggi è incompleto, la finestra di dialogo **New project** e la pagina del project denominano il passaggio mancante e collegano a dove lo completi. Completa il passaggio lì, quindi fai clic su **Check again** se la finestra di dialogo lo offre. Se un repository è ancora mancante dall'elenco in seguito, apri l'installazione dell'app Claude GitHub su GitHub, su [github.com/settings/installations](https://github.com/settings/installations) per un account personale, e conferma che il repository è elencato sotto **Repository access**. Per i messaggi di errore che un thread o il project segnala quando l'accesso è ancora sbagliato, vedi [Errori di accesso al repository](#repository-access-errors).

Lavora in un project

Dai a Claude il lavoro attraverso la conversazione del project: compiti uno alla volta o più contemporaneamente, più aggiornamenti e pensieri sciolti mentre si presentano. Claude instrada ogni messaggio, e i thread fanno il lavoro e riportano.

Il tuo primo batch

Prima di inviare a un nuovo project un batch di lavoro, configuralo in modo che i primi thread tornino nel modo che vuoi: 1. [Scrivi le istruzioni del project](#write-project-instructions): il briefing da cui ogni thread inizia, come quale branch scegliere come destinazione, come un thread controlla il suo lavoro e cosa ha bisogno della tua approvazione. 2. Invia un piccolo pezzo del lavoro reale, o avvia uno dei thread che Claude ha suggerito se ne ha offerti, e apri il thread quando finisce per vedere come riporta e cosa ha fatto sul suo branch. Se ha assunto qualcosa di sbagliato o non poteva raggiungere quello che aveva bisogno, [I thread hanno indovinato o si sono bloccati invece di chiedere](#threads-guessed-or-stalled-instead-of-asking) copre dove correggere. 3. Controlla **Thread model** e **Thread effort** in **Project settings > General**. Un nuovo project esegue ogni thread su Opus ad alto sforzo, che attinge al tuo piano più velocemente; [Scegli modelli e lascia che Claude gestisca il contesto](#choose-models-and-let-claude-manage-context) copre le alternative. 4. Chiedi a Claude di [proporre thread prima di avviarli e di eseguirne pochi contemporaneamente](#tune-how-claude-runs-a-project), e abbassa quei limiti una volta che pochi thread tornano nel modo che vuoi.

Invia il lavoro e leggi i risultati

Claude decide dove va ogni messaggio che invii nella conversazione: * Una domanda rapida di solito ottiene una risposta nella conversazione. * Il nuovo lavoro va a un nuovo thread o a un thread già al lavoro in quell'area, e Claude ti dice quale. Ogni nuovo thread appare sotto il tuo messaggio come una carta: una scatola con il titolo e lo stato del thread, che fai clic per aprire il thread. * Diversi compiti non correlati in un messaggio diventano thread separati. Se Claude instrada qualcosa diversamente da come volevi, dillo. [Sintonizza come Claude esegue un project](#tune-how-claude-runs-a-project) elenca le cose che puoi dirgli, come riutilizzare un thread esistente per i follow-up o rispondere sul posto invece di avviare un thread. I risultati completi di un thread rimangono nel thread, e apri la sua carta nella conversazione per leggerli. I file che un thread ha prodotto sono anche sulla scheda **Library** in **Overview**. A volte Claude propone thread invece di avviarli, in un elenco **Suggested threads**. Fai clic sulla freccia su un suggerimento per avviare quel thread. Quando più sono elencati, un pulsante sotto l'elenco avvia tutti loro.

Rivedi la pull request di un thread

Quando un thread cambia il codice, questo è quello che fa a meno che tu non gli dica diversamente: * **Branch**: lavora su un nuovo branch, iniziato dal branch predefinito del repository. * **Pull request**: apre una quando chiedi, e può aprirne una da sola per una correzione di bug o un altro cambiamento concreto. * **Dopo che si apre**: guarda la pull request con [auto-fix](/docs/it/claude-code-on-the-web#auto-fix-pull-requests) attivato, indipendentemente dal fatto che auto-fix sia attivato per le tue altre sessioni cloud. Spinge correzioni quando CI fallisce, affronta i commenti di revisione, e risponde nel thread quando i controlli passano e la pull request è pronta per te. La carta del thread nella conversazione mostra un pulsante per il prossimo passo della pull request quando ce n'è uno, come **Resolve conflicts**, **Fix CI**, **Address comments** o **Merge it**. Facendovi clic invii quell'istruzione al thread come messaggio da te, quindi puoi spingere il thread da solo invece di aspettare che reagisca alla pull request. **Review PR** apre la pull request su GitHub. Per cambiare quando i thread aprono le pull request, ad esempio solo quando chiedi, o quale branch iniziano, dillo nel compito o nelle [istruzioni del project](#write-project-instructions).

Vedi cosa ti serve in Overview

Il riquadro **Overview** accanto alla conversazione traccia i thread del project. È già aperto la prima volta che apri un nuovo project. Il pulsante **Overview** nell'intestazione del project lo chiude e lo riapre, e mostra un punto quando un thread ti sta aspettando. Nell'app desktop, ricevi anche una notifica desktop quando Claude pubblica nella conversazione, un thread colpisce un errore, o un thread ha bisogno del tuo input, quindi non devi tenere il project aperto per scoprirlo. Per riceverne anche una ogni volta che un thread finisce un turno, o per disattivarle per un project, scegli **Notifications** nel menu della barra laterale del project. Queste notifiche sono solo desktop: in un browser, controlla il punto sul pulsante **Overview**. La scheda **Threads** del riquadro raggruppa i thread per stato: | Gruppo | Cosa c'è dentro | | :------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Ready for review** | Thread la cui pull request è aperta e in attesa di revisione | | **Waiting on you** | Thread che hanno bisogno della tua risposta o approvazione, o che hanno fallito | | **Working** | Thread ancora in esecuzione | | **Landing** | Thread la cui pull request è approvata o in coda per l'unione | | **Idle** | Thread che hanno finito e non stanno aspettando nulla | | **Resolved** | Thread contrassegnati come fatto: da te dal menu del thread, da Claude una volta che hai preso l'ultimo passo, come unire la sua pull request, o automaticamente dopo una settimana senza attività. Puoi riaprirne uno dallo stesso menu | Le altre schede del riquadro sono **Library** per i file e le cartelle che hai aggiunto e i file che i thread hanno prodotto, **Pull requests** una volta che i thread ne hanno aperto, e **Routines** per le [routine](/docs/it/routines) che Claude ha configurato da questo project.

Apri un thread quando hai bisogno di controllo

Fai clic sulla carta di un thread nella conversazione o sulla sua riga in **Overview** per aprire la sua trascrizione nel riquadro Overview. Da lì puoi: * Leggere quello che Claude ha fatto, passo dopo passo. * Guidare il compito scrivendo nella casella di messaggio del thread. Un messaggio lì va direttamente a quel thread, mentre un follow-up nella conversazione del project lo raggiunge solo quando Claude abbina il follow-up a quel thread. * Rispondere a un prompt di permesso su cui il thread sta aspettando. * Interrompere il thread con **Stop**, che sostituisce il pulsante di invio mentre il thread sta funzionando, o premendo Esc.

Scegli modelli e lascia che Claude gestisca il contesto

Imposta modelli e sforzo in **Project settings > General**. Un nuovo project esegue Opus ovunque, con alto [sforzo](/docs/it/model-config#adjust-effort-level) per i thread e basso sforzo per la conversazione: * **Thread model** e **Thread effort** si applicano ai thread. Per usare un modello diverso per un compito, chiedilo nel compito; per un thread già in esecuzione, usa il selettore di modello di quel thread. * **Coordinator model** e **Coordinator effort** si applicano a Claude nella conversazione del project. Non gestisci le finestre di contesto in un project. I thread si compattano automaticamente, e la conversazione funziona da messaggi recenti, thread recenti e project memory piuttosto che dalla sua storia completa, quindi continua finché il project funziona. Metti qualsiasi cosa che non deve mai essere eliminata in [project memory](#give-a-project-standing-context). Se un thread supera il suo contesto, mostra [Claude ha esaurito il contesto in questo turno](#context-limit).

Sintonizza come Claude esegue un project

Dì a Claude nella conversazione quanti thread eseguire contemporaneamente, quando pubblicare aggiornamenti e quando aprire pull request. Se Claude sta coordinando in un modo che non vuoi, dillo. Ad esempio, puoi dire: * "Proponi thread e aspetta la mia approvazione prima di avviarli" o "Avvia questi ora senza chiedermi di confermare" * "Esegui al massimo due thread contemporaneamente" o "Riutilizza un thread esistente per i follow-up nella stessa area" * "Pubblica aggiornamenti più brevi" o "Pubblica solo quando qualcosa finisce o è bloccato" * "Dammi un aggiornamento di stato su ogni thread" * "Fai questo compito con un modello più piccolo" * "Non aprire una pull request finché non ho visto il piano" * "Dimmi cosa c'è di sbagliato in questi repository e non correggere nulla ancora", quando vuoi esaminare i risultati prima che uno di loro diventi un thread * "Rispondi qui invece di avviare un thread", quando Claude avvia un thread per qualcosa che intendevi come una domanda rapida Claude salva preferenze come queste in [project memory](#give-a-project-standing-context) da solo e le segue nei thread successivi. Sono istruzioni che Claude segue, non impostazioni applicate, quindi un limite di thread che dai in questo modo non è un limite rigido. Aggiungine uno alle istruzioni del project quando vuoi che sia formulato esattamente e applicato a ogni thread dall'inizio.

Sblocca un thread in attesa di approvazione

I thread vengono eseguiti in [auto mode](/docs/it/permission-modes#eliminate-prompts-with-auto-mode) quando il modello del thread lo supporta, quindi la maggior parte delle chiamate di strumento vengono eseguite senza chiederti. Quando un thread ha bisogno della tua approvazione, il prompt è dentro quel thread e il thread aspetta finché non rispondi lì. Dire a Claude nella conversazione del project di procedere non lo raggiunge. Ogni approvazione copre quel prompt, o il resto di quel thread se scegli l'opzione più ampia. Per lasciare che ogni thread esegua determinati comandi senza chiedere, o per bloccarne alcuni, aggiungi [regole di permesso](/docs/it/permissions) al `.claude/settings.json` del repository. I thread le applicano solo in un project con un repository; vedi [Cosa i thread raccolgono dai tuoi repository](#what-threads-pick-up-from-your-repositories).

Dai a un project un contesto permanente

La project memory, le istruzioni del project e i repository, i file e l'ambiente del project portano il contesto attraverso i thread. Imposti ognuno una volta e si applica a ogni nuovo thread. | Contesto | Cosa porta | Come lo imposti | | :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Project memory | Note che Claude tiene sul project, come requisiti, decisioni e ostacoli, memorizzate come file. Ogni thread legge il file di indice `MEMORY.md` quando inizia e apre gli altri file quando ne ha bisogno | Chiedi a Claude nella conversazione del project o in qualsiasi thread di ricordare un requisito, una decisione o un ostacolo, o di dimenticarne uno. Leggi, modifica ed elimina i file in **Project settings > Memory** | | Project instructions | Testo inviato a ogni nuovo thread e a Claude nella conversazione del project, fino a 16.000 caratteri. [Scrivi le istruzioni del project](#write-project-instructions) copre cosa metterci | **Project settings > Memory > Project instructions**, o chiedi a Claude di cambiare le istruzioni | | Repository, file e ambiente | I repository che ogni thread clona, le cartelle e i file che ogni thread può leggere sotto `/mnt/project-files`, e il cloud environment in cui i thread vengono eseguiti | Repository e ambiente in **Project settings > Environment**, o chiedi a Claude nella conversazione di aggiungere un repository al project. File e cartelle da **Add** sulla scheda **Library** in **Overview** | **Project settings > Memory** elenca questi file sotto **Auto memory**, perché Claude li scrive da solo mentre lavora nel project. Sono separati dalla [auto memory](/docs/it/memory) che Claude Code tiene sulla tua macchina, anche se entrambi usano un indice `MEMORY.md`. La project memory è anche separata dai file `CLAUDE.md` nei repository del project. Ogni thread legge ancora quei file `CLAUDE.md` dal suo clone quando inizia, quindi metti le istruzioni su un repository nel suo `CLAUDE.md` e le note sul project nella project memory.

Scrivi le istruzioni del project

Le istruzioni del project sono il briefing da cui ogni nuovo thread inizia. Fai clic sull'icona dell'ingranaggio nell'intestazione del project per aprire **Project settings**, quindi vai a **Memory > Project instructions**. Un briefing utile copre: * A cosa serve il project * Dove accade il lavoro: quali repository, quale branch da cui iniziare, come denominare le pull request * Come un thread controlla il suo lavoro prima di chiamarlo fatto * Cosa fare quando qualcosa di cui ha bisogno manca * Cosa ha bisogno della tua approvazione prima Ad esempio: ```text theme={null} Questo project mantiene la latenza p95 per l'API dei pagamenti sotto 200 ms: profiling, correzioni di query e caching, e gli aggiornamenti delle dipendenze che vengono con loro, nel repository payments-api. - Crea un branch da main e apri una pull request in bozza per thread. - Prima di chiamare il lavoro fatto, esegui `make test` e `make lint` e incolla le righe di riepilogo nel tuo messaggio finale. - Se non puoi raggiungere qualcosa di cui hai bisogno, come un repository, un segreto, un'API o un connector, dì esattamente cosa manca nel tuo primo messaggio e fermati. Non sostituire, simulare o indovinare. - Non unire, force-push o cambiare la configurazione CI senza chiedermi nel thread. ``` Le regole su un repository, come i suoi comandi di build, appartengono al `CLAUDE.md` di quel repository, che ogni thread legge quando il repository fa parte del project. Una volta che il lavoro è in corso, quando correggi un thread, dì anche a Claude di ricordare la correzione: va in [project memory](#give-a-project-standing-context) e i thread successivi iniziano con essa.

Decidi quali repository aggiungere

I repository che aggiungi a un project vengono con tutto in loro, il loro codice, `CLAUDE.md` e skills, in ogni thread. I repository che non aggiungi sono ancora a portata di mano: un thread può aggiungerne uno a se stesso quando il suo compito ne ha bisogno. La maggior parte dei project usa entrambi: * **Aggiungilo al project**, nella finestra di dialogo **New project**, in **Project settings > Environment**, o chiedendo a Claude nella conversazione di aggiungerlo al project. Ogni thread da allora in poi lo clona e inizia con il suo `CLAUDE.md` e le skills caricate, indipendentemente dal fatto che il compito lo tocchi. Passare da un repository a più repository cambia anche cosa i thread prendono dal `.claude/settings.json` di ogni repository; vedi [Cosa i thread raccolgono dai tuoi repository](#what-threads-pick-up-from-your-repositories). * **Lascialo fuori e lascia che i thread lo aggiungano quando necessario.** Un thread il cui compito ha bisogno di un repository che il project non ha può aggiungerlo a se stesso, e una nota nel thread dice che è stato aggiunto solo a questo thread. Il clone accade a metà del compito, quindi il `CLAUDE.md` e le skills di quel repository non erano lì quando il thread è iniziato. Il thread successivo inizia senza di esso di nuovo. Un repository che un thread aggiunge ha bisogno degli stessi [prerequisiti](#check-the-prerequisites) di un repository del project: l'app Claude GitHub installata su di esso e accesso push dal tuo account GitHub. Un project non ha bisogno di un repository affatto. I suoi thread possono ancora ricercare, scrivere documenti e scrivere ed eseguire codice nella loro sandbox, e consegnano file alla scheda **Library**. Un thread lì può anche aggiungere un repository a se stesso quando un compito lo richiede. Una volta che il project ha repository, Claude può solo aggiungere repository da un proprietario GitHub che il project usa già, indipendentemente dal fatto che lo aggiunga al project o un thread lo aggiunga a se stesso. Per portare un repository da un proprietario diverso, aggiungilo al project da solo in **Project settings > Environment**. Per un project che copre molti repository, come una funzione con codice server, web, mobile e desktop, aggiungi uno o due repository che quasi ogni compito tocca e nomina gli altri nelle [istruzioni del project](#write-project-instructions) in modo che Claude sappia dove vive il resto del codice. I thread iniziano quindi piccoli e tirano gli altri repository solo per i compiti che ne hanno bisogno.

Cosa i thread raccolgono dai tuoi repository

Ogni thread clona ogni repository nel project e carica `CLAUDE.md`, skills e plugins da tutti loro. Le regole di permesso, gli hook e `env` vengono solo dal `.claude/settings.json` nella directory in cui il thread inizia: dentro il repository quando il project ne ha uno, e sopra i cloni quando ne ha più di uno, dove il file di nessun repository viene letto per loro. | In ogni repository | Un repository | Più repository | | :------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------ | | `CLAUDE.md` | Caricato quando il thread inizia | Caricato da ogni repository quando il thread inizia | | Skills, agenti e comandi sotto `.claude/` | Caricati | Caricati da ogni repository | | Plugin abilitati in `.claude/settings.json` | Caricati | Caricati da ogni repository. Se due repository non sono d'accordo su un plugin, impostalo in **Project settings > Plugins**, che ha la precedenza | | Regole di permesso, hook e `env` definiti in `.claude/settings.json` | Si applicano al thread, tranne le chiavi `env` che [nessuna sessione cloud onora](/docs/it/cloud-environments#what-carries-over-from-your-setup) | Non si applicano | In un project con più repository, ogni clone è allegato al thread come una [directory aggiuntiva](/docs/it/memory#load-from-additional-directories) con il caricamento di `CLAUDE.md` attivato, che è il motivo per cui il `CLAUDE.md` e le skills di ogni repository si caricano all'inizio anche se il thread inizia sopra di loro. In entrambi i casi, gli hook che un plugin abilitato fornisce ancora vengono eseguiti, poiché i plugin si caricano da ogni repository. In un project con più repository, metti le regole permanenti nelle istruzioni del project e dai ai thread le variabili di ambiente attraverso il [cloud environment](#choose-an-environment-for-threads).

Scegli un ambiente per i thread

Ogni nuovo thread inizia nel [cloud environment](/docs/it/cloud-environments) del project. L'ambiente imposta quali domini i thread possono raggiungere, quali variabili di ambiente hanno, quali credenziali API vengono aggiunte alle loro richieste e cosa lo script di configurazione installa prima che Claude inizi. I thread usano un ambiente predefinito ospitato da Anthropic finché non ne scegli uno in **Project settings > Environment**. Se i thread hanno bisogno di raggiungere un'API interna o un registro di pacchetti privato, o hanno bisogno di un token che la tua macchina normalmente tiene, cambia l'ambiente piuttosto che il project: vedi [Accesso di rete](/docs/it/cloud-environments#network-access), [Aggiungi credenziali API](/docs/it/cloud-environments#add-api-credentials) e [Script di configurazione](/docs/it/cloud-environments#setup-scripts).

Ottieni skills, plugins, connectors e strumenti nei thread

I thread sono sessioni cloud, quindi non hanno le skills, i server MCP, i plugins e gli strumenti installati solo sulla tua macchina. Per rendere ognuno di questi disponibile ai thread: * Skills, subagenti e comandi: committili a un repository che hai aggiunto al project, ad esempio una skill su `.claude/skills//SKILL.md`. Ogni thread clona ogni repository nel project e carica `.claude/skills/`, `.claude/agents/` e `.claude/commands/` da ognuno di loro, quindi una skill committata a un repository è disponibile in ogni nuovo thread. I thread caricano anche le skills che abiliti per il tuo account claude.ai. * Plugin: aggiungili in **Project settings > Plugins**; si caricano in ogni nuovo thread. I plugin che un repository dichiara nel suo `.claude/settings.json` si caricano anche; vedi [Cosa si trasporta dalla tua configurazione](/docs/it/cloud-environments#what-carries-over-from-your-setup). * Server MCP: i thread ottengono i loro strumenti MCP dai connectors sul tuo account claude.ai, che sono server MCP che connetti una volta su [claude.ai/customize/connectors](https://claude.ai/customize/connectors) o attraverso il link **Manage connectors** in **Project settings > Environment**. Ogni thread può usarli tutti senza configurazione per project. La conversazione del project stessa non ha connectors, quindi invia il lavoro che ne ha bisogno come compito per un thread. In un project con un repository, i thread caricano anche i server MCP dal [`.mcp.json`](/docs/it/cloud-environments#what-carries-over-from-your-setup) di quel repository. [Come i connectors raggiungono Claude Code](/docs/it/mcp#how-connectors-reach-claude-code) elenca le regole per le sessioni cloud e le impostazioni che disattivano i connectors. * Strumenti da riga di comando e pacchetti: installali nello [script di configurazione](/docs/it/cloud-environments#setup-scripts) dell'ambiente. Per vedere quali connectors ha un thread in esecuzione su claude.ai/code, apri il thread e seleziona **Connectors** dal menu **+** accanto alla sua casella di messaggio. Disattivare un connector lì lo rimuove da quel thread, e rimane disattivato per i thread avviati in seguito finché non lo riattivi. Un thread raccoglie un connector che aggiungi o riconnetti dopo il prossimo messaggio che gli invii.

Riferimento delle impostazioni del project

Cambi le impostazioni del project su claude.ai/code o nell'app desktop, non in `settings.json`. Apri **Project settings** da **Settings** nel menu della barra laterale del project o dall'icona dell'ingranaggio nell'intestazione del project. Le impostazioni vengono salvate mentre le modifichi; un campo di testo che stai modificando, come l'obiettivo o le istruzioni, mostra **Save changes** e **Discard** finché non lo lasci. Le modifiche alle istruzioni, ai repository, ai plugin e all'ambiente in **Project settings** raggiungono i nuovi thread, non i thread già in esecuzione. | Impostazione | Scheda | Cosa controlla | | :------------------------- | :---------- | :-------------------------------------------------------------------------------------------------------------------- | | Nome, icona e obiettivo | General | Il nome e l'icona del project nella barra laterale e il suo obiettivo di una riga | | Coordinator model e effort | General | Il modello e il [livello di sforzo](/docs/it/model-config#adjust-effort-level) per Claude nella conversazione del project | | Thread model e effort | General | Il modello e il livello di sforzo per i thread | | Project instructions | Memory | [Regole permanenti](#give-a-project-standing-context) che ogni nuovo thread riceve | | Project repositories | Environment | I repository che i nuovi thread clonano | | Cloud environment | Environment | Il [cloud environment](#choose-an-environment-for-threads) in cui i nuovi thread vengono eseguiti | | Connectors | Environment | Un link per gestire i connectors claude.ai che i thread ottengono | | Plugins | Plugins | I plugin che si caricano in ogni nuovo thread | | Usage | Usage | [Utilizzo di token](#usage-and-cost) per thread e per modello | | Memory | Memory | I file di [memory](#give-a-project-standing-context) del project | | Restart Claude | General | Riavvia la conversazione del project quando [Claude smette di rispondere lì](#claude-hasnt-responded) | | Pause, Archive, Delete | General | Ferma, nascondi o rimuovi il project; vedi [Pausa, archivia o elimina un project](#pause-archive-or-delete-a-project) |

Pausa, archivia o elimina un project

Tutti e tre i controlli sono in fondo a **Project settings > General**: * **Pause**: ferma tutto contemporaneamente. Ogni thread in esecuzione e la conversazione vengono interrotti, nessun nuovo thread inizia, le routine non vengono eseguite e il project non accetta messaggi finché non lo riprendi. Fai clic su **Resume** nello stesso posto o sul banner sopra la casella di messaggio del project; un thread in pausa continua quando gli invii un messaggio dopo. * **Archive**: nasconde il project dalla barra laterale e archivia i suoi thread, che ferma qualsiasi thread che era in esecuzione o guardava una pull request. Le routine nel project non vengono eseguite mentre è archiviato. Per riportare il project, aprilo dalla pagina Projects e fai clic su **Unarchive**. I suoi thread rimangono archiviati finché non li disarchivia individualmente dall'elenco delle sessioni. * **Delete**: rimuove permanentemente il project insieme ai suoi thread, alla sua memoria e ai suoi file, e disattiva le routine del project. Questo non può essere annullato. I branch e le pull request che i thread hanno spinto a GitHub non sono interessati.

Utilizzo e costo

L'utilizzo del project conta rispetto agli stessi [limiti di piano](/docs/it/errors#youve-hit-your-session-limit) delle tue altre sessioni Claude Code, e un project non può spendere oltre quei limiti da solo. Un thread che raggiunge il limite del tuo piano aspetta e continua da solo quando il limite si ripristina, quindi il lavoro che hai lasciato in esecuzione inizia a usare la tua prossima finestra di utilizzo senza un messaggio da te. [Un thread ha raggiunto il limite di utilizzo](#usage-limit-reached) copre quello che vedi, come fermarlo e l'unico caso che non aspetta. Il lavoro va oltre i limiti del tuo piano solo se hai attivato [crediti di utilizzo](/docs/it/costs#add-usage-credits-to-your-subscription) per il tuo account. Un thread non può attivarli per te.

Cosa attinge al tuo piano

Un project usa i tuoi limiti più velocemente di una singola sessione, e su un piano Pro in particolare dovresti aspettarti di raggiungere il tuo limite prima nei giorni in cui ne esegui uno. Queste sono le parti di un project che usano il tuo piano: * **Thread in esecuzione**: ognuno è una sessione completa, e più possono essere eseguiti contemporaneamente. Non c'è un numero fisso; Claude avvia quanti il lavoro richiede, e un limite che [chiedi](#tune-how-claude-runs-a-project) è una preferenza piuttosto che un limite. Il limite applicato è 200 nuovi thread al giorno nei tuoi project. * **La conversazione**: Claude usa token da solo leggendo quello che i thread riportano e decidendo cosa fare dopo. * **Thread che guardano una pull request**: un thread inattivo si sveglia e usa il tuo piano di nuovo quando CI fallisce o un commento di revisione arriva sulla sua pull request. Per fermare questo, chiedi nel thread di smettere di guardare la pull request. Un project senza thread in esecuzione, nessuna pull request guardato e nessun nuovo messaggio non usa il tuo piano mentre rimane inattivo, e nemmeno un project archiviato.

Vedi e riduci l'utilizzo di un project

Apri 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: * Un follow-up instradato a un thread che è stato inattivo più a lungo della [durata della cache](/docs/it/prompt-caching#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. * 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. * 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.

Come i project si relazionano ad altre funzioni Claude Code

Diverse 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, ognuno inizia dagli stessi repository, istruzioni e memoria, e il lavoro vive nel cloud finché dura. Ecco come ogni funzione vicina si connette a un project: * **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. * **Sessioni cloud**: ogni thread è una [sessione cloud](/docs/it/claude-code-on-the-web), avviata e tracciata da Claude invece che da te. Una sessione cloud che hai avviato da solo può diventare un project o alimentarne uno attraverso [**Continue as a project** o **Move to project**](#start-from-an-existing-cloud-session). * **Routine**: quando chiedi il lavoro programmato in un project, Claude crea una [routine](/docs/it/routines) che viene eseguita come thread in quel project e appare sulla sua scheda **Routines**. Le routine che crei al di fuori di un project continuano a funzionare da sole. * **Sessioni locali e agent view**: le sessioni nel tuo terminale, IDE o nell'ambiente locale dell'app desktop vengono eseguite sulla tua macchina e non possono far parte di un project. [Agent view](/docs/it/agent-view) è una schermata per tracciare più di quelle sessioni locali; non ha un coordinatore. * **Worktrees**: un [worktree](/docs/it/worktrees) dà a ogni sessione locale la sua copia di lavoro di un repository in modo che le sessioni parallele sulla tua macchina non si sovrascrivano a vicenda. I thread non ne hanno bisogno: ogni thread clona i suoi repository nella sua sandbox cloud e lavora sul suo branch. * **Agent teams**: un [agent team](/docs/it/agent-teams) è una sessione che avvia sessioni di compagno per un singolo compito, sulla tua macchina o dentro una sessione cloud, e finisce con quel compito. * **Projects in claude.ai chat e Cowork**: l'[esperienza Projects precedente](https://support.claude.com/en/articles/9517075-what-are-projects), che raggruppa conversazioni e file di riferimento senza thread o un coordinatore. Questi project continuano a funzionare come fanno oggi fino a quando l'esperienza riprogettata li raggiunge. [Esegui agenti in parallelo](/docs/it/agents) confronta queste opzioni fianco a fianco.

Limitazioni

* I project sono disponibili su claude.ai/code e nell'app desktop, non nel CLI del terminale o attraverso Amazon Bedrock, Google Cloud's Agent Platform o Microsoft Foundry. Il comando [`claude project`](/docs/it/cli-reference) del CLI, che gestisce lo stato locale di Claude Code per una directory, non è correlato. * I thread del project sono [sessioni cloud](/docs/it/claude-code-on-the-web) con Anthropic come fornitore di modello. [Sicurezza](/docs/it/security) e [Utilizzo dei dati](/docs/it/data-usage) coprono come le sessioni cloud sono isolate e cosa viene conservato. * Una sessione locale non può far parte di un project. * La sandbox di un thread si mette in pausa tra i turni e riprende quando il thread continua. Se la sandbox non può essere ripresa, il thread continua da un clone fresco, quindi i cambiamenti non committati possono essere persi. Su compiti lunghi, chiedi a Claude di committare e spingere il lavoro in corso. * Un project appartiene a un utente. Non puoi condividere un project o i suoi thread con un altro utente, e le trascrizioni dei thread non hanno l'opzione di condivisione che hanno altre sessioni cloud. Non ci sono controlli a livello di organizzazione per i project durante la beta. * Un thread appartiene all'unico project che l'ha avviato. Non puoi spostare o copiare un thread in un altro project, o spostarlo fuori per stare da solo. [**Move to project**](#start-from-an-existing-cloud-session) va solo nell'altro modo: porta il lavoro di una sessione cloud in un project.

Risoluzione dei problemi

Per i prompt di configurazione di GitHub nella finestra di dialogo **New project**, vedi [Configura l'accesso a GitHub](#set-up-github-access).

Un thread sembra bloccato

Claude non pubblica ogni passo che un thread compie, quindi un thread che mostra come in esecuzione senza nuovi messaggi nella conversazione del project di solito sta ancora funzionando. Un nuovo thread provisiona anche il suo [cloud environment](/docs/it/cloud-environments) prima che Claude inizi, quindi il suo primo aggiornamento richiede un momento. Apri il thread per leggere la sua trascrizione. Se il thread sta aspettando un prompt di permesso, rispondi lì.

I thread hanno indovinato o si sono bloccati invece di chiedere

Quando più thread tornano avendo assunto qualcosa di sbagliato, hanno aggirato l'accesso mancante o si sono fermati con "bloccato", la causa di solito è lo stesso gap nella configurazione del project piuttosto che un problema con ogni compito. Ordina quali thread sono solidi prima di correggere qualsiasi cosa: 1. Chiedi a Claude nella conversazione: "Per ogni thread aperto, elenca quello che gli hai chiesto di fare, cosa ha assunto o non poteva raggiungere e cosa sta aspettando." Claude legge ogni thread e risponde nella conversazione. 2. Per i thread che hanno iniziato da un'assunzione sbagliata, apri il thread da **Overview** e contrassegnalo come risolto dal suo menu, o digli cosa fare invece nella sua casella di messaggio. Il suo branch e qualsiasi pull request rimangono su GitHub finché non li elimini. 3. Correggi il gap una volta, nelle [istruzioni del project](#give-a-project-standing-context) o nell'[ambiente](#choose-an-environment-for-threads), quindi invia un thread prima di inviare il resto del lavoro di nuovo come nuovi thread.

Claude non ha risposto

La conversazione del project mostra un banner "Claude hasn't responded" quando Claude è in esecuzione ma le sue risposte non raggiungono il project. Fai clic su **Restart Claude** sul banner, o vai a **Project settings > General** e fai clic su **Restart** nella riga **Restart Claude**. Claude si riconnette alla conversazione; qualsiasi risposta che stava scrivendo viene persa, e i thread non sono interessati.

Errori di accesso al repository

Tre messaggi significano che un thread o il project non può raggiungere uno dei suoi repository. Un thread del project ha bisogno dei [prerequisiti di GitHub](#check-the-prerequisites) anche quando le tue altre sessioni cloud clonano lo stesso repository senza problemi. * **"Couldn't start the session — Claude doesn't have GitHub access to this project's repository"**, segnalato prima che il thread inizi, quando l'app Claude GitHub non è installata su quel repository, è sospesa o non è collegata all'account GitHub che hai connesso. * **"Unable to access your repository"**, segnalato da un thread quando il suo clone fallisce: GitHub ha rifiutato il clone, il repository non è stato trovato sotto il nome che il project ha, o il branch da cui al thread è stato chiesto di iniziare non esiste. * **"Claude can't access"** un repository, mostrato quando salvi i repository nella finestra di dialogo **New project** o **Project settings**. Il messaggio continua con un link di installazione e un link di riconnessione. Usa il link di installazione se l'app Claude GitHub non è su quel repository, e il link di riconnessione se lo è, poiché l'app GitHub può essere installata su GitHub senza essere collegata all'account che hai connesso a Claude. Se il messaggio dice che l'app GitHub è sospesa o non include questo repository, segui il suo link a GitHub per correggere. Per correggere uno qualsiasi di essi, fai clic sul pulsante che il messaggio offre, come **Install GitHub App** o **Select repositories on GitHub**, quindi **Check again**. Quando il blocco è dal lato dell'organizzazione GitHub, come un proprietario che non ha approvato l'app o un elenco di indirizzi IP che esclude Claude, il messaggio mostra un link **See how to fix** invece. Se non c'è un pulsante, segui [Configura l'accesso a GitHub](#set-up-github-access), quindi invia un altro messaggio per riprovare.

Un thread ha raggiunto il limite di utilizzo

Quando un thread o la conversazione del project raggiunge il limite di cinque ore o settimanale del tuo piano, continua a riprovare da solo e continua quando il limite si ripristina. Mentre aspetta, il thread mostra **Service is busy** con "Claude is still retrying and will continue automatically." Non devi fare nulla perché il lavoro continui. Se preferisci che non usi la tua prossima finestra di utilizzo, fai clic su **Stop** nel thread, o [metti in pausa il project](#pause-archive-or-delete-a-project) per tenere ogni thread. Un thread che una routine ha avviato non aspetta: il suo turno si ferma con un errore di limite, e gli invii un messaggio dopo che il limite si ripristina. [Errori di limite di utilizzo](/docs/it/errors#youve-hit-your-session-limit) spiegano i limiti e quando si ripristinano.

Sono richiesti crediti di utilizzo aggiuntivi

Un thread o la conversazione del project ha fatto una richiesta che il tuo piano copre solo con crediti di utilizzo, come una a un modello o una dimensione di contesto che il tuo piano non include, e i crediti di utilizzo non sono attivati per il tuo account. [Aggiungi crediti di utilizzo al tuo abbonamento](/docs/it/costs#add-usage-credits-to-your-subscription) copre chi può attivarli o comprarli su ogni piano. Una volta che i crediti sono disponibili, invia un altro messaggio per riprovare.

Altri messaggi

Questi messaggi nominano la loro stessa causa. La tabella fornisce il prossimo passo per ognuno. | Messaggio | Cosa fare | | :-------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | "Unable to connect to repository" con "Claude couldn't reach GitHub to fetch your repository" | Aspetta un momento, quindi invia un altro messaggio per riprovare | | "Unable to connect to repository" con "Claude couldn't access your repository or environment" | Il tuo account GitHub ha bisogno di accesso push al repository, e l'ambiente deve ancora esistere. Controlla entrambi in **Project settings > Environment**, quindi riprova | | "Couldn't show the setup proposal" | L'app che hai aperto è più vecchia delle **Setup recommendations** che Claude ha inviato. Aggiorna la pagina o riavvia l'app desktop, o chiedi a Claude di proporre di nuovo la configurazione | | "The project's environment was removed" | Scegli un ambiente diverso in **Project settings > Environment**; il cambiamento si applica ai nuovi thread | | "Setup script failed" | Fai clic su **Edit setup script** sull'errore, correggi lo script nell'ambiente, quindi invia un altro messaggio. [Setup script failed](/docs/it/web-quickstart#setup-script-failed) elenca le cause comuni | | "Claude ran out of context on this turn" | Il thread ha riempito la sua finestra di contesto. Se il messaggio dice che il thread continua in una sessione fresca, continua da solo; altrimenti chiedi a Claude nella conversazione del project di avviare un nuovo thread per il lavoro rimanente | | "Reached the turn limit" | Il thread ha raggiunto il limite sui passaggi per un messaggio. Invia un altro messaggio con una richiesta più piccola o più specifica, o chiedi a Claude di dividere il compito tra i thread | * [Usa Claude Code nel cloud](/docs/it/claude-code-on-the-web): come funzionano le sessioni cloud dietro ogni thread, incluse le opzioni di accesso a GitHub e auto-fix sulle pull request * [Configura cloud environment](/docs/it/cloud-environments): cambia cosa i thread possono raggiungere sulla rete, dai loro variabili di ambiente e credenziali API, e installa strumenti con uno script di configurazione * [Automatizza il lavoro con le routine](/docs/it/routines): programmi, trigger e gestione per le routine, incluse quelle che Claude crea da un project * [Gestisci più agenti con agent view](/docs/it/agent-view): esegui e traccia più sessioni sulla tua macchina quando il lavoro ha bisogno di strumenti o servizi che solo la tua macchina può raggiungere * [Projects redesigned: from folder to conversation](https://claude.com/blog/projects-redesigned): l'annuncio di lancio, con il ragionamento dietro la trasformazione di un project in una conversazione con Claude