# Vorhandenen Code verstehen (/de/docs/verdent-for-vscode/task-based-guides/understanding-code)

> Mit Verdent vorhandene Codebasen erkunden, analysieren und verstehen



Verdent for VS Code hilft Ihnen, unbekannte Codebasen mithilfe natürlicher Sprachfragen und automatisierter Exploration zu verstehen. Der integrierte Explorer-Subagent findet schnell Dateien, durchsucht Codemuster und beantwortet architektonische Fragen, ohne Ihr Hauptkontextfenster zu belasten.

### Was Sie lernen werden [#was-sie-lernen-werden]

* Unbekannte Codebasen mit dem Explorer-Subagent erkunden
* Fragen zu Codestruktur und Implementierung stellen
* Detaillierte Erklärungen zu Funktionen, Klassen und Modulen erhalten
* Dokumentation aus vorhandenem Code generieren
* Projektarchitektur und Datenfluss verstehen
* Neue Teammitglieder effizient einarbeiten

### Voraussetzungen [#voraussetzungen]

Bevor Sie Verdent zum Verstehen von Code verwenden:

* Visual Studio Code mit installierter Verdent-Erweiterung
* Eine Codebasis oder ein Projekt-Arbeitsbereich, der in VS Code geöffnet ist
* Ein aktives Verdent-Abonnement mit verfügbaren Credits

***

## Unbekannte Codebasen erkunden [#unbekannte-codebasen-erkunden]

Wenn Sie Fragen zur Struktur der Codebasis stellen oder Dateisuchen anfordern, delegiert Verdent automatisch an den **Explorer-Subagent** (`@Explorer`), einen tokeneffizienten Spezialisten, der auf schnelle Erkundung von Codebasen optimiert ist.

Der Explorer-Subagent führt schnell Folgendes aus:

* Findet Dateien, die Mustern oder Namen entsprechen
* Durchsucht Code nach bestimmten Schlüsselwörtern oder Funktionen
* Beantwortet architektonische Fragen zur Codebasis
* Identifiziert, wo Funktionalität implementiert ist

**Beispiele für Erkundungsfragen:**

```
What is the structure of this project?
```

```
Where is user authentication handled?
```

```
Find all API endpoint definitions
```

```
Show me where database queries are defined
```

Der Explorer arbeitet effizient im Hintergrund und liefert schnelle Antworten, ohne Ihr Hauptkontextfenster zu belasten. Verdent präsentiert die Ergebnisse mit relevanten Dateipfaden und Codeausschnitten.

**Parallele Erkundung für komplexe Aufgaben:**

Für komplexe Erkundungsaufgaben können mehrere Explorer-Agenten parallel ausgeführt werden, um Zeit zu sparen, wobei jeder unterschiedliche Aspekte der Codebasis gleichzeitig untersucht. Verdent fasst die Ergebnisse dann zu einer kohärenten Zusammenfassung zusammen.

**Beispiel:**

```
Use the Explorer agent to find all places where we manually validate email addresses
```

Dies stellt sicher, dass Verdent systematisch jede Stelle findet, ohne Vorkommen in der gesamten Codebasis zu übersehen.

***

## Fragen zu Ihrem Code stellen [#fragen-zu-ihrem-code-stellen]

Verdent beantwortet praktisch jede Frage zu Ihrer Codebasis in natürlicher Sprache. Die KI versteht den Kontext und liefert detaillierte Erklärungen, Analysen und Einblicke.

<Tabs>
  <Tab title="Code verstehen">
    Fragen Sie, wie eine bestimmte Funktionalität funktioniert:

    ```
    Explain how authentication works in this project
    ```

    ```
    What does the calculateTotal function do?
    ```

    ```
    How are API requests handled?
    ```

    Verdent analysiert den relevanten Code, verfolgt Ausführungsabläufe und erklärt die Implementierung mit Verweisen auf bestimmte Dateien und Zeilennummern.
  </Tab>

  <Tab title="Architektur und Struktur">
    Verstehen Sie das große Ganze Ihrer Anwendung:

    ```
    What is the overall architecture of this application?
    ```

    ```
    How do the components communicate with each other?
    ```

    ```
    What design patterns are used in this codebase?
    ```

    Verdent untersucht Ihre Projektstruktur, identifiziert Muster und erklärt architektonische Entscheidungen.
  </Tab>

  <Tab title="Implementierung">
    Erhalten Sie Einblicke in technische Entscheidungen:

    ```
    Why do you think Redux was chosen instead of Context API for state management?
    ```

    ```
    What would happen if I changed the API timeout from 30s to 60s?
    ```

    ```
    Is this validateUserInput function redundant?
    ```

    Verdent analysiert den Codekontext und liefert fundierte Erklärungen basierend auf den Mustern Ihres Projekts und branchenüblichen Best Practices.
  </Tab>

  <Tab title="Entdeckung">
    Finden Sie bestimmte Funktionalitäten oder Abhängigkeiten:

    ```
    Where is user data validated?
    ```

    ```
    Show me all database queries in the project
    ```

    ```
    What dependencies does this project have?
    ```

    Der Explorer-Subagent führt effiziente Suchen mit Werkzeugen wie grep (Inhaltssuche) und glob (Dateimustersuche) durch und liefert relevante Ergebnisse, ohne den Hauptkontext zu belasten.
  </Tab>

  <Tab title="Lernen">
    Verstehen Sie Algorithmen und Muster:

    ```
    How does the quicksort algorithm work in the sortItems function?
    ```

    ```
    What are the best practices for error handling in React components?
    ```

    ```
    Explain the Observer pattern implementation in the EventEmitter class
    ```

    Verdent liefert klare Erklärungen mit Verweisen auf konkrete Implementierungen in Ihrer Codebasis.
  </Tab>
</Tabs>

***

## Funktionen und Klassen erklären [#funktionen-und-klassen-erklären]

Verdent liefert detaillierte Erklärungen zu bestimmten Funktionen oder Klassen, indem es deren Implementierung, Parameter, Rückgabewerte und Verwendung in der gesamten Codebasis analysiert.

**Beispiele:**

```
Explain the UserAuth class
```

```
What does the processPayment function do?
```

```
Break down the ApiService class methods
```

**Was Verdent erklärt:**

* **Zweck**: Was die Funktion oder Klasse bewirkt
* **Parameter**: Eingabetypen, erwartete Werte und Einschränkungen
* **Rückgabetypen**: Ausgabetypen und mögliche Rückgabewerte
* **Interne Logik**: Wie die Implementierung Schritt für Schritt funktioniert
* **Abhängigkeiten**: Verwendete externe Module, Funktionen oder Dienste
* **Verwendungsbeispiele**: Wie die Funktion/Klasse an anderer Stelle in Ihrem Code verwendet wird

Verdent verfolgt den Ausführungsablauf des Codes, identifiziert Randfälle und erklärt die Gründe hinter den Implementierungsentscheidungen.

***

## Dokumentation generieren [#dokumentation-generieren]

Verdent generiert Dokumentation in mehreren Formaten, einschließlich Inline-Codekommentaren (JSDoc, Python-Docstrings usw.), README-Dateien, API-Dokumentation und Architekturleitfäden.

#### Verwendung von Plan Mode für Dokumentation [#verwendung-von-plan-mode-für-dokumentation]

In Plan Mode kann Verdent:

* Ihre vorhandene Dokumentation analysieren, um deren Stil und Detailgrad anzupassen
* Klärende Fragen zu Formatierungspräferenzen stellen (Kommentarstil, Detailgrad, Einbindung von Beispielen)
* Die Codebasis analysieren, um aktuelle Dokumentationsmuster zu verstehen
* Einen Dokumentationsplan präsentieren, der zeigt, was in welchem Stil dokumentiert wird

**Beispiel:**

```
Generate JSDoc comments for all functions in the utils folder
```

Verdent untersucht vorhandene JSDoc-Kommentare in Ihrem Projekt, stellt Fragen zu Präferenzen (Parameterbeschreibungen, Einbindung von Verwendungsbeispielen) und generiert dann Dokumentation, die Ihren etablierten Konventionen entspricht.

**Unterstützte Dokumentationsformate:**

* **Inline-Kommentare**: JSDoc, Python-Docstrings, Javadoc, XML-Dokumentationskommentare
* **README-Dateien**: Projektübersichten, Einrichtungsanweisungen, Nutzungsanleitungen
* **API-Dokumentation**: Endpunktbeschreibungen, Anfrage-/Antwortformate, Authentifizierungsdetails
* **Architekturleitfäden**: Erklärungen zum Systemdesign, Komponentenbeziehungen, Datenflussdiagramme

<Tip>
  Verwenden Sie Plan Mode, wenn Sie umfangreiche Dokumentation generieren. Verdent überprüft Ihren vorhandenen Dokumentationsstil und stellt klärende Fragen, um sicherzustellen, dass die generierte Dokumentation den Konventionen Ihres Projekts entspricht.
</Tip>

<Tip>
  Verwenden Sie Plan Mode, wenn Sie Dokumentation für mehrere Dateien generieren, und überprüfen Sie die Dokumentationsstruktur vor dem Commit.
</Tip>

***

## Dateien und Module zusammenfassen [#dateien-und-module-zusammenfassen]

Verdent analysiert und fasst Dateien oder Module zusammen, indem es den Code liest, dessen Struktur versteht und dessen Zweck in klarer Sprache erklärt.

**Beispiele:**

```
Summarize what the authMiddleware.js file does
```

```
Explain the purpose of the UserService module
```

```
What's the main responsibility of the PaymentController?
```

**Was Verdent liefert:**

* **Hauptzweck**: Was die Datei/das Modul im System bewirkt
* **Schlüsselfunktionen**: Primäre Funktionen oder Methoden und ihre Rollen
* **Abhängigkeiten**: Verwendete externe Module und Dienste
* **Exporte**: Öffentliche API und worauf andere Teile des Systems zugreifen können
* **Muster**: Verwendete Designmuster oder architektonische Ansätze
* **Integrationspunkte**: Wie es mit anderen Teilen des Projekts verbunden ist

Verdent liest die Datei, identifiziert Schlüsselfunktionen, verfolgt Abhängigkeiten und erklärt, wie sich der Code in die größere Projektarchitektur einfügt.

***

## Architektur verstehen [#architektur-verstehen]

Verdent erklärt Architektur durch detaillierte Textbeschreibungen, Komponentenbeziehungen und Datenflusserklärungen. Zwar generiert es keine grafischen Diagramme direkt, kann aber ASCII-Art-Diagramme oder Mermaid-Diagrammcode erstellen, den Sie rendern können.

**Beispiel:**

```
Explain the architecture of this application and show component relationships
```

Verdent könnte eine ASCII-Darstellung erzeugen:

```
Frontend (React)
    ↓
API Layer (Express)
    ↓
Service Layer (Business Logic)
    ↓
Database Layer (PostgreSQL)
```

Oder Mermaid-Code zum Rendern generieren:

```mermaid
graph TD
    A[React Frontend] --> B[API Gateway]
    B --> C[Auth Service]
    B --> D[User Service]
    C --> E[Database]
    D --> E
```

**Architekturerklärungen umfassen:**

* **Komponenteninteraktionen**: Wie unterschiedliche Teile des Systems kommunizieren
* **Datenfluss**: Wie Informationen durch die Anwendung fließen
* **Architekturmuster**: MVC, Microservices, Schichtarchitektur usw.
* **Technologie-Stack**: Frontend, Backend, Datenbank, externe Dienste
* **Integrationspunkte**: APIs, Message Queues, Webhooks, Drittanbieterdienste
* **Skalierbarkeitsmuster**: Lastverteilung, Caching, Datenbank-Sharding

Verdent analysiert Ihre Projektstruktur, verfolgt Imports und Abhängigkeiten, identifiziert Muster und erklärt die architektonischen Entscheidungen hinter Ihrem Systemdesign.

***

## Neue Teammitglieder einarbeiten [#neue-teammitglieder-einarbeiten]

Verdent hilft bei der Einarbeitung neuer Teammitglieder, indem es Fragen zur Codebasis beantwortet, architektonische Entscheidungen erklärt, Schlüsseldateien und Muster identifiziert und Dokumentation generiert, die darauf zugeschnitten ist, Neulingen die Projektstruktur und die Konventionen verständlich zu machen.

**In Plan Mode** kann Verdent klärende Fragen stellen, um zu verstehen, welche Aspekte der Codebasis für die Rolle des neuen Teammitglieds am relevantesten sind, bevor ein personalisierter Einarbeitungsleitfaden erstellt wird.

**Beispielhafte Einarbeitungsfragen:**

```
What's the best starting point for understanding this codebase?
```

```
How does data flow from the API to the frontend?
```

```
Where should I look to understand the authentication system?
```

```
What are the naming conventions and code style guidelines used here?
```

**Verdent kann Folgendes generieren:**

* **Einarbeitungsleitfäden**: Schritt-für-Schritt-Durchgänge durch die Codebasisarchitektur
* **Komponentenübersichten**: Visuelle oder textbasierte Leitfäden, die zeigen, wie Komponenten zusammenhängen
* **Gängige Muster**: Dokumentation häufig verwendeter Muster und Konventionen
* **Einrichtungsanweisungen**: Wie die Entwicklungsumgebung konfiguriert und das Projekt ausgeführt wird
* **Erste Aufgaben**: Vorschläge für einfache erste Beiträge, um Vertrautheit zu gewinnen

Neue Teammitglieder können die Codebasis im Dialog erkunden und erhalten sofortige Antworten, ohne erfahrene Entwickler unterbrechen oder Stunden mit dem Lesen von Code verbringen zu müssen.

<Note>
  Der Explorer-Subagent von Verdent macht die Erkundung der Codebasis für Neulinge effizient. Sie können breite Fragen stellen wie „Zeig mir alle React-Komponenten" oder spezifische Anfragen wie „Wo ist die Fehlerprotokollierung implementiert?" und erhalten sofortige, präzise Antworten.
</Note>

***

## Best Practices [#best-practices]

<Accordion title="Beginnen Sie mit breiten Fragen und gehen Sie dann tiefer">
  Beginnen Sie mit übergeordneten Fragen wie „Wie sieht die Architektur aus?", bevor Sie sich mit spezifischen Implementierungen befassen. So bauen Sie den Kontext schrittweise auf.
</Accordion>

<Accordion title="Verwenden Sie den Explorer-Subagent explizit für umfassende Suchen">
  Für gründliche Suchen in der gesamten Codebasis erwähnen Sie den Explorer-Agenten explizit, um sicherzustellen, dass keine Vorkommen übersehen werden: „Verwende Explorer, um alle Authentifizierungsprüfungen zu finden."
</Accordion>

<Accordion title="Stellen Sie 'Warum'-Fragen, nicht nur 'Was'-Fragen">
  Das Verständnis der Beweggründe hinter Entscheidungen ist oft wertvoller als das Verständnis der Implementierung. Fragen Sie „Warum wurde dieses Muster gewählt?" zusätzlich zu „Was macht dieser Code?"
</Accordion>

<Accordion title="Nutzen Sie Plan Mode zur Dokumentationsgenerierung">
  Verwenden Sie beim Generieren von Dokumentation Plan Mode, um den Ansatz von Verdent zu überprüfen, sicherzustellen, dass er Ihrem Stil entspricht, und den Plan vor der Ausführung zu verfeinern.
</Accordion>

<Accordion title="Verwenden Sie @-Erwähnungen für gezielte Erklärungen">
  Verweisen Sie auf bestimmte Dateien, wenn Sie detaillierte Erklärungen wünschen: „@components/UserProfile.tsx erkläre diese Komponente" stellt sicher, dass sich Verdent auf den richtigen Code konzentriert.
</Accordion>

<Accordion title="Bauen Sie Kontext auf, bevor Sie Änderungen anfordern">
  Bevor Sie Änderungen vornehmen, bitten Sie Verdent, die aktuelle Implementierung zu erklären. Dies hilft Verdent, bessere Vorschläge zu machen, die mit den vorhandenen Mustern übereinstimmen.
</Accordion>

<Accordion title="Stellen Sie Folgefragen ohne Zurückhaltung">
  Verdent behält den Gesprächskontext bei, sodass Sie klärende Fragen stellen, tiefere Erklärungen anfordern oder verwandte Themen erkunden können, ohne den Kontext zu wiederholen.
</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">
    Erfahren Sie, wie Sie mit Verdent neue Funktionen und Komponenten schreiben
  </Card>

  <Card title="Code refaktorieren" icon="wrench" href="/docs/verdent-for-vscode/task-based-guides/refactoring">
    Verbessern und refaktorieren Sie vorhandenen Code sicher mit KI-Unterstützung
  </Card>
</CardGroup>
