Claude Code Workflows optimieren: Tipps & Tricks

TL;DR

Optimieren Sie Claude Code-Workflows durch die Verwendung von Klartext-Sitzungsverwaltung, strategischen Prompt-Strukturen und integrierten API-Testwerkzeugen. Zu den wichtigsten Taktiken gehören das Aufteilen von Aufgaben in fokussierte Unteraufgaben, das Aufrechterhalten des Kontexts mit .clinerules-Dateien und die sofortige Validierung des generierten Codes mit Tools wie Apidog. Teams berichten von 40-60 % schnelleren Entwicklungszyklen, wenn diese Ansätze kombiniert werden.

Einleitung

Sie starten eine Claude Code-Sitzung, um einen neuen API-Endpunkt zu erstellen. Drei Stunden später wechseln Sie immer noch ständig zwischen Ihrem Terminal, dem API-Client und der Dokumentation. Der Code funktioniert, aber der Prozess fühlte sich zerstreut an.

Claude Code hat die Arbeitsweise von Entwicklern verändert. Es schreibt Code, debuggt Probleme und erklärt komplexe Muster. Aber reine Fähigkeiten bedeuten nicht gleich Produktivität. Der Unterschied zwischen einer frustrierenden Sitzung und einem Flow-Zustand liegt im Workflow-Design.

Dieser Leitfaden behandelt bewährte Ansätze zur Optimierung von Claude Code-Workflows. Sie lernen Strategien zur Sitzungsverwaltung, Prompt-Muster, die den Token-Verbrauch reduzieren, und wie Sie API-Tests direkt in Ihren Workflow integrieren. Wir behandeln Tools wie Cog für Klartext-Architekturen und zeigen Ihnen, wie Sie generierten Code validieren, ohne Ihr Terminal zu verlassen.

Am Ende verfügen Sie über ein wiederholbares System für schnellere, konzentriertere Codierungssitzungen. Erwarten Sie, die Iterationszeit zu halbieren und den mentalen Aufwand zu reduzieren, der mit langen KI-unterstützten Entwicklungssitzungen einhergeht.

Das Problem: Warum sich Claude Code-Sitzungen zerstreut anfühlen

Kontextwechsel tötet den Flow

Entwickler verlieren 23 Minuten, um nach jeder Unterbrechung den Fokus wiederzufinden. Claude Code-Sitzungen schaffen einzigartige Herausforderungen beim Kontextwechsel:

• Tool-Fragmentierung: Wechseln zwischen Terminal, Browser, API-Client und Dokumentation
• Token-Angst: Sorge um die Grenzen des Kontextfensters mitten in der Aufgabe
• Prompt-Iteration: Mehrfaches Umschreiben derselben Anfrage
• Validierungslücken: Generieren von Code ohne sofortige Tests

Die versteckten Kosten eines schlechten Workflow-Designs

Ein schlechtes Workflow-Design führt zu einem unsichtbaren Produktivitätsverlust. Sie erledigen die Aufgabe, fühlen sich aber erschöpft. Der Code funktioniert, erforderte aber mehr Iterationen als erwartet.

Häufige Schwachstellen sind:

Ein Entwickler, der wöchentlich 4-5 Claude Code-Sitzungen durchführt, verliert monatlich 5-10 Stunden durch Workflow-Reibungsverluste.

Warum Standard-Workflows zu kurz greifen

Claude Code funktioniert für einfache Aufgaben gut. Komplexe Projekte decken Lücken auf:

1. Keine integrierte Sitzungspersistenz: Lange Projekte verlieren den Kontext über Neustarts hinweg
2. Generische Prompts erzeugen generischen Code: Ohne Struktur fehlt den Ausgaben die Spezifität
3. Tests erfolgen nach dem Codieren: Die Validierung wird zu einer separaten Phase statt zu integriertem Feedback
4. Keine API-Testintegration: Backend-Entwickler müssen Endpunkte ständig validieren

Kernkonzepte: Bausteine optimierter Workflows

Klartext-Sitzungsverwaltung

Die Klartext-Sitzungsverwaltung speichert den Kontext in lesbaren Dateien. Tools wie Cog zeigen, dass dieser Ansatz funktioniert. Anstatt sich allein auf Claudes Gedächtnis zu verlassen, pflegen Sie:

• Sitzungsziele in Markdown-Dateien
• Entscheidungs-Logs für wichtige Entscheidungen
• API-Spezifikationen als Referenz
• Testfälle als lebendige Dokumentation

Warum Klartext funktioniert:

• Dateien bleiben über Sitzungen hinweg erhalten
• Leicht zu durchsuchen und zu referenzieren
• Versionskontrollfreundlich
• Reduziert den Token-Verbrauch durch Bereitstellung von fokussiertem Kontext

Strategisches Prompt Engineering

Prompt Engineering für Claude Code unterscheidet sich von Chat-basierten Prompts. Sie bitten nicht um Erklärungen; Sie steuern die Codegenerierung.

Effektive Prompt-Struktur:

KONTEXT: [Was bereits existiert]
ZIEL: [Spezifisches Ergebnis]
BESCHRÄNKUNGEN: [Technische Anforderungen]
AUSGABE: [Erwartetes Format]

Beispiel:

CONTEXT: Building a REST API for user authentication with FastAPI
GOAL: Create a POST /login endpoint that validates credentials and returns JWT
CONSTRAINTS: Use Pydantic for validation, bcrypt for password hashing, 200ms response time target
OUTPUT: Complete endpoint code with error handling and type hints

Optimierung der Token-Nutzung

Das Kontextfenster von Claude Code ist groß, aber nicht unendlich. Eine strategische Token-Nutzung verlängert die Sitzungsdauer und reduziert die Kosten.

Token-sparende Taktiken:

• Dateien referenzieren statt Inhalte einzufügen
• .clinerules für dauerhafte Anweisungen verwenden
• Große Aufgaben in fokussierte Unteraufgaben zerlegen
• Irrelevanten Kontext zwischen größeren Aufgabenwechseln löschen

Umfassende Lösung: Einrichten Ihres optimierten Workflows

Schritt 1: Projektstruktur für KI-unterstützte Entwicklung

Organisieren Sie Ihr Projekt, um Claude Code-Workflows zu unterstützen:

my-project/
├── .clinerules           # Persistent instructions for Claude
├── .claude/              # Claude Code configuration
├── docs/
│   ├── api-spec.md       # API specification reference
│   └── decisions/        # Architecture decision records
├── src/
├── tests/
│   └── api/              # API test definitions
└── workflows/
    └── session-notes.md  # Active session tracking

Schritt 2: .clinerules für konsistente Ausgabe konfigurieren

Die .clinerules-Datei enthält dauerhafte Anweisungen für alle Sitzungen. Verwenden Sie sie, um:

• Codierungsstandards festzulegen
• Testanforderungen zu definieren
• API-Test-Workflows festzulegen
• Ausgabeformate zu etablieren

Beispiel .clinerules:

# Coding Standards
- Use type hints for all Python functions
- Write docstrings for public methods
- Follow PEP 8 style guidelines

# Testing Requirements
- Generate unit tests with each new function
- Include API integration tests for endpoints
- Use Apidog for API validation workflows

# Output Format
- Show complete files, not partial snippets
- Include error handling in all production code
- Add comments for non-obvious logic

Schritt 3: API-Tests in Ihren Workflow integrieren

API-Tests sollten nicht nach dem Codieren erfolgen. Sie sollten die Entwicklung vorantreiben. So integrieren Sie sie:

Vor der Codegenerierung:

1. Definieren Sie das erwartete API-Verhalten in Klartext
2. Erstellen Sie Testfälle in Ihrem API-Testtool
3. Teilen Sie die Spezifikation mit Claude Code

Während der Entwicklung:

1. Endpunkt-Code generieren
2. Sofort mit Apidog testen
3. Testergebnisse zur Behebung an Claude Code zurückgeben

Nach der Validierung:

1. Bestehende Tests als Regressionstest-Suite speichern
2. Entdeckte Edge-Cases dokumentieren
3. API-Spezifikation mit finalem Verhalten aktualisieren

Diese Schleife hält die Validierung eng und reduziert das Problem „Es funktionierte im generierten Code, schlägt aber in der Produktion fehl“.

Detailliertes Beispiel: Erstellen eines Authentifizierungs-Endpunkts mit integrierten Tests

Hier ist ein vollständiger Workflow, der zeigt, wie API-Tests mit Claude Code integriert werden:

Schritt 1: Definieren Sie die API-Spezifikation

Erstellen Sie eine Datei api-spec.md:

## POST /api/v1/auth/login

Request:
```json
{
  "email": "user@example.com",
  "password": "securepassword123"
}

Response (200 OK):

{
  "access_token": "eyJhbGc...",
  "token_type": "Bearer",
  "expires_in": 3600
}

Response (401 Unauthorized):

{
  "error": "invalid_credentials",
  "message": "Email or password is incorrect"
}

**Schritt 2: Spezifikation mit Claude Code teilen**

@api-spec.md Create a FastAPI endpoint for POST /api/v1/auth/login that matches this specification. Include password hashing with bcrypt and JWT token generation.

**Schritt 3: Sofort mit Apidog testen**

Sobald Claude den Code generiert hat, starten Sie den Server noch nicht. Erstellen Sie zuerst den Testfall in Apidog:

- Importieren Sie die API-Spezifikation
- Richten Sie Testumgebungen ein (Lokal, Staging)
- Erstellen Sie Test-Assertions für das Antwortschema und die Statuscodes

**Schritt 4: Tests ausführen und iterieren**

Starten Sie Ihren Server und führen Sie die Apidog-Testsuite aus. Wenn Tests fehlschlagen:

@auth.py The login endpoint returns 500 instead of 200. Here’s the error log: [paste error]. Fix the issue and explain what went wrong.

Dieser Workflow fängt Probleme ab, bevor sie sich potenzieren. Sie erstellen keine manuellen curl-Befehle und wechseln nicht zwischen Tools. Die Testsuite wird zu einer lebendigen Dokumentation.

### Schritt 4: Cog oder ähnliche Tools für die Sitzungspersistenz verwenden

Cog (Klartext-Kognitive-Architektur) demonstriert die Leistungsfähigkeit von externalisiertem Kontext. Richten Sie ein ähnliches Tracking ein:

```markdown
# Sitzung: 27.03.2026 API-Endpunkt-Entwicklung

## Ziele
- [x] Benutzerauthentifizierungs-Endpunkt erstellen
- [ ] Ratenbegrenzung hinzufügen
- [ ] JWT-Refresh-Logik implementieren

## Getroffene Entscheidungen
- HS256 für JWT-Signatur verwenden (einfacher als RS256 für die aktuelle Skalierung)
- Ratenbegrenzung auf 100 Anfragen/Minute pro IP

## Offene Fragen
- Passwort-Reset-Flow muss entschieden werden
- OAuth2-Anbieter hinzufügen in Betracht ziehen

Diese Datei begleitet Ihr Projekt. Sie können sie während der Sitzung referenzieren, um den Kontext zu erhalten.

Fortgeschrittene Techniken für Power-User

Projektverwaltung über mehrere Sitzungen hinweg

Große Projekte erstrecken sich über mehrere Claude Code-Sitzungen. Bewahren Sie die Kontinuität mit:

1. Sitzungsübergabe-Notizen: Beenden Sie jede Sitzung mit einer Zusammenfassung dessen, was erledigt wurde und was als Nächstes ansteht
2. Checkpoint-Commits: Git-Commits an den Sitzungsgrenzen mit aussagekräftigen Nachrichten
3. Entscheidungs-Logs: Halten Sie fest, warum Sie wichtige Architektur-Entscheidungen getroffen haben

Prompt-Muster für komplexe Aufgaben

Das Dekompositionsmuster:

Teilen Sie große Anfragen in kleinere, sequentielle Prompts auf:

Prompt 1: "Analyze this codebase and identify where authentication should be added"
Prompt 2: "Generate a plan for implementing JWT authentication"
Prompt 3: "Implement the token generation function from the plan"
Prompt 4: "Write tests for the token generation function"
Prompt 5: "Integrate token generation into the login endpoint"

Das iterative Verfeinerungsmuster:

Beginnen Sie breit, dann enger:

Prompt 1: "Generate a basic CRUD API for posts"
Prompt 2: "Add input validation using Pydantic"
Prompt 3: "Optimize database queries for the list endpoint"
Prompt 4: "Add pagination with cursor-based navigation"

Reduzierung des Token-Verbrauchs in langen Sitzungen

Überwachen und reduzieren Sie den Token-Verbrauch:

• Verwenden Sie @file-Referenzen anstatt Inhalte einzufügen
• Fassen Sie den vorherigen Kontext zusammen, anstatt die gesamte Historie einzubeziehen
• Löschen Sie den Kontext abgeschlossener Aufgaben zwischen größeren Aufgabenwechseln
• Referenzdokumente extern speichern und verlinken

Integration mit CI/CD-Pipelines

Claude Code kann CI/CD-Konfigurationen generieren. Validieren Sie diese vor dem Mergen:

1. Workflow-Dateien generieren (GitHub Actions, GitLab CI)
2. Lokal mit act oder ähnlichen Tools testen
3. API-Endpunkte in der Pipeline mit Apidog validieren
4. Erst committen, nachdem die Pipeline lokal bestanden wurde

Messung der Workflow-Effizienz

Verfolgen Sie Metriken, um Engpässe in Ihrem Claude Code-Workflow zu identifizieren:

Wie man verfolgt:

• Führen Sie ein einfaches Protokoll in Ihrer Sitzungsnotizen-Datei
• Notieren Sie, wann Sie Tools wechseln oder Prompts umschreiben
• Messen Sie die Zeit Ihrer Validierungsschleifen
• Wöchentlich überprüfen, um Muster zu erkennen

Ein Team, mit dem wir zusammenarbeiteten, verfolgte diese Metriken einen Monat lang. Sie stellten fest, dass Prompt-Iterationen ihr größter Zeitfresser waren. Nach der Einführung der KONTEXT-ZIEL-BESCHRÄNKUNGEN-AUSGABE-Struktur sanken die Iterationen von 3,2 auf 1,4 pro Aufgabe.

Fehlerbehebung bei häufigen Workflow-Problemen

Problem: Claude verliert während der Sitzung den Kontext

Symptome: Claude referenziert nicht existierende Dateien, vergisst frühere Entscheidungen oder generiert Code, der früheren Ausgaben widerspricht.

Ursachen:

• Kontextfenster füllt sich mit Konversationshistorie
• Vage Dateireferenzen ohne Pfade
• Keine persistente Regeldatei

Lösungen:

1. Verwenden Sie .clinerules für persistenten Kontext – Kritische Anweisungen überleben Sitzungsneustarts
2. Referenzieren Sie Dateien explizit – Verwenden Sie @src/auth.py statt „der auth-Datei“
3. Fassen Sie vor größeren Aufgaben zusammen – „Zusammenfassung: Wir haben X gebaut, jetzt bauen wir Y mit Z Beschränkungen“
4. Starten Sie neu, wenn Sie feststecken – Manchmal ist eine neue Sitzung mit einer Zusammenfassung besser, als gegen einen verwirrten Kontext anzukämpfen

Problem: Generierter Code stimmt nicht mit der API-Spezifikation überein

Symptome: Endpunkt-Signaturen stimmen nicht mit Ihrem Design überein, Antwortformate sind falsch oder die Validierungslogik fehlt.

Ursachen:

• Spezifikation nicht mit Claude geteilt
• Mehrdeutige Anforderungen in Prompts
• Kein sofortiger Validierungsschritt

Lösungen:

1. Teilen Sie zuerst die Spezifikation – @api-spec.md Überprüfen Sie diese Spezifikation und bestätigen Sie dann Ihr Verständnis, bevor Sie Code generiert wird
2. Fügen Sie explizite Beschränkungen hinzu – „Die Antwort muss diesem genauen JSON-Schema entsprechen“
3. Sofort validieren – Verwenden Sie Apidog, um gegen die Spezifikation zu testen, bevor Sie den Code als vollständig betrachten
4. Erstellen Sie testgetriebene Prompts – „Generieren Sie Code, der diese Testfälle besteht: [Link zu Tests]“

Problem: Sitzungen dauern länger als erwartet

Symptome: Einfache Aufgaben dehnen sich zu stundenlangen Sitzungen aus. Sie erledigen manuelle Arbeit, die Claude erledigen sollte.

Ursachen:

• Unklare Ziele zu Sitzungsbeginn
• Kein Bruchpunkt für komplexe Aufgaben
• Debugging ohne strukturierte Fehlerinformationen

Lösungen:

1. Schreiben Sie die Sitzungsziele im Voraus auf – „Heute: Login-Endpunkt erstellen, Tests schreiben, mit Apidog validieren“
2. Zeitbeschränken Sie komplexe Aufgaben – „Verbringen Sie 15 Minuten mit X, dann neu bewerten“
3. Teilen Sie den vollständigen Fehlerkontext – Fügen Sie vollständige Fehlermeldungen mit Stack-Traces ein
4. Wissen Sie, wann Sie neu starten müssen – Wenn Sie denselben Prompt zweimal umgeschrieben haben, starten Sie frisch mit mehr Kontext

Problem: Token-Verbrauch steigt unerwartet an

Symptome: Sitzungen erreichen Kontextgrenzen schneller als erwartet. Kosten steigen ohne ersichtlichen Grund.

Ursachen:

• Einfügen großer Dateien anstatt sie zu referenzieren
• Einschließen der vollständigen Konversationshistorie in Prompts
• Kontext abgeschlossener Aufgaben nicht löschen

Lösungen:

1. Verwenden Sie @file-Referenzen – Claude liest Dateien, ohne Kontext für das Einfügen zu verbrauchen
2. Zusammenfassen statt zitieren – „Wie wir im Auth-Bereich besprochen haben“ vs. erneutes Einfügen der Diskussion
3. Abgeschlossene Arbeit archivieren – Fertige Abschnitte in eine separate Datei verschieben und diese referenzieren
4. Token-Verbrauch überwachen – Einige Claude Code-Oberflächen zeigen Token-Anzahlen an; achten Sie auf Spitzen

Problem: Teammitglieder erhalten inkonsistente Ergebnisse

Symptome: Verschiedene Teammitglieder, die Claude Code verwenden, produzieren Code mit unterschiedlichen Stilen, Mustern oder Qualitätsstufen.

Ursachen:

• Keine gemeinsame .clinerules-Datei
• Individuelle Prompt-Stile variieren stark
• Kein Code-Review-Prozess für KI-generierten Code

Lösungen:

1. Erstellen Sie teamweite .clinerules – Standardisieren Sie Codierungskonventionen, Testanforderungen und Ausgabeformate
2. Erstellen Sie eine Prompt-Bibliothek – Teilen Sie Prompts, die für gängige Aufgaben gut funktionieren
3. Überprüfen Sie KI-Code wie menschlichen Code – Derselbe PR-Prozess, dieselben Standards
4. Dokumentieren Sie Workflow-Erwartungen – Wann Claude Code verwendet werden soll, was menschliche Überprüfung erfordert, wie API-Tests zu handhaben sind

Anwendungsfälle aus der Praxis

Backend-Team erstellt Microservices

Ein Fintech-Team, das Zahlungs-Microservices entwickelte, setzte Claude Code mit integrierten API-Tests ein. Sie:

• Zuerst OpenAPI-Spezifikationen definiert
• Server-Stubs mit Claude Code generiert
• Jeden Endpunkt während der Entwicklung mit Apidog validiert
• Integrationsfehler um 60% reduziert

Wichtige Erkenntnis: Tests während der Generierung deckten Probleme auf, bevor sie sich potenziert haben.

Solo-Entwickler liefert schneller

Ein Indie-Entwickler, der ein SaaS-Produkt entwickelte, kombinierte Claude Code mit Klartext-Sitzungsverwaltung:

• Verwendete Cog-ähnliches Tracking für den Feature-Fortschritt
• Entscheidungs-Logs für zukünftige Referenz gepflegt
• API-Tests in jede Entwicklungssitzung integriert
• 3x schneller geliefert als bei früheren Projekten

Wichtige Erkenntnis: Externalisierter Kontext reduzierte den mentalen Aufwand beim Tracking mehrerer Features.

DevOps-Team automatisiert Infrastruktur

Ein DevOps-Team nutzte Claude Code, um Terraform-Konfigurationen zu generieren:

• .clinerules mit Unternehmensstandards erstellt
• Infrastruktur-Code mit integrierter Validierung generiert
• Bereitstellungen im Staging vor der Produktion getestet
• Alle Entscheidungen in Markdown-Dateien dokumentiert

Wichtige Erkenntnis: Konsistente Prompts erzeugten konsistenten, überprüfbaren Infrastruktur-Code.

Alternativen und Vergleiche

Claude Code vs. andere KI-Codierungstools

Claude Code brilliert bei komplexen, mehrstufigen Aufgaben. Verwenden Sie es für Architektur-Entscheidungen, API-Design und Integrationsarbeiten.

Klartext-Tools vs. spezialisierte IDEs

Klartext-Ansätze (Cog, Markdown-Dateien) tauschen Glanz gegen Flexibilität:

• Vorteile: Versionskontrollfreundlich, Tool-agnostisch, durchsuchbar
• Nachteile: Keine Benutzeroberfläche, manuelle Organisation erforderlich

Spezialisierte IDEs (Cursor, Windsurf) bieten integrierte Erlebnisse:

• Vorteile: Automatische Integration, visuelles Feedback
• Nachteile: Herstellerbindung, weniger flexible Workflows

Für Teams, die bereits Claude Code CLI verwenden, lässt sich die Klartext-Sitzungsverwaltung sauber integrieren.

Fazit

Die Optimierung von Claude Code-Workflows basiert auf drei Prinzipien:

1. Kontext externalisieren: Verwenden Sie Klartext-Dateien für die Sitzungsverfolgung, Entscheidungs-Logs und API-Spezifikationen
2. Validierung integrieren: Testen Sie generierten Code sofort mit Tools wie Apidog
3. Prompts strukturieren: Verwenden Sie konsistente Muster zur Zerlegung komplexer Aufgaben

Diese Ansätze reduzieren Kontextwechsel, fangen Fehler früher ab und machen lange Projekte über mehrere Sitzungen hinweg handhabbar.

Häufig gestellte Fragen (FAQ)

Wie verwaltet man am besten lange Claude Code-Sitzungen?

Teilen Sie Sitzungen in fokussierte 30-60-minütige Blöcke mit klaren Zielen auf. Verwenden Sie Klartext-Dateien, um den Fortschritt zwischen den Blöcken zu verfolgen. Committen Sie Code an den Sitzungsgrenzen und pflegen Sie ein Entscheidungs-Log für den Kontext.

Wie reduziere ich den Token-Verbrauch in Claude Code?

Referenzieren Sie Dateien mit @Dateiname anstatt Inhalte einzufügen. Verwenden Sie .clinerules für dauerhafte Anweisungen. Fassen Sie den vorherigen Kontext zusammen, anstatt die gesamte Historie einzubeziehen. Löschen Sie den Kontext abgeschlossener Aufgaben zwischen größeren Aufgabenwechseln.

Kann ich Claude Code für die API-Entwicklung verwenden?

Ja. Claude Code brilliert bei der API-Entwicklung, wenn es mit geeigneten Test-Workflows kombiniert wird. Definieren Sie zuerst Ihre API-Spezifikation, generieren Sie den Code und validieren Sie ihn dann sofort mit einem API-Testtool wie Apidog.

Was sind .clinerules und wie verwende ich sie?

.clinerules ist eine Markdown-Datei, die Claude Code dauerhafte Anweisungen bietet. Verwenden Sie sie, um Codierungsstandards, Testanforderungen und Ausgabeformate festzulegen. Sie gilt für alle Sitzungen in diesem Projekt.

Wie integriere ich Claude Code in meinen bestehenden Workflow?

Fangen Sie klein an: Fügen Sie .clinerules zu einem Projekt hinzu, verwenden Sie Klartext-Sitzungsverfolgung und integrieren Sie API-Tests. Sobald Sie sich wohlfühlen, erweitern Sie auf Projektverwaltung über mehrere Sitzungen und fortgeschrittene Prompt-Muster.

Ist Klartext-Sitzungsverwaltung besser als spezialisierte Tools?

Klartext-Ansätze funktionieren besser für Teams, die bereits Claude Code CLI verwenden. Sie sind versionskontrollfreundlich und tool-agnostisch. Spezialisierte Tools bieten eine bessere UX, führen aber zu Herstellerbindung. Wählen Sie basierend auf dem bestehenden Workflow Ihres Teams.

Welche Prompt-Struktur funktioniert am besten für die Codegenerierung?

Verwenden Sie das Format KONTEXT, ZIEL, BESCHRÄNKUNGEN, AUSGABE. Seien Sie spezifisch bezüglich technischer Anforderungen und des erwarteten Ausgabeformats. Teilen Sie große Aufgaben in sequentielle Prompts auf, anstatt eine massive Anfrage zu stellen.