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

# Meilleures pratiques

> Comment structurer le travail pour Devin afin de maximiser l’efficacité et le ROI

Le choix du bon cas d’usage pour Devin est essentiel pour maximiser l’efficacité et le retour sur investissement (ROI). Vous trouverez ci-dessous les meilleures pratiques pour sélectionner un cas d’usage qui tire parti des points forts de Devin.

<div id="best-enterprise-use-cases">
  ## Meilleurs cas d’usage pour l’offre Enterprise
</div>

| **Critères d’un cas d’usage idéal**                                                                           |
| :------------------------------------------------------------------------------------------------------------ |
| Projets importants, à forte valeur métier, pouvant être décomposés en **sous-tâches isolées et répétitives**. |
| Tâches nécessitant **moins de 90 minutes** de travail d’ingénierie effectué manuellement.                     |
| **Tâches rétrocompatibles** pouvant être validées et fusionnées indépendamment.                               |

<div id="devins-ideal-requirements">
  ## Exigences idéales pour Devin
</div>

| **Exigence**                                               |
| :--------------------------------------------------------- |
| Volume important de **sous-tâches répétitives** (slices)   |
| Tâches d’une complexité de **niveau ingénieur junior**     |
| Tâches **isolées et incrémentales**                        |
| Sous-tâches **objectives et vérifiables**                  |
| **(Recommandé)** Dépendances minimales vis-à-vis du projet |

Si votre tâche remplit la plupart ou la totalité de ces exigences, elle est idéale à confier à Devin.

<div id="crafting-devins-work">
  ## Structurer le travail de Devin
</div>

Choisir le bon **type de tâche** est essentiel pour maximiser la fiabilité de Devin.

| **Scénario**                                                                                            | **Enjeu de fiabilité**                 | **Type de tâche**  |
| ------------------------------------------------------------------------------------------------------- | -------------------------------------- | ------------------ |
| Demander à Devin de créer des **fonctionnalités entièrement nouvelles** complexes (même si répétitives) | Fiabilité plus faible à grande échelle | **Tall & Deep**    |
| Confier à Devin des **tâches simples et bien définies**                                                 | Très fiable et efficace                | **Wide & Shallow** |

<div id="tall-deep-vs-wide-shallow">
  ### Étroit & profond vs. large & superficiel
</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="Comparaison entre étroit-profond et large-superficiel" width="50%" style={{ marginLeft: 'auto', marginRight: 'auto' }} data-path="images/use-cases/narrow-deep-vs-shallow.png" />
</div>

Un **important backlog** de tâches simples, **faciles à mettre à l’échelle horizontalement** (par exemple, la résolution de problèmes SonarQube) peut générer un **retour sur investissement (ROI)** significatif lorsqu’il est répliqué sur des milliers d’itérations.

<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="Diagramme de changements horizontaux" width="1916" height="322" data-path="images/use-cases/horizontal-changes.png" />

<Note>
  Plus chaque tranche est simple, plus le projet global est **fiable**.
</Note>

<div id="what-to-slice">
  ## Que découper
</div>

**Excellents cas d’utilisation pour Devin :**

* **Migrations**
* **Refactorisations**
* **Modernisations**
* **Backlogs de dette technique**

Par exemple, lors d’une **migration de code**, vous devez la découper en **segments isolés**, chacun géré par une session Devin distincte.

<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">
  ## Vérification
</div>

Une slice doit être la **plus petite unité atomique** du projet.

| **Exemples de slices** |
| :--------------------- |
| **Fichier**            |
| **Notebook**           |
| **Module**             |

| **Exigence**        | **Détails**                                                                                                                                                                                                                                   |
| :------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Limite de temps** | Chaque slice doit nécessiter **moins de 90 minutes** de travail d’ingénierie manuel.                                                                                                                                                          |
| **Vérification**    | Doit inclure un moyen de **valider les changements de code**, par exemple : <br /> - Exécuter les tests <br /> - Compiler ou construire le code <br /> - Lancer les vérifications CI <br /> - Utiliser un script de vérification personnalisé |

<Warning>
  Devin doit disposer d’un mécanisme clair de vérification du **succès ou de l’échec**.
</Warning>

<Tip>
  Évitez les tâches comportant des **dépendances** excessives ou des systèmes externes. Devin excelle sur les **tâches de développement**.
</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="Schéma de rétrocompatibilité" width="1746" height="1332" data-path="images/use-cases/backwards-compatibility.png" />

<div id="parallel-execution">
  ## Exécution parallèle
</div>

| **Exigence**            | **Description**                                                                                                       |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------- |
| **Isolation**           | Chaque segment doit être **indépendant** et **rétrocompatible**.                                                      |
| **Exécution parallèle** | Utilisez **le parallélisme de Devin** pour exécuter les segments **simultanément**.                                   |
| **Revue humaine**       | Une fois chaque segment terminé, il doit être soumis à une **revue par un humain** avant d’être fusionné dans `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="Visualisation de l’exécution parallèle" width="2576" height="872" data-path="images/use-cases/parallel-execution.png" />

<div id="scaling-considerations">
  ## Considérations de passage à l’échelle
</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="Schéma global du modèle" width="2216" height="1510" data-path="images/use-cases/overall-model.png" />

| **Principe**                             | **Description**                                                                                             |
| ---------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| **Fiabilité au niveau du slice**         | Devin est optimisé pour une **fiabilité maximale** au niveau de **chaque slice individuel**.                |
| **Considération de passage à l’échelle** | Lors du passage à l’échelle à **des milliers de slices**, maintenir une **fiabilité élevée** est essentiel. |
| **Impact des erreurs**                   | Même un faible taux d’erreur peut se cumuler lorsqu’on exécute à grande échelle.                            |

<div id="best-practices-for-task-definition">
  ## Bonnes pratiques pour la définition des tâches
</div>

| **Exigence**                  | **Description**                                                                         |
| ----------------------------- | --------------------------------------------------------------------------------------- |
| **Détails des étapes clairs** | Fournissez des **instructions explicites** pour chaque sous-tâche.                      |
| **Référence de bout en bout** | Un **guide détaillé ou une vidéo** aide à garantir la cohérence.                        |
| **Exemples avant/après**      | Proposez plusieurs **exemples de code avant/après** (paires entrée/sortie).             |
| **Accès aux dépendances**     | Assurez-vous que Devin dispose de **toutes les dépendances nécessaires** pour la tâche. |

Devin excelle sur les tâches récurrentes de **dette technique** (par exemple, **revues de pull requests (PR), automatisation de la QA**) lorsqu’elles sont correctement **découpées et structurées**.

<Note>
  Les migrations, modernisations et refactorings sont d’excellents cas d’usage **si elles peuvent être abordées de manière incrémentale**.
  Par exemple, une migration de l’ensemble du dépôt nécessitant **tous les changements en une seule fois** n’est **pas recommandée**.
</Note>

**Étude de cas :** [Étude de cas de migration Nubank](https://devin.ai/customers/nubank)