# Konfiguration & Anpassung (/de/docs/verdent-for-vscode/configuration/settings)
> Verdent an Ihren Workflow anpassen
Verdent for VS Code bietet umfangreiche Konfigurationsmöglichkeiten, um sich an Ihren Entwicklungsworkflow, Ihre Coding-Präferenzen und Teamstandards anzupassen. Konfigurieren Sie Einstellungen über die native Einstellungsoberfläche von VS Code, passen Sie Tastaturkürzel an und erstellen Sie Regeln und Subagenten für spezialisiertes Verhalten.
### Was Sie lernen werden [#was-sie-lernen-werden]
* Konfigurieren der VS Code-Erweiterungseinstellungen für Verdent
* Anpassen von Tastaturkürzeln für einen effizienten Workflow
* Erstellen und Verwalten von Regeln für personalisiertes Agentenverhalten
* Erstellen benutzerdefinierter Subagenten für spezialisierte Aufgaben
### Voraussetzungen [#voraussetzungen]
* Verdent for VS Code installiert und authentifiziert
* Zugriff auf die VS Code-Einstellungen (`Cmd+,` oder `Ctrl+,`)
* Grundkenntnisse in JSON für Regeldateien (optional)
***
## VS Code-Erweiterungseinstellungen [#vs-code-erweiterungseinstellungen]
Die Einstellungen von Verdent for VS Code sind je nach Konfigurationstyp und -umfang an mehreren Stellen zugänglich.
### Zugriff auf Einstellungen [#zugriff-auf-einstellungen]
**Erweiterungseinstellungen (nativ in VS Code):**
1. Öffnen Sie die VS Code-Einstellungen: `Cmd+,` (macOS) oder `Ctrl+,` (Windows/Linux)
2. Suchen Sie in der Einstellungssuche nach „Verdent“
3. Ändern Sie die Erweiterungseinstellungen (z. B. `verdent.enableCheckpoints`)
**Verdent-spezifische Einstellungen:**
Klicken Sie auf die Schaltfläche **Einstellungen** in der oberen Leiste von Verdent, um Folgendes aufzurufen:
* **Regeln** – Benutzerregeln, Projektregeln, Plan-Regeln
* **MCP-Server** – Model-Context-Protocol-Konfigurationen
* **Subagenten** – Verwaltung benutzerdefinierter Subagenten
**Steuerelemente im Chat:**
Viele Einstellungen lassen sich direkt über das Eingabefeld unten im Verdent-Panel umschalten:
* **Berechtigung wechseln** – Manuelle Bestätigung, Auto-Run, Plan, Berechtigungen überspringen
* **Modus wechseln** – Agent-, Plan-, Chat-Modus
* **KI-Modell wechseln/anpassen** – Voreinstellungen für Performance, Balance, Efficiency
* **Think Hard Mode** – Maximales Denkbudget für komplexes Reasoning
* **Kontext hinzufügen** – Dateien über @-Erwähnungen anhängen
* **Bilder oder Dateien hinzufügen** – Screenshots oder Dokumente einfügen
* **Subagent hinzufügen** – Aufgaben an spezialisierte Subagenten delegieren
Einstellungsänderungen werden sofort wirksam, ohne dass ein Neustart von VS Code erforderlich ist.
***
## Verfügbare Erweiterungseinstellungen [#verfügbare-erweiterungseinstellungen]
Verdent for VS Code bietet **2 zentrale Erweiterungseinstellungen**, die über die Einstellungsoberfläche von VS Code konfiguriert werden können:
| Einstellung | Typ | Standard | Beschreibung |
| --------------------------- | --------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `verdent.enableCheckpoints` | `boolean` | `true` | Ermöglicht der Erweiterung, während der Aufgabenbearbeitung Checkpoints des Arbeitsbereichs mittels Git zu speichern. Kann die Performance bei großen Arbeitsbereichen beeinträchtigen. |
| `verdent.enableProxy` | `boolean` | `true` | Aktiviert Proxy-Unterstützung für Netzwerkverbindungen. Erforderlich für Nutzer hinter Unternehmens-Firewalls oder Proxy-Servern. |
Dies sind alle VS Code-Erweiterungseinstellungen für Verdent. Weitere Konfigurationsoptionen (Regeln, Subagenten, MCP-Server) werden über das Verdent-Einstellungsmenü in der oberen Leiste der Erweiterung verwaltet.
***
## Referenz der Eingabefeld-Steuerelemente [#referenz-der-eingabefeld-steuerelemente]
Das Eingabefeld unten im Verdent-Panel bietet schnellen Zugriff auf Konfigurationssteuerelemente:
| Steuerelement | Zweck | Optionen |
| ---------------------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------- |
| **Kontext hinzufügen** | Dateien über @-Erwähnungen anhängen | @Dateiname, @Ordnername |
| **Bilder oder Dateien hinzufügen** | Screenshots oder Dokumente einfügen | Bilder, PDFs, Textdateien hochladen |
| **Subagent hinzufügen** | An spezialisierte Agenten delegieren | @Verifier, @Explorer, @Code-reviewer, benutzerdefinierte Subagenten |
| **Modus wechseln** | Ausführungsmodus umschalten | Agent Mode, Plan Mode, Chat Mode |
| **KI-Modell wechseln/anpassen** | Modellvoreinstellung oder bestimmtes Modell auswählen | Performance (1-2-facher Preis), Balance (1-facher Preis), Efficiency (0,3-facher Preis) |
| **Think Hard Mode** | Erweitertes Reasoning aktivieren | Ein-/Ausschalten für komplexe Probleme |
| **Berechtigung wechseln** | Berechtigungsstufe ändern | Manuelle Bestätigung (Standard), Auto-Run, Plan, Berechtigungen überspringen |
### Berechtigungsmodi [#berechtigungsmodi]
* Jede Operation erfordert eine Freigabe
* Vollständige Transparenz und Kontrolle
* Am besten geeignet zum Lernen, für unbekannte Codebasen und Produktionscode
* Befehle erfordern eine Freigabe, Dateioperationen erfolgen automatisch
* Weniger Berechtigungsabfragen
* Am besten geeignet für vertrauenswürdige Projekte und schnelles Prototyping
* Nur lesende Analyse und Planung
* Keine Codeänderungen während der Planung
* Am besten geeignet für komplexe Änderungen und architektonische Entscheidungen
* Vollständige Autonomie ohne Freigabeabfragen
* Schnellste Ausführung, aber höchstes Risiko
* Am besten geeignet für automatisierte Umgebungen und CI/CD
### Modellvoreinstellungen [#modellvoreinstellungen]
* **Kosten:** 1-fache Basislinie
* **Modelle:** Claude-4.5-sonnet
* **Am besten geeignet für:** Allgemeine Entwicklung, alltägliches Coding, Feature-Implementierung
* **Kosten:** 1- bis 2-fache Balance-Basislinie
* **Modelle:** Claude-4.5-sonnet-1m (1M Token Kontext)
* **Am besten geeignet für:** Komplexe Architektur, große Codebasen, Aufgaben über 200.000 Token
* **Kosten:** 3,2-mal effizienter als Sonnet (70 % Credit-Einsparung)
* **Modelle:** Claude-4.5-haiku
* **Am besten geeignet für:** Schnelle Fixes, einfache Aufgaben, Routineoperationen
***
## Anpassung von Tastaturkürzeln [#anpassung-von-tastaturkürzeln]
### Standardkürzel [#standardkürzel]
**Primäres Tastenkürzel:**
* **macOS:** `Cmd+L` – Verdent-Panel öffnen/fokussieren
* **Windows/Linux:** `Ctrl+L` – Verdent-Panel öffnen/fokussieren
* Befehl: `verdent.addToChat`
* Funktioniert über die Befehlspalette und den Editor-Kontext
Dies ist das wichtigste Tastenkürzel, um von überall in VS Code schnell auf Verdent zuzugreifen, ohne Ihren Coding-Flow zu unterbrechen.
**Weitere Befehle:**
Verfügbar über die Befehlspalette (Standardtastenkürzel können angepasst werden):
* `verdent.addFeedBack` – Feedback geben
* `verdent.addTerminalOutputToChat` – Terminalausgabe zu Verdent hinzufügen
* `verdent.addToChatBySearch` – Per Suche zu Verdent hinzufügen
* `verdent.centerButtonClicked` – Benutzerzentrum
* `verdent.historyButtonClicked` – Projektverlauf
* `verdent.mcpButtonClicked` – MCP-Server hinzufügen
* `verdent.openInNewTabByParams` – In neuem Tab öffnen
* `verdent.plusButtonClicked` – Neue Sitzung
* `verdent.rulesButtonClicked` – Regeleinstellungen
* `verdent.SettingClicked` – Einstellungsmenü
* `verdent.subagentButtonClicked` – Subagent hinzufügen
### Tastenkürzel anpassen [#tastenkürzel-anpassen]
Alle Tastaturkürzel von Verdent können über das Standard-Keybinding-System von VS Code angepasst werden.
Für die meisten Nutzer empfohlen – visuelle Oberfläche zur Verwaltung von Tastenkürzeln.
Drücken Sie `Cmd+K Cmd+S` (macOS) oder `Ctrl+K Ctrl+S` (Windows/Linux)
Geben Sie „Verdent“ in das Suchfeld ein, um Verdent-Befehle zu filtern
Klicken Sie auf das Stiftsymbol neben einem Befehl, drücken Sie die gewünschte Tastenkombination und drücken Sie die Eingabetaste, um zu speichern
Für erfahrene Nutzer – direkte JSON-Konfiguration, versionskontrollfreundlich.
Drücken Sie `Cmd+Shift+P` (macOS) oder `Ctrl+Shift+P` (Windows/Linux)
Geben Sie „Preferences: Open Keyboard Shortcuts (JSON)“ ein und wählen Sie es aus
```json macOS
{
"key": "cmd+shift+v",
"command": "verdent.addToChat"
}
```
```json Windows/Linux
{
"key": "ctrl+shift+v",
"command": "verdent.addToChat"
}
```
**Anpassungsumfang:**
* Alle Verdent-Befehle können neu zugewiesen werden
* Mehrere Tastenkürzel können demselben Befehl zugewiesen werden
* Standardtastenkürzel können entfernt werden
* Änderungen werden über VS Code Settings Sync auf mehreren Rechnern synchronisiert
### Plattformspezifische Tastenkürzel [#plattformspezifische-tastenkürzel]
Verdent folgt den plattformspezifischen Tastaturkonventionen von VS Code:
| Plattform | Muster der Modifikatortaste |
| ----------------- | -------------------------------------------------------- |
| **macOS** | `Cmd` für primäre Tastenkürzel, `Option` für alternative |
| **Windows/Linux** | `Ctrl` für primäre Tastenkürzel, `Alt` für alternative |
**Häufige Muster:**
* Einstellungen: `Cmd+,` (macOS) vs. `Ctrl+,` (Windows/Linux)
* Befehlspalette: `Cmd+Shift+P` (macOS) vs. `Ctrl+Shift+P` (Windows/Linux)
* Tastaturkürzel: `Cmd+K Cmd+S` (macOS) vs. `Ctrl+K Ctrl+S` (Windows/Linux)
***
## Benutzerdefinierte Anweisungen & Personas [#benutzerdefinierte-anweisungen--personas]
Verdent for VS Code unterstützt zwei Systeme zur Anpassung des KI-Verhaltens: **Regeln** für Präferenzen und Richtlinien sowie **Subagenten** für spezialisierte Aufgabenpersonas.
### Regelsystem [#regelsystem]
Regeln definieren, wie sich Verdent während Coding-Sitzungen verhält und reagiert. Regeln werden in Markdown-Dateien gespeichert und durchgängig in Unterhaltungen angewendet.
#### Drei Arten von Regeln [#drei-arten-von-regeln]
**1. Benutzerregeln (VERDENT.md):**
* **Speicherort:** `~/.verdent/` (globales Konfigurationsverzeichnis)
* **Umfang:** Wird auf alle Unterhaltungen in allen Projekten angewendet
* **Zweck:** Persönliche Coding-Präferenzen, Kommunikationsstil, Dokumentationsstandards
**2. Projektregeln (AGENTS.md):**
* **Speicherort:** Projektstammverzeichnis oder Arbeitsbereich
* **Umfang:** Wird nur auf das aktuelle Projekt angewendet
* **Versionskontrolle:** Kann für teamweite Standards in Git committet werden
* **Zweck:** Projektspezifische Coding-Standards, architektonische Muster, Testanforderungen
**3. Plan-Regeln (plan\_rules.md):**
* **Speicherort:** `~/.verdent/` (globales Konfigurationsverzeichnis)
* **Umfang:** Wird bei Verwendung von Plan Mode in allen Projekten angewendet
* **Zweck:** Anpassung von Planinhalt, -format und Detailgrad
#### Regeln erstellen und bearbeiten [#regeln-erstellen-und-bearbeiten]
Klicken Sie auf die Schaltfläche **Einstellungen** in der oberen Leiste von Verdent und wählen Sie **Regeln** aus dem Dropdown-Menü
Wählen Sie je nach Bedarf **Benutzerregeln**, **Projektregeln** oder **Plan-Regeln**
Regeldateien öffnen sich im VS Code-Editor. Verwenden Sie Markdown-Formatierung, um klare, direktive Anweisungen zu schreiben
Speichern Sie die Datei. Regeln werden sofort in aktuellen und zukünftigen Sitzungen angewendet – kein Neustart erforderlich
**Beispiel für Benutzerregeln:**
```markdown
# Code Style Preferences
- Always use functional React components with hooks
- Prefer TypeScript over JavaScript
- Add JSDoc comments for all exported functions
- Provide explanations before showing code
```
**Beispiel für Projektregeln:**
```markdown
## Testing instructions
- Run `pnpm turbo run test --filter ` to run all checks
- Fix test and type errors until suite is green
- Add or update tests for code changes
## PR instructions
- Title format: []
- Always run `pnpm lint` and `pnpm test` before committing
```
#### Speicherung und Anwendung von Regeln [#speicherung-und-anwendung-von-regeln]
| Regeltyp | Speicherort | Umfang | Versionskontrolle |
| -------------- | -------------------------- | ------------------------- | ---------------------------------------- |
| Benutzerregeln | `~/.verdent/VERDENT.md` | Alle Projekte | Persönlich, nicht geteilt |
| Projektregeln | `<project>/AGENTS.md` | Aktuelles Projekt | Kann für Teamkonsistenz committet werden |
| Plan-Regeln | `~/.verdent/plan_rules.md` | Alle Projekte (Plan Mode) | Persönlich, nicht geteilt |
**Konfigurationspriorität:**
Bei widersprüchlichen Regeln wendet Verdent folgende Reihenfolge an:
1. **Projektregeln (AGENTS.md)** – Höchste Priorität (projektspezifisch)
2. **Benutzerregeln (VERDENT.md)** – Globale Benutzerpräferenzen
3. **Standardverhalten** – Die integrierten Standardeinstellungen von Verdent
<Tip>
Committen Sie AGENTS.md in die Versionskontrolle, um projektspezifische Coding-Standards mit Ihrem gesamten Team zu teilen. Der Arbeitsbereich jedes Teammitglieds folgt automatisch den Projektregeln und behält gleichzeitig individuelle Präferenzen über VERDENT.md bei.
</Tip>
***
## Subagenten [#subagenten]
Subagenten sind spezialisierte KI-Agenten mit benutzerdefinierten Systemprompts und isolierten Kontextfenstern zur Bearbeitung bestimmter Aufgaben.
### Integrierte Subagenten [#integrierte-subagenten]
Verdent enthält drei standardmäßige Subagenten, die ohne Konfiguration sofort verfügbar sind:
<Tabs>
<Tab title="@Verifier">
* Schnelle Codeprüfungen und Verifizierung
* Schnelle Validierung ohne vollständige Review
* Einsatz für: schnelle Plausibilitätsprüfungen, Syntaxvalidierung, Pre-Commit-Checks
</Tab>
<Tab title="@Explorer">
* Schnelle Erkundung und Navigation der Codebasis
* Findet Dateien schnell und beantwortet Fragen zur Codebasis
* Einsatz für: Erkunden unbekannter Codebasen, Finden von Komponenten, Verstehen der Struktur
</Tab>
<Tab title="@Code-reviewer">
* Sofortige Bewertung der Codequalität
* Erkennt Probleme in Bezug auf Sicherheit, Wartbarkeit und Performance
* Einsatz für: Pre-Commit-Reviews, Sicherheitsaudits, Performance-Optimierung
</Tab>
</Tabs>
### Benutzerdefinierte Subagenten erstellen [#benutzerdefinierte-subagenten-erstellen]
<Steps>
<Step title="Subagent-Einstellungen aufrufen">
Klicken Sie auf **Einstellungen** → **Subagenten** in der oberen Leiste von Verdent
</Step>
<Step title="Neuen Subagenten erstellen">
Erstellen Sie einen neuen Subagenten oder navigieren Sie zu `~/.verdent/subagents/` und erstellen Sie eine Markdown-Datei mit YAML-Frontmatter
</Step>
<Step title="Verhalten des Subagenten definieren">
Schreiben Sie einen Systemprompt, der die Persönlichkeit, den Interpretationsstil und den Umgang des Subagenten mit Aufgaben festlegt
</Step>
<Step title="Aufrufrichtlinie festlegen">
Definieren Sie, wann der Subagent verwendet werden soll (strikte oder flexible Aufrufregel)
</Step>
</Steps>
**Dateiformat für Subagenten:**
```markdown
---
name: security-reviewer
description: Security-focused code review specialist
---
# System Prompt
You are a security-focused code reviewer. When analyzing code:
- Prioritize security vulnerabilities (SQL injection, XSS, auth flaws)
- Use skeptical, critical tone - assume code is vulnerable until proven otherwise
- Provide specific remediation steps with code examples
- Reference OWASP Top 10 and security best practices
- Never approve code with unresolved security issues
Invocation policy (strict): Only run security-reviewer if user explicitly requests it.
When to use the security-reviewer agent:
- User requests security review of authentication/authorization logic
- User asks to audit code for vulnerabilities
- User needs security assessment before deployment
When NOT to use:
- General code review without security focus
- Opening or reading files without analysis
```
### Subagenten verwalten [#subagenten-verwalten]
Zugriff über **Einstellungen → Subagenten** für Folgendes:
* **Bearbeiten:** Systemprompts, Werkzeugberechtigungen, Konfigurationen ändern
* **Kopieren:** Subagenten für Varianten oder Vorlagen duplizieren
* **Löschen:** Nicht verwendete Subagenten entfernen
* **Aktivieren/Deaktivieren:** Verfügbarkeit umschalten, ohne zu löschen
### Subagenten verwenden [#subagenten-verwenden]
**Integrierte Subagenten:**
* Mit @-Erwähnungen referenzieren: `@Verifier`, `@Explorer`, `@Code-reviewer`
* Werden automatisch aufgerufen, wenn passende Aufgabentypen erkannt werden
**Benutzerdefinierte Subagenten:**
* Klicken Sie auf die Schaltfläche **Subagent hinzufügen** im Eingabefeld
* Wählen Sie aus dem Dropdown-Menü
* Der Hauptagent delegiert passende Aufgaben automatisch
### Subagent vs. Regeln [#subagent-vs-regeln]
| Aspekt | Regeln | Subagenten |
| ------------------- | ------------------------------- | ----------------------------------------- |
| **Wann angewendet** | Durchgängig, bei jeder Antwort | Bei Bedarf für bestimmte Aufgaben |
| **Kontext** | Gemeinsames Hauptkontextfenster | Isolierter, separater Kontext |
| **Verhalten** | Präferenzen und Richtlinien | Aufgabenspezifische Verhaltenspersonas |
| **Aufruf** | Immer aktiv | Automatische oder manuelle Delegation |
| **Zweck** | Definiert, WAS Sie bevorzugen | Definiert, WER Aufgaben übernimmt und WIE |
**Beispiel-Workflow:**
1. **Benutzerregel:** „Erstelle Unit-Tests für alle neuen Funktionen“
2. **Hauptagent:** Erkennt den Bedarf an Testerstellung
3. **Delegiert an den Test-Generator-Subagenten:** Spezialisierter, umfassender Testansatz
4. **Subagent:** Erstellt eine vollständige Testsuite mit isoliertem Kontext
5. **Hauptagent:** Erhält die Ergebnisse und fährt fort, ohne den Kontext zu belasten
<Tip>
Teilen Sie Subagenten mit Teammitgliedern über die Schaltfläche **Kopieren** unter Einstellungen → Subagenten, oder indem Sie Subagent-Markdown-Dateien direkt aus `~/.verdent/subagents/` teilen.
</Tip>
***
## FAQs (Häufig gestellte Fragen) [#faqs-häufig-gestellte-fragen]
<Accordion title="Wann werden Konfigurationsänderungen wirksam?">
Die meisten Einstellungen von Verdent werden sofort wirksam, ohne dass ein Neustart erforderlich ist:
* **Berechtigungsmodi:** Sofortiges Umschalten über das Eingabefeld
* **Modellvoreinstellungen:** Werden auf die nächste Anfrage angewendet
* **Regeldateien:** Werden auf neue Unterhaltungen angewendet (Speichern löst ein Reload aus)
* **Subagenten:** Sofort nach der Erstellung verfügbar
* **Tastaturkürzel:** Werden nach dem Speichern in VS Code angewendet
**Ausnahme:** Erweiterungseinstellungen von VS Code (wie `verdent.enableCheckpoints`) werden sofort wirksam, erfordern aber möglicherweise das erneute Öffnen von Dateien oder Sitzungen, um vollständig angewendet zu werden.
</Accordion>
<Accordion title="Was ist der Unterschied zwischen Regeln und Subagenten?">
**Regeln** definieren, WAS Sie global bevorzugen:
* Durchgängige Anwendung auf alle Unterhaltungen
* Coding-Standards, Kommunikationsstil, Präferenzen
* Gespeichert in Markdown-Dateien (VERDENT.md, AGENTS.md, plan\_rules.md)
* Immer im Hintergrund aktiv
**Subagenten** definieren, WER bestimmte Aufgaben übernimmt und WIE:
* Aufruf bei Bedarf für bestimmte Aufgabentypen
* Spezialisierte Verhaltenspersonas mit benutzerdefinierten Systemprompts
* Isolierte Kontextfenster (belasten nicht den Hauptkontext)
* Automatisch oder manuell über @-Erwähnungen delegiert
**Beispiel:** Eine Regel besagt: „Erstelle Unit-Tests für neue Funktionen.“ Ein Test-Generator-Subagent übernimmt die tatsächliche Testerstellung mit einer umfassenden Testmethodik.
</Accordion>
<Accordion title="Kann ich mehrere Berechtigungsmodi gleichzeitig verwenden?">
Nein, Berechtigungsmodi schließen sich gegenseitig aus – Sie können immer nur EINEN gleichzeitig verwenden:
* **Manuelle Bestätigung** – Standard, maximale Kontrolle
* **Auto-Run** – Optimiert für vertrauenswürdige Projekte
* **Plan** – Nur lesender Planungsmodus
* **Berechtigungen überspringen** – Vollständige Autonomie
Sie können Modi sofort über die Schaltfläche **Berechtigung wechseln** im Eingabefeld umschalten. Die meisten Nutzer wechseln je nach Aufgabenkontext zwischen den Modi (z. B. Plan Mode für komplexe Features, Auto-Run für schnelle Fixes).
</Accordion>
<Accordion title="Wie wähle ich die richtige Modellvoreinstellung für meine Aufgabe?">
Passen Sie die Modellvoreinstellung an die Aufgabenkomplexität und das Budget an:
**Efficiency verwenden (3,2-mal effizienter als Sonnet):**
* Schnelle Fehlerbehebungen und einfache Codegenerierung
* Routineoperationen und häufig wiederkehrende Aufgaben
* Wenn Geschwindigkeit wichtiger ist als Tiefe
**Balance verwenden (1-fache Basislinie) – Standard:**
* Allgemeine Entwicklung und alltägliches Coding
* Feature-Implementierung und Code-Reviews
* Ausgewogene Leistung für die meisten Szenarien
**Performance verwenden (0,5-fache Effizienz, 2-fache Kosten):**
* Komplexe architektonische Entscheidungen
* Große Codebasen, die umfangreichen Kontext benötigen (200.000+ Token)
* Anspruchsvolles Debugging und Refactoring
**Profi-Tipp:** Die meisten Nutzer behalten Balance als Standard bei und wechseln nur zu Performance, wenn sie an Kontextgrenzen stoßen oder tiefgehendes Reasoning benötigen.
</Accordion>
***
## Siehe auch [#siehe-auch]
<CardGroup cols="2">
<Card title="Plan-First-Workflows" icon="sitemap" href="/docs/verdent-for-vscode/configuration/plan-workflows">
Konfigurieren Sie KI-gestützte Aufgabenplanung und Freigabe-Workflows
</Card>
<Card title="Konfigurationsoptimierung" icon="sliders" href="/docs/verdent-for-vscode/configuration/tuning">
Optimieren Sie Einstellungen für Geschwindigkeit, Kosten und Performance
</Card>
</CardGroup>