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

# Best Practices

> So strukturieren Sie Arbeit mit Devin, um Effizienz und ROI zu maximieren

Den richtigen Use Case für Devin zu finden, ist entscheidend, um Effizienz und Return on Investment (ROI) zu maximieren. Im Folgenden finden Sie Best Practices für die Auswahl eines Use Cases, der zu den Stärken von Devin passt.

<div id="best-enterprise-use-cases">
  ## Optimale Enterprise-Anwendungsfälle
</div>

| **Kriterien für ideale Anwendungsfälle**                                                                                     |
| :--------------------------------------------------------------------------------------------------------------------------- |
| Große Projekte mit hohem geschäftlichem Mehrwert, die in **isolierte und wiederholbare Teilaufgaben** zerlegt werden können. |
| Aufgaben, die **weniger als 90 Minuten** manuelle Entwicklungszeit erfordern.                                                |
| **Abwärtskompatible Aufgaben**, die unabhängig validiert und integriert werden können.                                       |

<div id="devins-ideal-requirements">
  ## Devins ideale Anforderungen
</div>

| **Anforderung**                                          |
| :------------------------------------------------------- |
| Hohe Anzahl **wiederkehrender Unteraufgaben** („Slices“) |
| Aufgaben mit **Komplexität auf Junior-Engineer-Niveau**  |
| **Isolierte und schrittweise** Aufgaben                  |
| **Objektive und überprüfbare** Unteraufgaben             |
| **(Empfohlen)** Geringe Projektabhängigkeiten            |

Wenn Ihre Aufgabe die meisten oder alle dieser Anforderungen erfüllt, ist sie ein idealer Kandidat für Devin.

<div id="crafting-devins-work">
  ## Die Arbeit mit Devin gestalten
</div>

Die Wahl des richtigen **Aufgabentyps** ist entscheidend, um die Zuverlässigkeit von Devin zu maximieren.

| **Szenario**                                                                                           | **Zuverlässigkeitsaspekt**                  | **Aufgabentyp**   |
| ------------------------------------------------------------------------------------------------------ | ------------------------------------------- | ----------------- |
| Devin beauftragen, komplexe, **komplett neue Features** zu entwickeln (selbst wenn sie repetitiv sind) | Geringere Zuverlässigkeit bei großem Umfang | **Schmal & Tief** |
| Devin **einfache, klar definierte Aufgaben** zuweisen                                                  | Sehr zuverlässig und effektiv               | **Breit & Flach** |

<div id="tall-deep-vs-wide-shallow">
  ### Tief & schmal vs. breit & flach
</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="Vergleich schmal-tief vs. flach-breit" width="50%" style={{ marginLeft: 'auto', marginRight: 'auto' }} data-path="images/use-cases/narrow-deep-vs-shallow.png" />
</div>

Ein **großer Backlog** aus einfachen, **horizontal skalierbaren** Aufgaben (z. B. dem Beheben von SonarQube-Issues) kann einen erheblichen **ROI** erzielen, wenn er über Tausende von Iterationen skaliert wird.

<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="Diagramm horizontaler Änderungen" width="1916" height="322" data-path="images/use-cases/horizontal-changes.png" />

<Note>
  Je einfacher der Slice ist, desto **zuverlässiger** ist das Gesamtprojekt.
</Note>

<div id="what-to-slice">
  ## Was Sie slicen sollten
</div>

**Gute Kandidaten für Devin:**

* **Migrationen**
* **Refactorings**
* **Modernisierungen**
* **Backlogs technischer Schulden**

Wenn Sie zum Beispiel an einer **Code-Migration** arbeiten, muss diese in **isolierte Slices** aufgeteilt werden, die jeweils in einer eigenen Devin-Session bearbeitet werden.

<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">
  ## Verifizierung
</div>

Ein Slice sollte die **kleinste atomare Einheit** des Projekts sein.

| **Beispiel-Slices** |
| :------------------ |
| **Datei**           |
| **Notebook**        |
| **Modul**           |

| **Anforderung**   | **Details**                                                                                                                                                                                                      |
| :---------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Zeitlimit**     | Jedes Slice darf **höchstens 90 Minuten** manuelle Entwicklungsarbeit erfordern.                                                                                                                                 |
| **Verifizierung** | Muss eine Möglichkeit beinhalten, **Codeänderungen zu überprüfen**, zum Beispiel: <br /> - Ausführen von Tests <br /> - Build des Codes <br /> - CI-Checks <br /> - Ein benutzerdefiniertes Verifizierungsskript |

<Warning>
  Devin muss über einen klaren Verifizierungsmechanismus für **Erfolg/Misserfolg** verfügen.
</Warning>

<Tip>
  Vermeiden Sie Aufgaben mit übermäßigen **Abhängigkeiten** oder externen Systemen. Devin ist besonders gut für **Programmieraufgaben** geeignet.
</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="Backwards compatibility diagram" width="1746" height="1332" data-path="images/use-cases/backwards-compatibility.png" />

<div id="parallel-execution">
  ## Parallele Ausführung
</div>

| **Anforderung**             | **Beschreibung**                                                                                                               |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| **Isolation**               | Jedes Slice muss **unabhängig** und **abwärtskompatibel** sein.                                                                |
| **Parallele Ausführung**    | Verwende die **Parallelisierung von Devin**, um Slices **gleichzeitig** auszuführen.                                           |
| **Menschliche Überprüfung** | Nachdem jedes Slice abgeschlossen ist, sollte es vor dem Merge in `main` einer **menschlichen Überprüfung** unterzogen werden. |

<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="Visualisierung der parallelen Ausführung" width="2576" height="872" data-path="images/use-cases/parallel-execution.png" />

<div id="scaling-considerations">
  ## Überlegungen zur Skalierung
</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="Gesamtdiagramm des Modells" width="2216" height="1510" data-path="images/use-cases/overall-model.png" />

| **Prinzip**                         | **Beschreibung**                                                                                                       |
| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| **Zuverlässigkeit auf Slice-Ebene** | Devin ist für **maximale Zuverlässigkeit** auf der **Ebene einzelner Slices** optimiert.                               |
| **Überlegungen zur Skalierung**     | Beim Skalieren über **tausende Slices** hinweg ist die Aufrechterhaltung einer **hohen Zuverlässigkeit** entscheidend. |
| **Auswirkungen von Fehlern**        | Selbst eine geringe Fehlerrate kann sich bei der Ausführung in großem Maßstab stark auswirken.                         |

<div id="best-practices-for-task-definition">
  ## Best Practices für die Definition von Aufgaben
</div>

| **Anforderung**                | **Beschreibung**                                                                      |
| ------------------------------ | ------------------------------------------------------------------------------------- |
| **Klare Schritt-Details**      | Gib **explizite Anweisungen** für jede Teilaufgabe.                                   |
| **End-to-End-Referenz**        | Ein **detaillierter Leitfaden oder ein Video** hilft, Konsistenz sicherzustellen.     |
| **Vorher/Nachher-Beispiele**   | Stelle mehrere **Vorher/Nachher-Codebeispiele** (Input/Output-Paare) bereit.          |
| **Zugriff auf Abhängigkeiten** | Stelle sicher, dass Devin **alle erforderlichen Abhängigkeiten** für die Aufgabe hat. |

Devin eignet sich besonders gut für fortlaufende Aufgaben im Bereich der **Technical Debt** (z. B. **PR-Reviews, QA-Automatisierung**), wenn sie sinnvoll **in Teilaufgaben zerlegt und strukturiert** sind.

<Note>
  Migrationen, Modernisierungen und Refactorings sind starke Anwendungsfälle, **wenn sie schrittweise bearbeitet werden können**.
  Eine vollständige Repository-Migration, die **alle Änderungen auf einmal** erfordert, ist beispielsweise **nicht zu empfehlen**.
</Note>

**Fallstudie:** [Fallstudie zur Nubank-Migration](https://devin.ai/customers/nubank)