# Beispiele für mehrstufige Aufgaben (/de/docs/verdent-for-vscode/common-workflows/multi-step-tasks)

> Umgang mit komplexen mehrstufigen Aufgaben mit Verdent



Verdent for VS Code eignet sich hervorragend dafür, komplexe mehrstufige Aufgaben eigenständig zu zerlegen. Dieser Leitfaden bietet schrittweise Workflows für gängige mehrstufige Szenarien und zeigt genau, wie Verdent die Aufgabenzerlegung, das Abhängigkeitsmanagement und die schrittweise Ausführung handhabt.

***

## Plan Mode für komplexe Implementierungen nutzen [#plan-mode-für-komplexe-implementierungen-nutzen]

Angenommen, Sie möchten einen detaillierten Plan überprüfen, bevor Verdent Änderungen an Ihrer Codebasis vornimmt.

<Steps>
  <Step title="Zu Plan Mode wechseln">
    Klicken Sie auf die Schaltfläche „Switch Mode" in der Oberfläche und wählen Sie „Plan Mode".

    Plan Mode ist rein lesend: Verdent kann Code analysieren, Recherchen durchführen und Pläne erstellen, ohne Dateien zu verändern oder Befehle auszuführen.
  </Step>

  <Step title="Ihre komplexe Anfrage übermitteln">
    ```
    Refactor this codebase to replace our custom authentication with OAuth 2.0
    ```

    Verdent analysiert Ihre aktuelle Implementierung gründlich.
  </Step>

  <Step title="Klärende Fragen beantworten">
    Verdent stellt möglicherweise Fragen, um Unklarheiten zu beseitigen:

    * Welcher OAuth-Anbieter soll verwendet werden?
    * Sollen Tokens in localStorage oder in Cookies gespeichert werden?
    * Müssen mehrere OAuth-Anbieter unterstützt werden?

    Beantworten Sie diese Fragen, um den Plan zu verfeinern.
  </Step>

  <Step title="Den detaillierten Plan überprüfen">
    Verdent präsentiert einen umfassenden Plan mit:

    * Zu erstellenden Dateien
    * Zu ändernden vorhandenen Dateien
    * Implementierungsschritten in logischer Reihenfolge
    * Abhängigkeiten zwischen den Schritten

    Prüfen Sie diesen Plan sorgfältig, bevor Sie fortfahren.
  </Step>

  <Step title="Wählen Sie Ihre nächste Aktion">
    Nach der Überprüfung des Plans bietet Verdent zwei Optionen an:

    * Wählen Sie **Edit**, um Änderungen anzufordern oder klärende Fragen zu stellen
    * Wählen Sie **Start Building**, um zu Agent Mode zu wechseln und mit der Ausführung zu beginnen

    Sie können den Plan beliebig oft überarbeiten, bevor Sie mit dem Bauen beginnen.
  </Step>
</Steps>

<Tip>
  **Tipps:**

  * Nutzen Sie Plan Mode für Funktionen, die mehrere Dateien betreffen
  * Führen Sie mehrere Runden der Planüberprüfung durch, um den Ansatz zu verfeinern
  * Speichern Sie den Plan in einer Datei zur Teamdiskussion vor der Ausführung
  * Plan Mode hilft dabei, die Übereinstimmung zwischen Ihren Erwartungen und der von Verdent vorgeschlagenen Lösung sicherzustellen
  * **Planformat anpassen:** Öffnen Sie **Settings → Rules → Plan Rules**, um Planstruktur, Detailgrad und Formatierungspräferenzen zu steuern
</Tip>

***

## Große Feature-Anfragen zerlegen [#große-feature-anfragen-zerlegen]

Angenommen, Sie bauen ein komplexes E-Commerce-Checkout-System mit mehreren integrierten Komponenten.

<Steps>
  <Step title="Das übergeordnete Ziel angeben">
    ```
    Build a complete checkout system with cart management, payment processing, order confirmation, and inventory updates
    ```

    Verdent analysiert, was zu tun ist.
  </Step>

  <Step title="Verdent erstellt logische Teilaufgaben">
    Das System zerlegt dies eigenständig in:

    1. Datenmodell für den Warenkorb und API erstellen
    2. Warenkorb-UI mit Hinzufügen/Entfernen/Aktualisieren von Artikeln erstellen
    3. Checkout-Seite mit Formular für die Versandadresse implementieren
    4. Zahlungsgateway integrieren (Stripe oder konfigurierter Anbieter)
    5. Bestellbestätigungsseite erstellen
    6. Logik zur Bestandsaktualisierung hinzufügen
    7. E-Mail-Bestätigungssystem implementieren
    8. Integrationstests schreiben

    Jede Teilaufgabe wird in der Todo-Liste mit klaren Beschreibungen angezeigt.
  </Step>

  <Step title="Verdent verwaltet Abhängigkeiten automatisch">
    Verdent führt Teilaufgaben in der richtigen Reihenfolge aus:

    * Erstellt Datenmodelle vor den API-Endpunkten, die sie verwenden
    * Baut Backend-Endpunkte vor Frontend-Komponenten, die diese aufrufen
    * Implementiert Kernfunktionen, bevor Tests hinzugefügt werden

    Abhängigkeiten werden automatisch ohne manuelles Eingreifen verwaltet.
  </Step>

  <Step title="Fortschritt in Echtzeit überwachen">
    Beobachten Sie, wie sich die Todo-Liste in Echtzeit aktualisiert, während Verdent jede Teilaufgabe abarbeitet. Todo-Einträge wechseln von ausstehend → in Bearbeitung → abgeschlossen.
  </Step>
</Steps>

<Tip>
  **Tipps:**

  * Lassen Sie Verdent die Zerlegung bei den meisten Aufgaben eigenständig übernehmen
  * Nutzen Sie Plan Mode, wenn Sie die Zerlegung vor der Ausführung überprüfen möchten
  * Verdent passt seinen Ansatz an, wenn es auf Grenzfälle oder neue Anforderungen trifft
  * Die sichtbare Todo-Liste sorgt für Transparenz bei der mehrstufigen Ausführung
</Tip>

***

## Mehrphasige Refactoring-Projekte [#mehrphasige-refactoring-projekte]

Angenommen, Sie refaktorisieren eine große Codebasis und möchten dabei in überschaubaren Phasen vorgehen.

<Steps>
  <Step title="Den mehrphasigen Ansatz definieren">
    ```
    In Plan Mode: Refactor this codebase to replace our custom authentication with OAuth 2.0. I want this done in phases so we can test incrementally.
    ```
  </Step>

  <Step title="Verdent schlägt Phasenaufteilung vor">
    Verdent schlägt einen mehrphasigen Plan vor:

    * **Phase 1**: OAuth-Bibliothek hinzufügen und Endpunkte konfigurieren
    * **Phase 2**: Benutzermodell und Datenbankschema aktualisieren
    * **Phase 3**: Bestehende Authentifizierungslogik migrieren
    * **Phase 4**: Veraltete Authentifizierungscode entfernen
    * **Phase 5**: Tests und Dokumentation aktualisieren

    Jede Phase ist unabhängig testbar.
  </Step>

  <Step title="Phase für Phase ausführen">
    Genehmigen Sie Phase 1, lassen Sie Verdent sie ausführen und testen Sie dann:

    ```
    npm test
    ```

    Sobald Phase 1 als funktionierend verifiziert ist, gehen Sie zu Phase 2 über.
  </Step>

  <Step title="Nachfolgende Phasen bei Bedarf anpassen">
    Basierend auf den Erkenntnissen aus Phase 1 können Sie den Ansatz für die verbleibenden Phasen anpassen:

    ```
    For Phase 2, let's also add user role migration to the database schema changes
    ```
  </Step>

  <Step title="Alle Phasen schrittweise abschließen">
    Arbeiten Sie alle Phasen mit Tests und Verifizierung zwischen jeder Phase durch, um Sicherheit zu gewährleisten und Kurskorrekturen zu ermöglichen.
  </Step>
</Steps>

<Tip>
  **Tipps:**

  * Mehrphasiges Refactoring reduziert das Risiko, da inkrementelles Testen möglich ist
  * Jede Phase sollte die Codebasis in einem funktionierenden Zustand hinterlassen
  * Committen Sie nach jeder Phase, um bei Bedarf einfach zurückrollen zu können
  * Passen Sie spätere Phasen basierend auf den Erkenntnissen aus früheren Phasen an
</Tip>

***

## Backend- und Frontend-Änderungen koordinieren [#backend--und-frontend-änderungen-koordinieren]

Angenommen, Sie fügen eine Funktion hinzu, die synchronisierte Aktualisierungen sowohl der Backend-APIs als auch der Frontend-Komponenten erfordert.

<Steps>
  <Step title="Die Full-Stack-Funktion beschreiben">
    ```
    Add a commenting system where users can add comments to blog posts. Include backend API, database schema, and frontend UI
    ```
  </Step>

  <Step title="Verdent koordiniert einen Backend-first-Ansatz">
    Verdent geht bei Full-Stack-Funktionen typischerweise Backend-first vor:

    1. Datenbankmigration für die Kommentartabelle erstellen
    2. API-Endpunkt zum Erstellen von Kommentaren hinzufügen
    3. API-Endpunkt zum Abrufen von Kommentaren hinzufügen
    4. TypeScript-Schnittstellen für Kommentardaten definieren
    5. Frontend-Komponente für das Kommentarformular erstellen
    6. Komponente zur Kommentaranzeige erstellen
    7. Frontend mit API-Endpunkten verbinden
  </Step>

  <Step title="Verdent sorgt für Konsistenz">
    Verdent stellt sicher, dass:

    * TypeScript-Schnittstellen im Frontend mit den Backend-Datenstrukturen übereinstimmen
    * API-Endpunkt-URLs im Frontend-Code korrekt referenziert werden
    * Anfrage-/Antwortformate zwischen Backend und Frontend übereinstimmen
    * Fehlerbehandlung im gesamten Stack konsistent ist
  </Step>

  <Step title="Integrationstests">
    ```
    Write integration tests for the commenting system covering the full stack
    ```

    Verdent erstellt Tests, die überprüfen, ob Backend und Frontend korrekt zusammenarbeiten.
  </Step>
</Steps>

<Tip>
  **Tipps:**

  * Der Backend-first-Ansatz stellt sicher, dass das Frontend funktionierende APIs zur Integration hat
  * Verdent wahrt automatisch die Konsistenz zwischen Backend- und Frontend-Code
  * TypeScript-Schnittstellen helfen dabei, Integrationsprobleme bereits zur Kompilierzeit zu erkennen
  * Integrationstests verifizieren, dass die vollständige Funktion end-to-end funktioniert
</Tip>

***

## Subagents für die parallele Ausführung nutzen [#subagents-für-die-parallele-ausführung-nutzen]

Angenommen, Sie haben mehrere unabhängige Aufgaben, die gleichzeitig erledigt werden könnten.

<Steps>
  <Step title="Parallelisierbare Aufgaben identifizieren">
    ```
    Generate unit tests for all service classes in the src/services directory
    ```

    Diese Testdateien sind unabhängig und können parallel erstellt werden.
  </Step>

  <Step title="Verdent delegiert an mehrere Subagents">
    Verdent nutzt automatisch mehrere Subagents, um unabhängige Aufgaben gleichzeitig zu bearbeiten:

    * Subagent 1: Erstellt Tests für UserService
    * Subagent 2: Erstellt Tests für PaymentService
    * Subagent 3: Erstellt Tests für NotificationService
    * Subagent 4: Erstellt Tests für AuthService

    Die gesamte Arbeit läuft parallel ab und spart dadurch Zeit.
  </Step>

  <Step title="Ergebnisse werden zusammengeführt">
    Jeder Subagent liefert seine Ergebnisse zurück. Verdent integriert alle Testdateien mit korrekter Benennung und Struktur in das Projekt.
  </Step>

  <Step title="Sequenzielle Verifizierung">
    Führen Sie nach der parallelen Erstellung die Tests sequenziell aus, um zu überprüfen, ob sie alle funktionieren:

    ```
    npm test
    ```
  </Step>
</Steps>

<Tip>
  **Tipps:**

  * Verdent parallelisiert unabhängige Aufgaben automatisch mithilfe von Subagents
  * Locker gekoppelte Arbeit (separate Testdateien, unabhängige Komponenten) profitiert von der Parallelisierung
  * Eng gekoppelte Arbeit (Dateien mit Abhängigkeiten) wird zur Korrektheit sequenziell erledigt
  * Die parallele Ausführung beschleunigt umfangreiche Änderungen erheblich
</Tip>

***

## Häufig gestellte Fragen [#häufig-gestellte-fragen]

<Accordion title="Kann ich Verdent mitten in einer mehrstufigen Aufgabe anhalten?">
  Ja. Sie können die Ausführung jederzeit unterbrechen. Verdent schließt den aktuell bearbeiteten Schritt ab und stoppt dann. Der bis dahin erreichte Fortschritt bleibt erhalten. Sie können überprüfen, was bereits erledigt wurde, Anpassungen vornehmen und entweder fortfahren oder einen anderen Ansatz wählen.
</Accordion>

<Accordion title="Wie erkenne ich, was Verdent bei einer langen Aufgabe gerade tut?">
  Beobachten Sie die Todo-Liste. Sie zeigt den Status in Echtzeit an, wobei jeweils ein Eintrag als „in Bearbeitung" markiert ist. Der aktive Eintrag zeigt genau, worauf Verdent gerade arbeitet. Abgeschlossene Einträge sind als erledigt markiert, und ausstehende Einträge zeigen, was noch verbleibt.
</Accordion>

<Accordion title="Was, wenn ich mit der Art, wie Verdent meine Aufgabe zerlegt hat, nicht einverstanden bin?">
  Nutzen Sie Plan Mode, um die Zerlegung vor der Ausführung zu überprüfen und anzupassen. In Plan Mode können Sie Feedback geben wie „Teile die Frontend-Arbeit in separate Komponenten auf" oder „Fasse diese beiden Schritte zusammen." Verdent überarbeitet den Plan basierend auf Ihrem Feedback, bevor jeglicher Code geschrieben wird.
</Accordion>

<Accordion title="Sollte ich Plan Mode für jede mehrstufige Aufgabe verwenden?">
  Nicht unbedingt. Nutzen Sie Plan Mode für komplexe Funktionen, die viele Dateien betreffen, für große Refactorings oder wenn Sie den Ansatz zunächst überprüfen möchten. Für vertraute, unkomplizierte Aufgaben kann Verdent direkt ausführen, mit Echtzeit-Transparenz über die Todo-Liste. Plan Mode fügt einen Überprüfungsschritt für risikoreichere Änderungen hinzu.
</Accordion>

<Accordion title="Kann ich den Plan von Verdent nach Beginn der Ausführung noch ändern?">
  Sie können korrigierende Hinweise geben, während Verdent arbeitet. Sagen Sie „Verwende eigentlich einen anderen Ansatz für die API-Integration" und Verdent passt die verbleibenden Schritte an. Bei größeren Planänderungen ist es besser, anzuhalten, das bereits Erledigte zu committen und mit dem überarbeiteten Ansatz eine neue Sitzung zu beginnen.
</Accordion>

***

## Siehe auch [#siehe-auch]

<CardGroup cols="2">
  <Card title="Neuen Code schreiben" icon="code" href="/docs/verdent-for-vscode/task-based-guides/writing-code">
    Erstellen neuer Funktionen und Komponenten mit Verdent
  </Card>

  <Card title="Best Practices" icon="star" href="/docs/verdent-for-vscode/best-practices/prompts">
    Effektives Prompting und Workflow-Strategien
  </Card>
</CardGroup>