> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt
> Use this file to discover all available pages before exploring further.

# La tua prima sessione

> Inizia la tua prima sessione e scopri cosa può fare Devin

export const PromptBlock = ({children, type, agent, intent, playbookId}) => {
  var utm = 'utm_source=docs&utm_medium=use-case-gallery&utm_campaign=prompt-block';
  var tag = 'docs-use-case-gallery';
  var agentParams = (agent ? '&agent=' + agent : '') + (intent ? '&intent=' + intent : '') + (playbookId ? '&playbookId=' + playbookId : '');
  var label = type === 'schedule' ? 'Schedule in Devin' : type === 'playbook' ? 'Create Playbook' : type === 'knowledge' ? 'Add to Knowledge' : agent === 'advanced' ? 'Try in Devin' : agent === 'dana' ? 'Try in Dana' : agent === 'ada' ? 'Try in Ask Devin' : 'Try in Devin';
  var buildUrl = function (text) {
    var encoded = encodeURIComponent(text);
    if (type === 'schedule') return 'https://app.devin.ai/settings/schedules/create?' + utm + agentParams + '&prompt=' + encoded;
    if (type === 'playbook') return 'https://app.devin.ai/settings/playbooks/create?' + utm + '&body=' + encoded;
    if (type === 'knowledge') return 'https://app.devin.ai/knowledge?' + utm + '&body=' + encoded;
    if (agent === 'ada') return 'https://app.devin.ai/search?' + utm + '&noSubmit=true&prompt=' + encoded;
    return 'https://app.devin.ai/?tags=' + tag + '&' + utm + agentParams + '&prompt=' + encoded;
  };
  const ref = React.useRef(null);
  const [href, setHref] = React.useState('#');
  React.useEffect(() => {
    if (!ref.current) return;
    var codeEl = ref.current.querySelector('pre code');
    if (codeEl) {
      var text = codeEl.textContent.trim();
      if (text) setHref(buildUrl(text));
    }
    var header = ref.current.querySelector('[data-component-part="code-block-header"]');
    if (header && !header.querySelector('.prompt-block-devin-link')) {
      var link = document.createElement('a');
      link.href = href;
      link.target = '_blank';
      link.rel = 'noopener noreferrer';
      link.className = 'prompt-block-devin-link';
      link.style.cssText = 'display:inline-flex;align-items:center;gap:6px;text-decoration:none;color:#fff;font-size:11px;font-weight:500;padding:4px 10px;border-radius:6px;white-space:nowrap;background:#317CFF;transition:background 0.2s;margin-left:8px;';
      link.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/><polyline points="15 3 21 3 21 9"/><line x1="10" y1="14" x2="21" y2="3"/></svg> ' + label;
      link.onmouseenter = function () {
        link.style.background = '#2968D9';
      };
      link.onmouseleave = function () {
        link.style.background = '#317CFF';
      };
      header.appendChild(link);
    }
    var existingLink = ref.current.querySelector('.prompt-block-devin-link');
    if (existingLink && href !== '#') existingLink.href = href;
  });
  return <div className="prompt-block" ref={ref}>{children}</div>;
};

<Note>
  Prima di iniziare la tua prima sessione, assicurati di aver [indicizzato](/it/onboard-devin/index-repo) e [configurato](/it/onboard-devin/environment) i tuoi repository. Questi passaggi fondamentali aiutano
  Devin a comprendere e a lavorare sulla tua codebase.
</Note>

Ora che hai completato la configurazione, avvia la tua prima sessione con Devin! Questa guida ti guiderà nella nuova interfaccia della sessione e ti aiuterà a capire come interagire al meglio con Devin.

<Tip>
  Preferisci lavorare dal terminale? [Devin CLI](/it/cli) ti consente di avviare sessioni direttamente dalla riga di comando. Installalo in 2 minuti con `curl -fsSL https://cli.devin.ai/install.sh | bash`.
</Tip>

<div id="understanding-the-devin-session-page">
  ## Informazioni sulla pagina della sessione di Devin
</div>

Quando avvii una nuova sessione, ti vengono presentate due modalità principali: **Ask** e **Agent**.

<Note>
  A meno che tu non abbia già un piano ben definito, consigliamo di iniziare con Ask per collaborare con Devin alla definizione di un piano, quindi passare alla modalità Agent per eseguirlo.
</Note>

<div id="ask-mode">
  ### Modalità Ask
</div>

**Ask Devin** è una modalità leggera per esplorare la tua codebase e pianificare attività con Devin, senza modificare effettivamente il codice. Ora con Ask Devin puoi sia porre domande sia pianificare:

* **Fare domande** su come funziona il tuo codice. Utilizza una ricerca avanzata nel codice per produrre risposte dettagliate, accurate e ben supportate da riferimenti.
* **Pianificare attività** definendo l'ambito del lavoro prima dell'implementazione. Devin genera prompt ricchi di contesto per le sessioni di Agent.

Quando avvii una sessione di Devin da Ask Devin, lo stato della sessione è visibile direttamente nella conversazione.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/F5oUw1qMUFyqdYvx/images/get-started/ada-main-page.png?fit=max&auto=format&n=F5oUw1qMUFyqdYvx&q=85&s=4322113b3a37d34381ed9ce3643ce361" alt="Ask Mode" width="2758" height="1448" data-path="images/get-started/ada-main-page.png" />
</Frame>

<div id="triggering-ask-mode">
  #### Attivare Ask mode
</div>

Puoi attivare Ask mode dalla pagina principale o da una pagina DeepWiki.

Per usare Ask mode dalla pagina principale, passa ad Ask mode e seleziona il/i repository su cui vuoi porre domande.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/F5oUw1qMUFyqdYvx/images/get-started/ada-session-page-entry.png?fit=max&auto=format&n=F5oUw1qMUFyqdYvx&q=85&s=419e52527134041c36d32968bd89cc70" alt="Ask Mode from Main Page" width="2758" height="1448" data-path="images/get-started/ada-session-page-entry.png" />
</Frame>

Per usare Ask mode da una pagina DeepWiki, digita una query nel campo di input della chat in fondo alla pagina e fai clic su Ask. Questo contestualizzerà automaticamente le conoscenze di Devin a quello specifico repository.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/F5oUw1qMUFyqdYvx/images/get-started/ada-deepwiki-entry.png?fit=max&auto=format&n=F5oUw1qMUFyqdYvx&q=85&s=8c6b34541551d6f6d879d75c1ae3b719" alt="Ask Mode from DeepWiki" width="2878" height="1471" data-path="images/get-started/ada-deepwiki-entry.png" />
</Frame>

Scopri di più nella nostra [guida Ask Devin](/it/work-with-devin/ask-devin).

Dopo aver lavorato con Devin per capire il problema e creare un piano, sei pronto per passare ad Agent mode.

<div id="agent-mode">
  ### Modalità Agent
</div>

La modalità Agent è la modalità completamente autonoma di Devin, in cui può scrivere codice, eseguire comandi, navigare sul web e completare attività complesse end-to-end. Usa la modalità Agent quando sei pronto a:

* Implementare funzionalità o correggere bug
* Aprire pull request
* Eseguire test e fare debug dei problemi
* Svolgere attività in più passaggi che richiedono modifiche al codice

<div id="triggering-agent-mode">
  #### Attivare la modalità Agent
</div>

Puoi attivare la modalità Agent dalla pagina principale o da una sessione Ask Devin. Quando una sessione viene avviata da Ask Devin, il relativo stato viene mostrato nella conversazione Ask Devin, così puoi monitorarne l'avanzamento.

Per attività che non sono completamente definite, ti consigliamo di:

* Iniziare con la **modalità Ask** per pianificare l'attività
* **Creare un Devin Prompt**, che utilizzerà la tua sessione Ask per creare un piano con ambito ben definito
* Fare clic su **Send to Devin** per passare alla modalità Agent ed eseguire l'attività

Questo flusso è illustrato di seguito:

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/o-vVqnQzugDuTQBr/images/get-started/ada-to-agent.gif?s=7b6553fa3595bf3d6382c6657e3e5adb" alt="Da Ask Mode ad Agent Mode" width="800" height="541" data-path="images/get-started/ada-to-agent.gif" />
</Frame>

Per avviare la modalità Agent dalla pagina principale, passa alla modalità Agent e seleziona uno o più repository con cui vuoi lavorare.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/F5oUw1qMUFyqdYvx/images/get-started/agent-mode.png?fit=max&auto=format&n=F5oUw1qMUFyqdYvx&q=85&s=730174eadb0bbd98f231b9ace8ce7a8d" alt="Modalità Agent" width="2660" height="1431" data-path="images/get-started/agent-mode.png" />
</Frame>

Quando avvii una sessione Agent, dovrai configurare alcune opzioni: la selezione di un Repository e la selezione di un Agent.

<div id="selecting-a-repository">
  #### Selezionare un repository
</div>

Seleziona il repository con cui vuoi che Devin lavori. Fai clic sul selettore del repository per vedere tutti i repository che sono stati [aggiunti alla macchina di Devin](/it/onboard-devin/environment).

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/F5oUw1qMUFyqdYvx/images/get-started/repo-selector.png?fit=max&auto=format&n=F5oUw1qMUFyqdYvx&q=85&s=3b61fbcd38b6aaf1c82984afeb481afa" alt="Repository Selector" width="2004" height="1094" data-path="images/get-started/repo-selector.png" />
</Frame>

Selezionare un repository garantisce che Devin:

* abbia accesso alla tua codebase e possa apportare modifiche
* utilizzi il branch corretto come punto di partenza
* possa creare pull request sul repository corretto

<div id="selecting-an-agent">
  #### Selezionare un Agent
</div>

Puoi scegliere quale configurazione di agent Devin utilizza per la tua sessione. Agent diversi possono avere funzionalità diverse o essere ottimizzati per tipi specifici di attività.

Gli agent disponibili includono:

* **Devin** (predefinito) — Un software engineer AI per uso generale per sviluppare funzionalità, correggere bug, fare refactoring del codice e gestire la maggior parte delle attività di sviluppo.
* **Fast Mode** — Una modalità ottimizzata per attività rapide e con un ambito ben definito.
* **[Dana](/it/work-with-devin/data-analyst)** — Un agent data analyst ottimizzato per interrogare database, analizzare dati e creare visualizzazioni.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/F5oUw1qMUFyqdYvx/images/get-started/agent-selector.png?fit=max&auto=format&n=F5oUw1qMUFyqdYvx&q=85&s=f2b6da8aa45e29b237e8ef0ea0cfbef8" alt="Agent Selector" width="2046" height="908" data-path="images/get-started/agent-selector.png" />
</Frame>

<Tip>
  Se non sei sicuro di quale agent utilizzare, l'agent Devin predefinito è adatto alla maggior parte delle attività.
</Tip>

<div id="using-mentions">
  ## Uso delle menzioni @
</div>

Usa le menzioni `@` per fornire a Devin un contesto specifico su file, repository o altre risorse. Quando digiti `@` nel campo di input della chat, vedrai un menu a discesa con le menzioni disponibili:

* **@Repos** - Fai riferimento a un repository specifico
* **@Files** - Fai riferimento a un file specifico nella tua codebase
* **[@Macros](/it/product-guides/knowledge)** - Fai riferimento a una macro per una voce di Knowledge
* **[@Playbooks](/it/product-guides/creating-playbooks)** - Fai riferimento a un playbook del team o della community, ovvero template di prompt dettagliati che possono essere utilizzati per guidare il comportamento di Devin
* **[@Skills](/it/product-guides/skills)** - Fai riferimento a una skill definita nel tuo repository (procedure riutilizzabili salvate come file `SKILL.md`)
* **[@Secrets](/it/product-guides/secrets)** - Fai riferimento a uno specifico secret (ad es. API key, credenziali, ecc.) nel gestore di sessioni di Devin
* **@Sessions** - Fai riferimento a una sessione precedente di Devin come contesto

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/F5oUw1qMUFyqdYvx/images/get-started/at-mention.png?fit=max&auto=format&n=F5oUw1qMUFyqdYvx&q=85&s=dbcade626b2b560f9dbf90589b27a6b8" alt="At Mentions" width="1860" height="1104" data-path="images/get-started/at-mention.png" />
</Frame>

Le menzioni @ aiutano Devin a comprendere esattamente su cosa stai lavorando e a ridurre l'ambiguità nei tuoi prompt.

<div id="scoping-your-first-session">
  ## Definire l’ambito della tua prima sessione
</div>

Inizia con attività che abbiano **criteri di successo chiari** e **forniscano a Devin il contesto di cui ha bisogno** — proprio come faresti quando affidi un lavoro a un collega. Man mano che prendi confidenza, prova attività progressivamente più complesse. Abbiamo visto utenti lavorare con Devin su tutto, dalla correzione di piccoli bug a refactoring mirati, fino a migrazioni su larga scala e alla creazione di intere funzionalità da zero.

<Tip>
  Come regola generale: se un’attività ti richiederebbe tre ore o meno, molto probabilmente Devin può occuparsene. Per progetti più grandi, suddividili in sessioni mirate ed eseguili in parallelo con i [managed Devins](/it/work-with-devin/advanced-capabilities#managed-devins).
</Tip>

<div id="first-time-prompt-ideas">
  ## Idee di prompt per iniziare
</div>

<AccordionGroup>
  <Accordion title="Aggiunta di un nuovo endpoint API" icon="code-pull-request">
    <PromptBlock>
      ```Adding a new API endpoint theme={null}
      Crea un nuovo endpoint /users/stats che restituisca un oggetto JSON con il numero di utenti e l'età media al momento dell'iscrizione. 

      Usa la nostra tabella users già esistente in PostgreSQL. 

      Puoi fare riferimento all'endpoint /orders/stats in statsController.js per vedere come strutturiamo le risposte. 

      Assicurati che il nuovo endpoint sia coperto dai test nella suite StatsController.test.js.
      ```
    </PromptBlock>
  </Accordion>

  <Accordion title="Piccole funzionalità del frontend" icon="sun">
    <PromptBlock>
      ```Small frontend features theme={null}
      In UserProfileComponent, aggiungi un menu a discesa che mostri l'elenco dei ruoli utente (admin, editor, viewer). 

      Usa lo stile di DropdownBase. 

      Quando viene selezionato un ruolo, chiama l'API esistente per impostare il ruolo utente. 

      Verifica che la selezione aggiorni il ruolo utente nel DB. Fai riferimento alla tua Knowledge per eseguire i test correttamente.
      ```
    </PromptBlock>
  </Accordion>

  <Accordion title="Scrivere test unitari" icon="flask">
    <PromptBlock>
      ```Write unit tests theme={null}
      Aggiungi test Jest per i metodi di AuthService: login e logout. 

      Assicurati che la copertura dei test per queste due funzioni sia almeno dell'80%. 

      Usa UserService.test.js come esempio.

      Dopo l'implementazione, esegui `npm test -- --coverage` e verifica che il report di copertura mostri >80% per entrambe le funzioni. 

      Conferma inoltre che i test vengano superati sia con credenziali valide che non valide e che il logout svuoti correttamente i dati di sessione.
      ```
    </PromptBlock>
  </Accordion>

  <Accordion title="Migrazione o refactoring del codice esistente" icon="code-pull-request">
    <PromptBlock>
      ```Migrating or refactoring existing code theme={null}
      Esegui la migrazione di logger.js da JavaScript a TypeScript. 

      Disponiamo già di un tsconfig.json e di una suite di test LoggerTest.test.js per la validazione. 

      Assicurati che compili senza errori e non modificare la configurazione esistente!

      Dopo la migrazione, verifica quanto segue: 
      1) esegui `tsc` per confermare che non ci siano errori di tipo
      2) esegui la suite di test con `npm test LoggerTest.test.js` per assicurarti che tutti i test vengano superati
      3) verifica che tutte le chiamate esistenti ai metodi del logger in tutto il codebase continuino a funzionare senza errori di tipo.
      ```
    </PromptBlock>
  </Accordion>

  <Accordion title="Aggiornamento delle API o delle query al database" icon="database">
    <PromptBlock>
      ```Updating APIs or database queries theme={null}
      Stiamo effettuando la migrazione da pg a Sequelize (vedi https://sequelize.org/api/v6/identifiers). 

      Aggiorna le query di UserModel per usare i metodi di Sequelize. 

      Fai riferimento a OrderModel per vedere come lo gestiamo in questo codebase.

      Dopo l'implementazione, verifica:
      1) eseguendo `npm run test:integration UserModel.test.js` per verificare che tutti i test di integrazione vengano superati
      2) confermando che le prestazioni delle query non siano peggiorate, controllando il tempo di esecuzione su un dataset di test di 1000 utenti
      3) verificando che tutte le operazioni CRUD mantengano ancora l'integrità dei dati, eseguendo `npm run test:e2e user-flows.test.js`
      ```
    </PromptBlock>
  </Accordion>

  <Accordion title="Crea una PR rapida (consigliamo di utilizzare questo prompt in un Playbook)" icon="code-pull-request">
    <PromptBlock>
      ```txt Quick PR theme={null}
      ## Panoramica
      Il compito è creare una pull request rapida in un repository.
      Poiché questa è una PR "rapida", non avrai bisogno di eseguire alcun codice o testare nulla; limitati a creare una PR e l'utente si occuperà dei test. La tua unica responsabilità è leggere e scrivere codice.

      ## Cosa è necessario dall'utente
      - Il repository su cui creare la pull request

      ## Procedura
      ### Prepara il tuo ambiente di lavoro
      1. Vai al repository rilevante sulla tua macchina (chiarisci con l'utente se non riesci a capirlo).
          - Fai il checkout del branch principale e annota il nome del branch principale.
          - Fai il checkout di un nuovo branch dato che creerai una pull request. Il nome del branch deve avere il formato `devin/<timestamp>-<your-branch-name>`. Ad esempio `devin/1700000000-fix-popup`. Esegui `git remote -v && git pull && git checkout -b devin/$(date +%s)-{branch-name}` e sostituisci `{branch-name}` con il nome del branch che vuoi creare.
      2. Studia la richiesta, il codebase e pianifica le modifiche
          - Esamina i file e le sezioni di codice più rilevanti, identificando gli snippet pertinenti.
          - Informa l'utente del tuo piano
      ### Lavora sulla PR
      3. Apporta le modifiche al codice
          - Non cambiare nulla che non sia stato specificamente richiesto dall'utente
      4. Crea la PR
          - Effettua il commit e il push delle modifiche e avvisa l'utente.
          - Consulta la sezione dei consigli per il comando esatto con cui creare la PR
          - Crea una pull request e rivedi la PR per assicurarti che sia tutto a posto.
          - Assicurati che tutte le GitHub Actions vadano a buon fine e apporta le modifiche necessarie finché non succede
          - Invia all'utente il link della PR e riassumi ciò che hai cambiato.
      5. Gestisci qualsiasi feedback dalla review; invia di nuovo il link della PR ogni volta che apporti modifiche
          - Se hai bisogno di fare aggiornamenti, esegui semplicemente il push di altri commit sullo stesso branch; non crearne uno nuovo


      ## Specifiche del task
      - Il link della PR è incluso nei tuoi messaggi all'utente
      - La PR è stata rivista dopo la creazione
      - La PR non include modifiche spurie
      - La PR non cambia nulla che non sia stato specificamente richiesto dall'utente
      - La descrizione della PR deve includere un riepilogo delle modifiche, formattato come checklist
      - La descrizione della PR deve menzionare che il codice è stato scritto senza essere testato e includere - [ ] Test the changes come elemento
      - La descrizione della PR deve includere il seguente footer: "Questa PR è stata scritta da [Devin](https://devin.ai/) :angel:"
      - La descrizione della PR deve includere tutti i metadati forniti dall'utente (ad es. tag dei ticket Linear nella sintassi appropriata)
      - La descrizione della PR non deve essere malformattata (usa --body-file invece di --body se le nuove righe risultano illeggibili!)

      ## Azioni vietate
      - NON provare ad accedere a github.com tramite il browser, non sarai autenticato.
      - NON fare mai force push sui branch! Preferisci il merge al rebase così da non perdere alcun lavoro.
      - NON eseguire push direttamente sul branch principale.

      ## Consigli e suggerimenti
      - Controlla due volte il nome del branch principale (che potrebbe essere `main` o `master`) usando `git branch`.
      - Per i repository con CI/CD su GitHub Actions, puoi controllare i log di build usando la gh cli. Se ti viene chiesto di sistemare una build o di correggere errori di linting, dovresti iniziare guardando i log delle build recenti.
      - Controlla `git status` prima di effettuare commit o aggiungere file.
      - Usa `git diff` per vedere quali modifiche hai fatto prima di effettuare il commit.
      - Se stai aggiornando un repository esistente, usa `gh cli` per creare pull request.
      - Invia all'utente il link della PR ogni volta che effettui un aggiornamento e chiedi di rivederla di nuovo, in modo che sia comodo per loro.
      - Dovresti essere già autorizzato ad accedere a qualsiasi repository che l'utente ti segnala. In caso contrario, chiedi all'utente l'accesso.
      ```
    </PromptBlock>
  </Accordion>
</AccordionGroup>

Se vuoi approfondire alcuni esempi più dettagliati di ciò che Devin può fare (e come), consulta i nostri **casi d'uso**.

<CardGroup cols={1}>
  <Card title="Esplora i casi d'uso" icon="grid-2" href="/it/use-cases/gallery/index">
    Esplora esempi pratici nei flussi di lavoro di ingegneria — ognuno include prompt che puoi provare subito.
  </Card>
</CardGroup>

<div id="after-your-session">
  ## Dopo la sessione
</div>

Quando Devin ha finito, apri [Session Insights](/it/product-guides/session-insights) e fai clic su **Genera analisi** — troverai una cronologia di ciò che è successo, feedback pratico e un prompt migliorato che puoi riutilizzare per attività simili in futuro.

<div id="next-steps">
  ## Prossimi passaggi
</div>

Quando hai preso dimestichezza con le sessioni di base, esplora queste risorse per ottenere ancora di più da Devin:

<CardGroup cols={2}>
  <Card title="Integrazioni" icon="plug" href="/it/integrations/overview">
    Collega Devin ai tuoi strumenti esistenti come GitHub, Slack, Jira e altri.
  </Card>

  <Card title="Playbooks" icon="book" href="/it/product-guides/creating-playbooks">
    Scopri come utilizzare i Playbook per eseguire attività.
  </Card>

  <Card title="Knowledge" icon="lightbulb" href="/it/product-guides/knowledge">
    Aggiungi Knowledge per aiutare Devin a comprendere le pratiche del tuo team.
  </Card>
</CardGroup>