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

# Pratiche consigliate

> Come strutturare il lavoro con Devin per massimizzare efficienza e ROI

Identificare il caso d'uso giusto per Devin è fondamentale per massimizzare l'efficienza e il ritorno sull'investimento (ROI). Di seguito sono riportate le pratiche consigliate per selezionare un caso d'uso che sia in linea con i punti di forza di Devin.

<div id="best-enterprise-use-cases">
  ## Casi d’uso Enterprise ideali
</div>

| **Criteri ideali per i casi d’uso**                                                                                                       |
| :---------------------------------------------------------------------------------------------------------------------------------------- |
| Progetti di grandi dimensioni e ad elevato valore per il business che possono essere suddivisi in **sottoattività isolate e ripetitive**. |
| Attività che richiedono **meno di 90 minuti** di lavoro manuale di ingegneria.                                                            |
| **Attività retrocompatibili** che possono essere validate e unite in modo indipendente.                                                   |

<div id="devins-ideal-requirements">
  ## Requisiti ideali per Devin
</div>

| **Requisito**                                        |
| :--------------------------------------------------- |
| Alto volume di **sottoattività ripetitive** (slices) |
| Attività con complessità da **junior engineer**      |
| Attività **isolate e incrementali**                  |
| Sottoattività **oggettive e verificabili**           |
| **(Consigliato)** Dipendenze di progetto minime      |

Se la tua attività soddisfa la maggior parte o tutti questi requisiti, è una candidata ideale per Devin.

<div id="crafting-devins-work">
  ## Progettare il lavoro di Devin
</div>

La scelta del **tipo di task** giusto è fondamentale per massimizzare l'affidabilità di Devin.

| **Scenario**                                                                              | **Considerazione sull'affidabilità**  | **Tipo di task**   |
| ----------------------------------------------------------------------------------------- | ------------------------------------- | ------------------ |
| Chiedere a Devin di creare **nuove funzionalità complesse da zero** (anche se ripetitive) | Affidabilità inferiore su larga scala | **Tall & Deep**    |
| Assegnare a Devin **task semplici e ben definiti**                                        | Altamente affidabile ed efficace      | **Wide & Shallow** |

<div id="tall-deep-vs-wide-shallow">
  ### Stretto & profondo vs. ampio & superficiale
</div>

<div style={{ width: '100%' }}>
  <img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/use-cases/narrow-deep-vs-shallow.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=31e8a4ed3215dda3a3bb7a530dbdc75a" alt="Confronto tra stretto-profondo e ampio-superficiale" width="50%" style={{ marginLeft: 'auto', marginRight: 'auto' }} data-path="images/use-cases/narrow-deep-vs-shallow.png" />
</div>

Un **ampio backlog** di attività semplici, **scalabili orizzontalmente** (ad esempio la risoluzione di ticket SonarQube) può generare un **ROI** significativo quando viene esteso a migliaia di iterazioni.

<img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/use-cases/horizontal-changes.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=573767f3f77f9a58c0781b8e02bebc31" alt="Diagramma delle modifiche orizzontali" width="1916" height="322" data-path="images/use-cases/horizontal-changes.png" />

<Note>
  Più semplice è lo slice, più l'intero progetto risulta **affidabile**.
</Note>

<div id="what-to-slice">
  ## Cosa suddividere in slice
</div>

**Ottimi candidati per Devin:**

* **Migrazioni**
* **Refactoring**
* **Modernizzazioni**
* **Backlog di debito tecnico**

Ad esempio, quando si lavora a una **migrazione di codice**, questa deve essere suddivisa in **slice isolate**, ciascuna gestita da una singola sessione Devin.

<img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/use-cases/slicing-use-cases.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=6aa284d1718ffdbee6c34bc5941c6f0f" alt="Slicing use cases illustration" width="2000" height="581" data-path="images/use-cases/slicing-use-cases.png" />

<div id="verification">
  ## Verifica
</div>

Una slice dovrebbe essere la **più piccola unità atomica** del progetto.

| **Esempi di slice** |
| :------------------ |
| **File**            |
| **Notebook**        |
| **Modulo**          |

| **Requisito**  | **Dettagli**                                                                                                                                                                                            |
| :------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Time Limit** | Ogni slice deve richiedere **meno di 90 minuti** di lavoro manuale di sviluppo.                                                                                                                         |
| **Verifica**   | Deve includere un modo per **validare le modifiche al codice**, ad esempio: <br /> - Esecuzione dei test <br /> - Build del codice <br /> - Verifiche CI <br /> - Uno script di verifica personalizzato |

<Warning>
  Devin deve avere un chiaro meccanismo di verifica dell’esito (**successo/fallimento**).
</Warning>

<Tip>
  Evita attività con **dipendenze** eccessive o sistemi esterni. Devin eccelle nelle **attività di programmazione**.
</Tip>

<img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/use-cases/backwards-compatibility.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=af04cf632b6147d00d0a7b8770ea7565" alt="Diagramma di retrocompatibilità" width="1746" height="1332" data-path="images/use-cases/backwards-compatibility.png" />

<div id="parallel-execution">
  ## Esecuzione parallela
</div>

| **Requisito**            | **Descrizione**                                                                                                          |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| **Isolamento**           | Ogni slice deve essere **indipendente** e **retrocompatibile**.                                                          |
| **Esecuzione parallela** | Sfrutta il **parallelismo di Devin** per eseguire le slice **simultaneamente**.                                          |
| **Revisione umana**      | Una volta completato ciascun slice, deve essere sottoposto a **revisione umana** prima di effettuare il merge in `main`. |

<img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/use-cases/parallel-execution.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=a433d54e210090f0684cc52fe1dc9721" alt="Visualizzazione dell'esecuzione parallela" width="2576" height="872" data-path="images/use-cases/parallel-execution.png" />

<div id="scaling-considerations">
  ## Considerazioni sulla scalabilità
</div>

<img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/use-cases/overall-model.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=19606bc8be5371a190001df9daf3d2cf" alt="Overall model diagram" width="2216" height="1510" data-path="images/use-cases/overall-model.png" />

| **Principio**                        | **Descrizione**                                                                                   |
| ------------------------------------ | ------------------------------------------------------------------------------------------------- |
| **Affidabilità a livello di slice**  | Devin è ottimizzato per la **massima affidabilità** a livello di **singolo slice**.               |
| **Considerazione sulla scalabilità** | Quando si opera su **migliaia di slice**, mantenere un'**elevata affidabilità** è fondamentale.   |
| **Impatto degli errori**             | Anche un tasso di errore ridotto può avere un effetto cumulativo quando si lavora su larga scala. |

<div id="best-practices-for-task-definition">
  ## Best practice per la definizione dei task
</div>

| **Requisito**                    | **Descrizione**                                                            |
| -------------------------------- | -------------------------------------------------------------------------- |
| **Dettagli chiari dei passaggi** | Fornisci **istruzioni esplicite** per ogni slice.                          |
| **Riferimento end-to-end**       | Una **guida dettagliata o un video** aiuta a garantire coerenza.           |
| **Esempi Before/After**          | Offri **più esempi di codice before/after** (coppie input/output).         |
| **Accesso alle dipendenze**      | Assicurati che Devin abbia **tutte le dipendenze necessarie** per il task. |

Devin eccelle in task continuativi di **debito tecnico** (ad es. **revisioni di PR, automazione dei test QA**) quando sono correttamente **suddivisi in slice e strutturati**.

<Note>
  Migrazioni, modernizzazioni e refactoring sono ottimi casi d'uso **se possono essere affrontati in modo incrementale**.
  Ad esempio, una migrazione dell'intero repository che richiede **tutte le modifiche in una volta sola** **non è consigliata**.
</Note>

**Caso di studio:** [Nubank Migration Case Study](https://devin.ai/customers/nubank)