---
title: Best Practices für das Prompting
url: https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices
description: Umfassender Leitfaden zu Prompt-Engineering-Techniken für Claudes neueste Modelle, der Klarheit, Beispiele, XML-Strukturierung, Nachdenken und agentische Systeme abdeckt.
---

Dies ist die Referenz für „prompt engineering“ (Prompt-Gestaltung) mit aktuellen Claude-Modellen, darunter Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6, Claude Haiku 5.5 und Claude Haiku 4.5. Die Seite ist in drei Teile gegliedert:

* **[Modellspezifische Hinweise](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices#model-specific-guidance)** zuerst: wo sich ein einzelnes Modell anders verhält und was du in deinem Prompt ändern solltest.
* **Techniken für alle aktuellen Modelle** danach: allgemeine Prinzipien, Ausgabe und Formatierung, Tool-Nutzung, Nachdenken und agentische Systeme.
* **Überlegungen zur Migration** zuletzt, für Prompts, die von früheren Generationen übernommen werden.

<Tip>
  Einen Überblick über die Fähigkeiten der Modelle findest du in der [Modellübersicht](https://platform.claude.com/docs/de/models/overview). Zu den Fähigkeiten und API-Änderungen von Claude Fable 5.1 siehe [Was ist neu in Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/whats-new-fable-5-1). Hinweise zur Migration findest du im [Migrationsleitfaden](https://platform.claude.com/docs/de/about-claude/models/migration-guide). Zu Claude Opus 5.5 siehe [Neuerungen in Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/whats-new-opus-5-5). Zu Claude Sonnet 5.5 siehe [Neuerungen in Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/whats-new-sonnet-5-5). Zu Claude Haiku 5.5 siehe [Neuerungen in Claude Haiku 5.5](https://platform.claude.com/docs/de/models/haiku-5-5/whats-new-haiku-5-5).
</Tip>

## Modellspezifische Hinweise

Jedes dieser Modelle hat eine eigene Seite zum Prompting. Lies zuerst die Seite für dein Modell und danach die folgenden Techniken.

| Modell                                 | Leitfaden                                                                                                                               | Was anders ist                                                                                                                                                                                                                                                                                                                                                                              |
| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Claude Fable 5.1 und Claude Mythos 5.1 | [Prompting für Claude Fable 5.1](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1)   | Unterschiede zu Claude Fable 5: Effort-Stufen, Abschließen langer Aufgaben, Fortschrittsmeldungen für Nutzer, unverändertes Zurückgeben von Thinking-Blöcken, Bündeln von Tool-Aufrufen in Agentenschleifen, Auslösen von Suchen bei niedrigem Effort, Formatierung und Schreibdichte.                                                                                                      |
| Claude Fable 5 und Claude Mythos 5     | [Prompting für Claude Fable 5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5)       | Unterschiede zu Claude Opus 4.8: Effort-Stufen, Befolgen von Anweisungen, Fortschrittsangaben bei langen Läufen, Speichersysteme und die Ablehnungskategorie `reasoning_extraction`.                                                                                                                                                                                                        |
| Claude Sonnet 5.5                      | [Prompting für Claude Sonnet 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5) | Unterschiede zu Claude Sonnet 5: Effort-Kalibrierung, Eigeninitiative und Umfang, Ausführung ohne vorgelagertes Nachdenken, JSON-Ausgabe bei Reasoning-Aufgaben, Fortschrittsmeldungen für Nutzer, Tool-Nutzung im Chat, Nutzernachrichten mitten im Turn, Verifizierung bei Coding-Aufgaben, Umgang mit Tool-Aufrufen, komplexe visuelle Eingaben und Ablehnungen durch Schutzmechanismen. |
| Claude Sonnet 5                        | [Prompting für Claude Sonnet 5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5)     | Unterschiede zu Claude Sonnet 4.6: Antwortlänge, Kalibrierung von Effort und Nachdenktiefe, Auslösen der Tool-Nutzung, wörtliches Befolgen von Anweisungen sowie Standardverhalten bei Design und Frontend.                                                                                                                                                                                 |
| Claude Opus 5.5                        | [Prompting für Claude Opus 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5)     | Unterschiede zu Claude Opus 5: Effort-Kalibrierung, Prompts, die für deaktiviertes Nachdenken geschrieben wurden, Fortschrittsmeldungen für Nutzer, Ablehnungen durch Schutzmechanismen und Tools für komplexe visuelle Eingaben.                                                                                                                                                           |
| Claude Opus 5                          | [Prompting für Claude Opus 5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5)         | Unterschiede zu früheren Opus-Modellen: Antwortlänge und Ausführlichkeit, Fortschrittsmeldungen für Nutzer, Länge schriftlicher Ergebnisse, Aufgabenumfang und Überverifizierung, Steuerung von Subagenten und Selbstkorrektur.                                                                                                                                                             |
| Claude Opus 4.8                        | [Prompting für Claude Opus 4.8](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-4-8)     | Antwortlänge, Kalibrierung von Effort und Nachdenktiefe, Auslösen der Tool-Nutzung, wörtliches Befolgen von Anweisungen, Steuerung von Subagenten sowie Standardverhalten bei Design und Frontend.                                                                                                                                                                                          |
| Claude Haiku 5.5                       | [Prompting für Claude Haiku 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5)   | Unterschiede zu Claude Haiku 4.5: Effort-Stufen, Suche, JSON-Ausgabe mit deinen eigenen Tools, vorzeitiges Stoppen in langen Agenten-Prompts, Verifizierung bei Coding-Aufgaben, Nutzernachrichten mitten im Turn, Einhaltung des System-Prompts in Chatbots und Ablehnungen durch Schutzmechanismen.                                                                                       |

## Allgemeine Prinzipien

Die Techniken in diesem Abschnitt und den folgenden Abschnitten gelten für aktuelle Claude-Modelle, einschließlich Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5 und Claude Mythos 5. Wenn eine Technik ein bestimmtes Modell nennt, betrachte sie als an diesem Modell gemessen und überprüfe sie anhand deiner eigenen Evals, bevor du sie auf ein anderes Modell anwendest.

### Sei klar und direkt

Claude reagiert gut auf klare, explizite Anweisungen. Wenn du deine gewünschte Ausgabe konkret beschreibst, kann das die Ergebnisse verbessern. Wenn du ein Verhalten möchtest, das „über das Erwartete hinausgeht“, fordere es ausdrücklich an, anstatt dich darauf zu verlassen, dass das Modell dies aus vagen Prompts ableitet.

Stell dir Claude als brillanten, aber neuen Mitarbeiter vor, dem der Kontext zu deinen Normen und Arbeitsabläufen fehlt. Je präziser du erklärst, was du willst, desto besser das Ergebnis.

**Goldene Regel:** Zeige deinen Prompt einem Kollegen mit minimalem Kontext zur Aufgabe und bitte ihn, ihn zu befolgen. Wenn er verwirrt wäre, wird Claude es auch sein.

* Sei konkret in Bezug auf das gewünschte Ausgabeformat und die Einschränkungen.
* Gib Anweisungen als aufeinanderfolgende Schritte mit nummerierten Listen oder Aufzählungspunkten, wenn die Reihenfolge oder Vollständigkeit der Schritte wichtig ist.

<Accordion title="Beispiel: Erstellen eines Analytics-Dashboards" defaultOpen>
  **Weniger effektiv:**

  ```text wrap
  Create an analytics dashboard
  ```

  **Effektiver:**

  ```text wrap
  Create an analytics dashboard. Include as many relevant features and interactions as possible. Go beyond the basics to create a fully-featured implementation.
  ```
</Accordion>

### Füge Kontext hinzu, um die Leistung zu verbessern

Wenn du den Kontext oder die Motivation hinter deinen Anweisungen angibst, etwa indem du Claude erklärst, warum ein bestimmtes Verhalten wichtig ist, kann Claude deine Ziele besser verstehen und gezieltere Antworten liefern.

<Accordion title="Beispiel: Formatierungspräferenzen" defaultOpen>
  **Weniger effektiv:**

  ```text wrap
  NEVER use ellipses
  ```

  **Effektiver:**

  ```text wrap
  Your response will be read aloud by a text-to-speech engine, so never use ellipses since the text-to-speech engine will not know how to pronounce them.
  ```
</Accordion>

Claude ist intelligent genug, um aus der Erklärung zu verallgemeinern.

### Nutze Beispiele effektiv

Beispiele sind eine der zuverlässigsten Methoden, um Claudes Ausgabeformat, Ton und Struktur zu steuern. Einige gut ausgearbeitete Beispiele (bekannt als „few-shot prompting“ oder „multishot prompting“ (Prompting mit wenigen bzw. mehreren Beispielen)) verbessern Genauigkeit und Konsistenz.

Wenn du Beispiele hinzufügst, achte darauf, dass sie:

* **Relevant** sind: Sie sollten deinen tatsächlichen Anwendungsfall genau widerspiegeln.
* **Vielfältig** sind: Sie sollten Grenzfälle abdecken und ausreichend variieren, damit Claude keine unbeabsichtigten Muster übernimmt.
* **Strukturiert** sind: Umschließe Beispiele mit `<example>`-Tags (mehrere Beispiele mit `<examples>`-Tags), damit Claude sie von Anweisungen unterscheiden kann.

<Tip>
  Füge für beste Ergebnisse 3–5 Beispiele ein. Du kannst Claude auch bitten, deine Beispiele auf Relevanz und Vielfalt zu bewerten oder auf Basis deines anfänglichen Satzes weitere zu generieren.
</Tip>

### Strukturiere Prompts mit XML-Tags

XML-Tags helfen Claude, komplexe Prompts eindeutig zu parsen, insbesondere wenn dein Prompt Anweisungen, Kontext, Beispiele und variable Eingaben mischt. Wenn du jede Art von Inhalt in ein eigenes Tag einschließt (zum Beispiel `<instructions>`, `<context>`, `<input>`), verringert das Fehlinterpretationen.

Best Practices:

* Verwende konsistente, beschreibende Tag-Namen in deinen Prompts.
* Verschachtele Tags, wenn der Inhalt eine natürliche Hierarchie hat (Dokumente innerhalb von `<documents>`, jedes innerhalb von `<document index="n">`).

### Gib Claude eine Rolle

Das Festlegen einer Rolle im „system prompt“ (System-Prompt) fokussiert Claudes Verhalten und Ton auf deinen Anwendungsfall. Schon ein einziger Satz macht einen Unterschied:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "system": "You are a helpful coding assistant specializing in Python.",
      "messages": [
        {"role": "user", "content": "How do I sort a list of dictionaries by key?"}
      ]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 1024 \
    --system "You are a helpful coding assistant specializing in Python." \
    --message '{role: user, content: "How do I sort a list of dictionaries by key?"}'
  ```

  ```python Python
  client = anthropic.Anthropic()

  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      system="You are a helpful coding assistant specializing in Python.",
      messages=[
          {"role": "user", "content": "How do I sort a list of dictionaries by key?"}
      ],
  )

  print(message.content)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const message = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    system: "You are a helpful coding assistant specializing in Python.",
    messages: [{ role: "user", content: "How do I sort a list of dictionaries by key?" }]
  });

  console.log(message.content);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      System = "You are a helpful coding assistant specializing in Python.",
      Messages =
      [
          new() { Role = Role.User, Content = "How do I sort a list of dictionaries by key?" }
      ]
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);
  ```

  ```go Go
  client := anthropic.NewClient()

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	System: []anthropic.TextBlockParam{
  		{Text: "You are a helpful coding assistant specializing in Python."},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("How do I sort a list of dictionaries by key?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(message.Content)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(1024)
      .system("You are a helpful coding assistant specializing in Python.")
      .addUserMessage("How do I sort a list of dictionaries by key?")
      .build();

  Message message = client.messages().create(params);
  System.out.println(message.content());
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          ['role' => 'user', 'content' => 'How do I sort a list of dictionaries by key?']
      ],
      model: 'claude-opus-5-5',
      system: 'You are a helpful coding assistant specializing in Python.',
  );

  echo json_encode($message->content, JSON_PRETTY_PRINT), PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    system: "You are a helpful coding assistant specializing in Python.",
    messages: [
      { role: "user", content: "How do I sort a list of dictionaries by key?" }
    ]
  )

  puts message.content
  ```
</CodeGroup>

### Prompting mit langem Kontext

Wenn du mit großen Dokumenten oder datenreichen Eingaben (20k+ Token) arbeitest, strukturiere deinen Prompt sorgfältig, um die besten Ergebnisse zu erzielen:

* **Platziere lange Daten oben:** Platziere deine langen Dokumente und Eingaben nahe am Anfang deines Prompts, oberhalb deiner Anfrage, Anweisungen und Beispiele. Dies verbessert die Leistung bei allen Modellen.

  <Note>
    Anfragen am Ende können die Antwortqualität in Tests um bis zu 30 Prozent verbessern, insbesondere bei komplexen Eingaben mit mehreren Dokumenten.
  </Note>

* **Strukturiere Dokumentinhalte und Metadaten mit XML-Tags:** Wenn du mehrere Dokumente verwendest, umschließe jedes Dokument zur Klarheit mit `<document>`-Tags mit den Untertags `<document_content>` und `<source>` (und weiteren Metadaten).

  <Accordion title="Beispiel für eine Struktur mit mehreren Dokumenten">
    ```xml
    <documents>
      <document index="1">
        <source>annual_report_2023.pdf</source>
        <document_content>
          {{ANNUAL_REPORT}}
        </document_content>
      </document>
      <document index="2">
        <source>competitor_analysis_q2.xlsx</source>
        <document_content>
          {{COMPETITOR_ANALYSIS}}
        </document_content>
      </document>
    </documents>

    Analyze the annual report and competitor analysis. Identify strategic advantages and recommend Q3 focus areas.
    ```
  </Accordion>

* **Stütze Antworten auf Zitate:** Bitte Claude bei Aufgaben mit langen Dokumenten, zuerst relevante Teile der Dokumente zu zitieren, bevor es seine Aufgabe ausführt. Das hilft Claude, sich auf den relevanten Inhalt zu konzentrieren und den Rest des Dokuments zu ignorieren.

  <Accordion title="Beispiel für Zitatextraktion">
    ```xml
    You are an AI physician's assistant. Your task is to help doctors diagnose possible patient illnesses.

    <documents>
      <document index="1">
        <source>patient_symptoms.txt</source>
        <document_content>
          {{PATIENT_SYMPTOMS}}
        </document_content>
      </document>
      <document index="2">
        <source>patient_records.txt</source>
        <document_content>
          {{PATIENT_RECORDS}}
        </document_content>
      </document>
      <document index="3">
        <source>patient01_appt_history.txt</source>
        <document_content>
          {{PATIENT01_APPOINTMENT_HISTORY}}
        </document_content>
      </document>
    </documents>

    Find quotes from the patient records and appointment history that are relevant to diagnosing the patient's reported symptoms. Place these in <quotes> tags. Then, based on these quotes, list all information that would help the doctor diagnose the patient's symptoms. Place your diagnostic information in <info> tags.
    ```
  </Accordion>

### Selbstkenntnis des Modells

Wenn du möchtest, dass Claude sich in deiner Anwendung korrekt identifiziert oder bestimmte API-Strings verwendet:

```text Sample prompt for model identity wrap
The assistant is Claude, created by Anthropic. The current model is Claude Opus 5.5.
```

Für LLM-gestützte Apps, die Modell-Strings angeben müssen:

```text Sample prompt for model string wrap
When an LLM is needed, please default to Claude Opus 5.5 unless the user requests
otherwise. The exact model string for Claude Opus 5.5 is claude-opus-5-5.
```

## Ausgabe und Formatierung

### Kommunikationsstil und Ausführlichkeit

Claudes neueste Modelle haben im Vergleich zu früheren Modellen einen prägnanteren und natürlicheren Kommunikationsstil:

* **Direkter und sachlicher:** Liefert faktenbasierte Fortschrittsberichte statt selbstlobender Updates
* **Gesprächiger:** Etwas flüssiger und umgangssprachlicher, weniger maschinenhaft
* **Weniger ausführlich:** Lässt aus Effizienzgründen möglicherweise detaillierte Zusammenfassungen weg, sofern nicht anders angewiesen

Das bedeutet, dass Claude nach Tool-Aufrufen möglicherweise verbale Zusammenfassungen überspringt und direkt zur nächsten Aktion übergeht. Wenn du mehr Einblick in seine Arbeit bevorzugst:

```text Sample prompt wrap
After completing a task that involves tool use, provide a quick summary of the work you've done.
```

Claude Opus 5 ist bei der Ausführlichkeit eine Ausnahme: Seine standardmäßigen Antworten an Nutzer sind länger als die früherer Modelle, und das Erhöhen oder Senken von [Effort](https://platform.claude.com/docs/de/build-with-claude/effort) verändert die sichtbare Antwortlänge nicht zuverlässig. Fordere stattdessen ausdrücklich Prägnanz an. Eine Beispielanweisung findest du unter [Prompting für Claude Opus 5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5#response-length-and-verbosity). Claude Fable 5.1 hat bei agentischer Arbeit die entgegengesetzte Tendenz: Es schreibt zwischen Tool-Aufrufen weniger Updates für Nutzer. Fordere Fortschrittstext ausdrücklich an und entferne jede Anweisung, die es auffordert, diesen Text kurz zu halten. Siehe [Nutzerseitige Fortschritts-Updates anfordern](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates).

### Steuere das Format von Antworten

Es gibt einige besonders effektive Möglichkeiten, die Ausgabeformatierung zu steuern:

1. **Sage Claude, was es tun soll, statt was es nicht tun soll**

   * Statt: „Verwende kein Markdown in deiner Antwort“
   * Versuche: „Deine Antwort sollte aus flüssig geschriebenen Prosa-Absätzen bestehen.“

2. **Verwende XML-Formatindikatoren**

   * Versuche: „Schreibe die Prosa-Abschnitte deiner Antwort in \<smoothly\_flowing\_prose\_paragraphs>-Tags.“

3. **Passe deinen Prompt-Stil an die gewünschte Ausgabe an**

   Der in deinem Prompt verwendete Formatierungsstil kann Claudes Antwortstil beeinflussen. Wenn du weiterhin Probleme mit der Steuerbarkeit der Ausgabeformatierung hast, versuche, deinen Prompt-Stil so genau wie möglich an deinen gewünschten Ausgabestil anzupassen. Wenn du zum Beispiel Markdown aus deinem Prompt entfernst, kann das die Menge an Markdown in der Ausgabe reduzieren.

4. **Verwende detaillierte Prompts für spezifische Formatierungspräferenzen**

   Für mehr Kontrolle über die Verwendung von Markdown und Formatierung gib explizite Hinweise:

````text Sample prompt to minimize markdown wrap
<avoid_excessive_markdown_and_bullet_points>
When writing reports, documents, technical explanations, analyses, or any long-form
content, write in clear, flowing prose using complete paragraphs and sentences. Use
standard paragraph breaks for organization and reserve markdown primarily for `inline
code`, code blocks (```...```), and simple headings (## and ###). Avoid using **bold**
and *italics*.

DO NOT use ordered lists (1. ...) or unordered lists (*) unless: a) you're presenting
truly discrete items where a list format is the best option, or b) the user explicitly
requests a list or ranking

Instead of listing items with bullets or numbers, incorporate them naturally into
sentences. This guidance applies especially to technical writing. Using prose instead of
excessive formatting will improve user satisfaction. NEVER output a series of overly
short bullet points.

Your goal is readable, flowing text that guides the reader naturally through ideas
rather than fragmenting information into isolated points.
</avoid_excessive_markdown_and_bullet_points>
````

Claude Fable 5.1 formatiert bereits weniger als frühere Modelle, sodass ein solcher Block bei diesem Modell Struktur unterdrücken kann, die der Inhalt benötigt. Entferne ihn oder ersetze ihn durch die kürzere Regel unter [Formatierung im Chat](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#formatting-in-chat).

### LaTeX-Ausgabe

Claudes neueste Modelle verwenden standardmäßig LaTeX für mathematische Ausdrücke, Gleichungen und technische Erklärungen. Wenn du reinen Text bevorzugst, füge deinem Prompt die folgenden Anweisungen hinzu:

```text Sample prompt wrap
Format your response in plain text only. Do not use LaTeX, MathJax, or any markup
notation such as \( \), $, or \frac{}{}. Write all math expressions using standard text
characters (e.g., "/" for division, "*" for multiplication, and "^" for exponents).
```

### Dokumenterstellung

Claudes neueste Modelle erstellen Präsentationen, Animationen und visuelle Dokumente mit starker Befolgung von Anweisungen und liefern in der Regel beim ersten Versuch brauchbare Ergebnisse.

Für beste Ergebnisse bei der Dokumenterstellung:

```text Sample prompt wrap
Create a professional presentation on [topic]. Include thoughtful design elements,
visual hierarchy, and engaging animations where appropriate.
```

### Migration weg von vorausgefüllten Antworten

Ab den Claude-4.6-Modellen und [Claude Mythos Preview](https://anthropic.com/glasswing) werden vorausgefüllte Antworten (das Bereitstellen einer partiellen Assistant-Nachricht, die Claude fortsetzt) im letzten Assistant-Turn nicht mehr unterstützt. Anfragen mit vorausgefüllten Assistant-Nachrichten an diese Modelle geben einen 400-Fehler zurück. Modellintelligenz und Befolgung von Anweisungen haben sich so weit entwickelt, dass die meisten Anwendungsfälle für Prefill dies nicht mehr erfordern. Frühere Modelle unterstützen Prefills weiterhin, und das Hinzufügen von Assistant-Nachrichten an anderer Stelle im Gespräch ist nicht betroffen.

Hier sind gängige Prefill-Szenarien und wie du davon weg migrierst:

<Accordion title="Steuerung der Ausgabeformatierung">
  Prefills wurden verwendet, um bestimmte Ausgabeformate wie JSON/YAML, Klassifizierung und ähnliche Muster zu erzwingen, bei denen das Prefill Claude auf eine bestimmte Struktur beschränkt.

  **Migration:** Die Funktion [Structured Outputs](https://platform.claude.com/docs/de/build-with-claude/structured-outputs) ist speziell dafür konzipiert, Claudes Antworten auf ein vorgegebenes Schema zu beschränken. Versuche zunächst, das Modell zu bitten, sich an deine Ausgabestruktur zu halten, da neuere Modelle komplexe Schemata zuverlässig einhalten können, wenn sie dazu aufgefordert werden, insbesondere wenn dies mit Wiederholungsversuchen implementiert wird. Verwende für Klassifizierungsaufgaben entweder Tools mit einem Enum-Feld, das deine gültigen Labels enthält, oder Structured Outputs.
</Accordion>

<Accordion title="Präambeln eliminieren">
  Prefills wie `Here is the requested summary:\n` wurden verwendet, um einleitenden Text zu überspringen.

  **Migration:** Verwende direkte Anweisungen im System-Prompt: „Antworte direkt ohne Präambel. Beginne nicht mit Formulierungen wie ‚Hier ist...', ‚Basierend auf...' usw.“ Alternativ kannst du das Modell anweisen, innerhalb von XML-Tags auszugeben, Structured Outputs verwenden oder Tool-Aufrufe nutzen. Wenn gelegentlich eine Präambel durchrutscht, entferne sie in der Nachbearbeitung.
</Accordion>

<Accordion title="Unangemessene Ablehnungen vermeiden">
  Prefills wurden verwendet, um unnötige Ablehnungen zu umgehen.

  **Migration:** Claude ist jetzt viel besser bei angemessenen Ablehnungen. Klares Prompting innerhalb der `user`-Nachricht ohne Prefill sollte ausreichen.
</Accordion>

<Accordion title="Fortsetzungen">
  Prefills wurden verwendet, um partielle Completions fortzusetzen, unterbrochene Antworten wieder aufzunehmen oder dort weiterzumachen, wo eine vorherige Generierung aufgehört hat.

  **Migration:** Verschiebe die Fortsetzung in die User-Nachricht und füge den letzten Text der unterbrochenen Antwort ein: „Deine vorherige Antwort wurde unterbrochen und endete mit \`\[previous\_response]\`. Mach dort weiter, wo du aufgehört hast." Wenn dies Teil der Fehlerbehandlung oder der Behandlung unvollständiger Antworten ist und es keine UX-Nachteile gibt, wiederhole die Anfrage.
</Accordion>

<Accordion title="Kontext-Hydration und Rollenkonsistenz">
  Prefills wurden verwendet, um regelmäßig aufgefrischten oder eingefügten Kontext sicherzustellen.

  **Migration:** Füge bei sehr langen Gesprächen das, was zuvor vorausgefüllte Assistant-Erinnerungen waren, in den User-Turn ein. Wenn die Kontext-Hydration Teil eines komplexeren agentischen Systems ist, erwäge die Hydration über Tools (stelle Tools mit Kontext bereit oder fördere deren Nutzung basierend auf Heuristiken wie der Anzahl der Turns) oder während der [Kontextkomprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction).
</Accordion>

## Tool-Nutzung

### Verwendung von Tools

Claudes neueste Modelle sind auf präzises Befolgen von Anweisungen trainiert und profitieren von expliziten Anweisungen zur Verwendung bestimmter Tools. Wenn du sagst „kannst du einige Änderungen vorschlagen“, wird Claude manchmal Vorschläge machen, anstatt sie umzusetzen, selbst wenn das Vornehmen von Änderungen das war, was du beabsichtigt hast. Wie du Tools definierst und Probleme beim Auslösen von Tools behebst, erfährst du unter [Tool-Nutzung mit Claude](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview).

Damit Claude handelt, sei expliziter:

<Accordion title="Beispiel: Explizite Anweisungen" defaultOpen>
  **Weniger effektiv (Claude wird nur vorschlagen):**

  ```text wrap
  Can you suggest some changes to improve this function?
  ```

  **Effektiver (Claude wird die Änderungen vornehmen):**

  ```text wrap
  Change this function to improve its performance.
  ```

  Oder:

  ```text wrap
  Make these edits to the authentication flow.
  ```
</Accordion>

Damit Claude standardmäßig proaktiver handelt, kannst du Folgendes zu deinem System-Prompt hinzufügen:

```text Sample prompt for proactive action wrap
<default_to_action>
By default, implement changes rather than only suggesting them. If the user's intent is
unclear, infer the most useful likely action and proceed, using tools to discover any
missing details instead of guessing. Try to infer the user's intent about whether a tool
call (e.g., file edit or read) is intended or not, and act accordingly.
</default_to_action>
```

Wenn du andererseits möchtest, dass das Modell standardmäßig zurückhaltender ist, weniger dazu neigt, direkt in Implementierungen zu springen, und nur auf Anfrage handelt, kannst du dieses Verhalten mit einem Prompt wie dem folgenden steuern:

```text Sample prompt for conservative action wrap
<do_not_act_before_instructions>
Do not jump into implementation or change files unless clearly instructed to make
changes. When the user's intent is ambiguous, default to providing information, doing
research, and providing recommendations rather than taking action. Only proceed with
edits, modifications, or implementations when the user explicitly requests them.
</do_not_act_before_instructions>
```

Claude Opus 4.5 und Claude Opus 4.6 reagieren außerdem stärker auf den System-Prompt als frühere Modelle. Wenn deine Prompts darauf ausgelegt waren, ein zu seltenes Auslösen von Tools oder Skills zu reduzieren, lösen diese Modelle jetzt möglicherweise zu häufig aus. Die Lösung besteht darin, aggressive Formulierungen zurückzunehmen. Wo du vielleicht „KRITISCH: Du MUSST dieses Tool verwenden, wenn...“ gesagt hättest, kannst du normaleres Prompting wie „Verwende dieses Tool, wenn...“ nutzen.

### Optimiere parallele Tool-Aufrufe

Claudes neueste Modelle führen unabhängige Tool-Aufrufe parallel aus. Diese Modelle werden:

* Während der Recherche mehrere spekulative Suchen ausführen
* Mehrere Dateien gleichzeitig lesen, um schneller Kontext aufzubauen
* Bash-Befehle parallel ausführen (was sogar die Systemleistung ausbremsen kann)

Dieses Verhalten ist steuerbar. Obwohl das Modell ohne Prompting eine hohe Erfolgsquote bei parallelen Tool-Aufrufen hat, kannst du diese auf \~100 % steigern oder den Aggressivitätsgrad anpassen:

```text Sample prompt for maximum parallel efficiency wrap
<use_parallel_tool_calls>
If you intend to call multiple tools and there are no dependencies between the tool
calls, make all of the independent tool calls in parallel. Prioritize calling tools
simultaneously whenever the actions can be done in parallel rather than sequentially.
For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into
context at the same time. Maximize use of parallel tool calls where possible to increase
speed and efficiency. However, if some tool calls depend on previous calls to inform
dependent values like the parameters, do NOT call these tools in parallel and instead
call them sequentially. Never use placeholders or guess missing parameters in tool
calls.
</use_parallel_tool_calls>
```

```text Sample prompt to reduce parallel execution wrap
Execute operations sequentially with brief pauses between each step to ensure stability.
```

Sende bei Claude Fable 5.1 in langen Agentenschleifen die Anweisung für parallele Aufrufe als Turn-bezogene System-Nachricht nach jeder Runde von Tool-Ergebnissen. Siehe [Unabhängige Tool-Aufrufe in Agentenschleifen bündeln](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops).

## Nachdenken und Schlussfolgern

### Übermäßiges Nachdenken und übertriebene Gründlichkeit

Claude Opus 4.6 betreibt mehr Vorab-Exploration als frühere Modelle, insbesondere bei höheren [`effort`](https://platform.claude.com/docs/de/build-with-claude/effort)-Einstellungen. Diese anfängliche Arbeit hilft oft, die Endergebnisse zu optimieren, aber das Modell kann umfangreichen Kontext sammeln oder mehrere Recherchestränge verfolgen, ohne dazu aufgefordert zu werden. Wenn deine Prompts das Modell zuvor zu mehr Gründlichkeit ermutigt haben, solltest du diese Hinweise für Claude Opus 4.6 anpassen:

* **Ersetze pauschale Standardvorgaben durch gezieltere Anweisungen.** Statt „Verwende standardmäßig \[tool]“ füge Hinweise hinzu wie „Verwende \[tool], wenn es dein Verständnis des Problems verbessern würde.“
* **Entferne übermäßiges Prompting.** Tools, die bei früheren Modellen zu selten ausgelöst wurden, werden jetzt wahrscheinlich angemessen ausgelöst. Anweisungen wie „Im Zweifel verwende \[tool]“ führen zu übermäßigem Auslösen.
* **Nutze Effort als Fallback.** Wenn Claude weiterhin zu aggressiv ist, verwende eine niedrigere Einstellung für `effort`.

In manchen Fällen kann Claude Opus 4.6 ausgiebig nachdenken, was die Thinking-Token aufblähen und Antworten verlangsamen kann. Wenn dieses Verhalten unerwünscht ist, kannst du explizite Anweisungen hinzufügen, um seine Überlegungen einzuschränken, oder die `effort`-Einstellung senken, um das Nachdenken und den Token-Verbrauch insgesamt zu reduzieren.

```text Sample prompt wrap
When you're deciding how to approach a problem, choose an approach and commit to it.
Avoid revisiting decisions unless you encounter new information that directly
contradicts your reasoning. If you're weighing two approaches, pick one and see it
through. You can always course-correct later if the chosen approach fails.
```

Wenn du eine harte Obergrenze für Denkkosten benötigst, ist „extended thinking“ (erweitertes Nachdenken) mit einer `budget_tokens`-Obergrenze auf Opus 4.6 und Sonnet 4.6 noch funktionsfähig, aber abgekündigt. Bei Claude 4.7 und späteren Modellen gibt das Setzen von `budget_tokens` einen 400-Fehler zurück. Bevorzuge das Senken der [effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Einstellung oder die Verwendung von `max_tokens` als hartes Limit mit [adaptivem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking).

### Nutze die Fähigkeiten für Nachdenken und verschachteltes Nachdenken

Claudes neueste Modelle bieten Fähigkeiten zum Nachdenken, die besonders bei Aufgaben hilfreich sein können, die Reflexion nach der Tool-Nutzung oder komplexes mehrstufiges Schlussfolgern erfordern. Du kannst das anfängliche oder verschachtelte Nachdenken für bessere Ergebnisse lenken.

Claude-4.6- und spätere Modelle sowie Claude Mythos Preview verwenden [adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking) (`thinking: {type: "adaptive"}`), bei dem Claude dynamisch bestimmt, wann und wie viel es nachdenkt. Bei Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5 und Claude Opus 5.5 ist das Nachdenken immer aktiv, und adaptives Nachdenken ist der einzige Modus. Claude kalibriert sein Nachdenken anhand von zwei Faktoren: dem `effort`-Parameter und der Komplexität der Anfrage. Höherer Effort führt zu mehr Nachdenken, und komplexere Anfragen ebenso. Bei einfacheren Anfragen, die kein Nachdenken erfordern, antwortet das Modell direkt. In internen Evaluierungen führt adaptives Nachdenken zuverlässig zu besserer Leistung als erweitertes Nachdenken. Erwäge den Umstieg auf adaptives Nachdenken.

Verwende adaptives Nachdenken für Workloads, die agentisches Verhalten erfordern, etwa mehrstufige Tool-Nutzung, komplexe Coding-Aufgaben und Agentenschleifen mit langem Zeithorizont. Ältere Modelle verwenden manuelles [erweitertes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/extended-thinking) mit `budget_tokens`; welche Konfiguration jedes Modell akzeptiert, siehst du in der [Konfigurationstabelle pro Modell](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#supported-models).

Du kannst Claudes Nachdenkverhalten lenken:

```text Example prompt wrap
After receiving tool results, carefully reflect on their quality and determine optimal
next steps before proceeding. Use your thinking to plan and iterate based on this new
information, and then take the best next action.
```

Das Auslöseverhalten für adaptives Nachdenken lässt sich per Prompt steuern. Wenn du feststellst, dass das Modell häufiger nachdenkt, als dir lieb ist, was bei großen oder komplexen System-Prompts vorkommen kann, füge Anweisungen hinzu, um es zu lenken:

```text Sample prompt wrap
Thinking adds latency and should only be used when it will meaningfully improve
answer quality - typically for problems that require multistep reasoning. When in
doubt, respond directly.
```

Wenn du von [erweitertem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/extended-thinking) mit `budget_tokens` migrierst, ersetze deine Thinking-Konfiguration und verlagere die Budgetsteuerung auf `effort`. Die folgenden Beispiele zeigen dieselbe Anfrage vor und nach der Migration (die verfügbaren Stufen und die Verfügbarkeit pro Modell findest du unter [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)):

<CodeGroup>
  ```bash cURL
  # Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  curl https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
      "model": "claude-sonnet-4-5-20250929",
      "max_tokens": 16000,
      "thinking": {"type": "enabled", "budget_tokens": 10000},
      "messages": [
        {"role": "user", "content": "..."}
      ]
    }'

  # Nachher: adaptives Nachdenken mit Effort
  curl https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 16000,
      "thinking": {"type": "adaptive"},
      "output_config": {"effort": "high"},
      "messages": [
        {"role": "user", "content": "..."}
      ]
    }'
  ```

  ```bash CLI
  # Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  ant messages create <<'YAML'
  model: claude-sonnet-4-5-20250929
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: "..."
  YAML

  # Nachher: adaptives Nachdenken mit Effort
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  thinking:
    type: adaptive
  output_config:
    effort: high
  messages:
    - role: user
      content: "..."
  YAML
  ```

  ```python Python
  # Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  client.messages.create(
      model="claude-sonnet-4-5-20250929",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[{"role": "user", "content": "..."}],
  )

  # Nachher: adaptives Nachdenken mit Effort
  client.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      thinking={"type": "adaptive"},
      output_config={"effort": "high"},
      messages=[{"role": "user", "content": "..."}],
  )
  ```

  ```typescript TypeScript
  // Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  await client.messages.create({
    model: "claude-sonnet-4-5-20250929",
    max_tokens: 16000,
    thinking: { type: "enabled", budget_tokens: 10000 },
    messages: [{ role: "user", content: "..." }]
  });

  // Nachher: adaptives Nachdenken mit Effort
  await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    thinking: { type: "adaptive" },
    output_config: { effort: "high" },
    messages: [{ role: "user", content: "..." }]
  });
  ```

  ```csharp C#
  // Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeSonnet4_5_20250929,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages = [new() { Role = Role.User, Content = "..." }]
  });

  // Nachher: adaptives Nachdenken mit Effort
  await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigAdaptive(),
      OutputConfig = new OutputConfig { Effort = Effort.High },
      Messages = [new() { Role = Role.User, Content = "..." }]
  });
  ```

  ```go Go
  // Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  client.Messages.New(ctx, anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet4_5_20250929,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfEnabled: &anthropic.ThinkingConfigEnabledParam{BudgetTokens: 10000},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })

  // Nachher: adaptives Nachdenken mit Effort
  client.Messages.New(ctx, anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Thinking: anthropic.ThinkingConfigParamUnion{
  		OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortHigh,
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("...")),
  	},
  })
  ```

  ```java Java
  // Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  client.messages().create(MessageCreateParams.builder()
      .model(Model.CLAUDE_SONNET_4_5_20250929)
      .maxTokens(16000L)
      .thinking(ThinkingConfigEnabled.builder().budgetTokens(10000L).build())
      .addUserMessage("...")
      .build());

  // Nachher: adaptives Nachdenken mit Effort
  client.messages().create(MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(16000L)
      .thinking(ThinkingConfigAdaptive.builder().build())
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.HIGH)
          .build())
      .addUserMessage("...")
      .build());
  ```

  ```php PHP
  // Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  $client->messages->create(
      model: 'claude-sonnet-4-5-20250929',
      maxTokens: 16000,
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
      messages: [['role' => 'user', 'content' => '...']],
  );

  // Nachher: adaptives Nachdenken mit Effort
  $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 16000,
      thinking: ['type' => 'adaptive'],
      outputConfig: ['effort' => 'high'],
      messages: [['role' => 'user', 'content' => '...']],
  );
  ```

  ```ruby Ruby
  # Vorher: erweitertes Nachdenken mit manuellem Budget (ältere Modelle)
  client.messages.create(
    model: "claude-sonnet-4-5-20250929",
    max_tokens: 16000,
    thinking: { type: "enabled", budget_tokens: 10000 },
    messages: [{ role: "user", content: "..." }]
  )

  # Nachher: adaptives Nachdenken mit Effort
  client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 16000,
    thinking: { type: "adaptive" },
    output_config: { effort: "high" },
    messages: [{ role: "user", content: "..." }]
  )
  ```
</CodeGroup>

Wenn du kein erweitertes Nachdenken verwendest, musst du keinen `thinking`-Parameter hinzufügen. Bei Claude Opus 4.6 bis Claude Opus 4.8 und Claude Sonnet 4.6 ist das Nachdenken deaktiviert, wenn du den `thinking`-Parameter weglässt. Bei Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5 und Claude Haiku 5.5 ist das Nachdenken standardmäßig aktiviert, wenn du den `thinking`-Parameter weglässt, sodass eine Antwort mit `thinking`-Blöcken beginnen kann. Wähle Content-Blöcke anhand von `type` statt anhand ihrer Position aus und lass in `max_tokens` Platz für das Nachdenken. Bei Claude Opus 5 und Claude Haiku 5.5 kannst du es nur bei Effort `high` oder niedriger deaktivieren. Bei Claude Sonnet 5.5 ist die niedrigste Thinking-Einstellung `between_tools`, die bei Effort `high` oder niedriger akzeptiert wird. Bei Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5 und Claude Opus 5.5 ist das Nachdenken immer aktiv, unabhängig davon, ob du den `thinking`-Parameter setzt.

* **Bevorzuge allgemeine Anweisungen gegenüber vorgeschriebenen Schritten.** Ein Prompt wie „denke gründlich nach“ führt oft zu besserem Schlussfolgern als ein von Hand geschriebener Schritt-für-Schritt-Plan. Claudes Schlussfolgern übertrifft häufig das, was ein Mensch vorschreiben würde.
* **Multishot-Beispiele funktionieren mit Nachdenken.** Ausgearbeitete Beispiele in deinem Prompt prägen, wie Claude ähnliche Probleme in seinen eigenen Thinking-Blöcken angeht. Stelle jedes Beispiel als Problem, anzuwendende Methode und erwartete Antwort dar.
* **Manuelles „chain-of-thought prompting“ (Prompting mit Gedankenkette), oder CoT, als Ausweichlösung.** Wenn das Nachdenken deaktiviert ist, kannst du trotzdem schrittweises Schlussfolgern fördern, indem du Claude bittest, das Problem vor der Antwort durchzudenken und die endgültige Antwort in `<answer>`-Tags zu setzen, damit du sie extrahieren kannst. Verlasse dich bei Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5 und Claude Sonnet 5.5 stattdessen auf das Nachdenken, bei einer niedrigeren [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Stufe, wenn Kosten oder Latenz wichtig sind: Ein Prompt, der das Modell auffordert, sein Reasoning auszuschreiben, zum Beispiel in `<thinking>`-Tags, wird möglicherweise abgelehnt. Siehe [Reasoning in Thinking-Blöcken belassen](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks).
* **Bitte Claude um eine Selbstprüfung.** Füge etwas hinzu wie „Bevor du fertig bist, überprüfe deine Antwort anhand von \[Testkriterien].“ Das fängt Fehler zuverlässig ab, besonders bei Coding und Mathematik. Claude Opus 5 ist die Ausnahme: Es überprüft seine eigene Arbeit auch ohne explizite Anweisung gut, und Verifizierungsanweisungen, die aus für frühere Modelle abgestimmten Prompts übernommen wurden, können zu Überverifizierung führen, was Token und Latenz erhöht. Entferne diese Anweisungen bei Claude Opus 5, anstatt sie umzuschreiben. Siehe [Aufgabenumfang und Überverifizierung](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5#task-scope-and-over-verification).

<Note>
  Wenn erweitertes Nachdenken deaktiviert ist, reagiert Claude Opus 4.5 besonders empfindlich auf das Wort „think“ und seine Varianten. Erwäge in diesen Fällen Alternativen wie „consider“, „evaluate“ oder „reason through“.
</Note>

<Info>
  Weitere Informationen zu den Fähigkeiten zum Nachdenken findest du unter [Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking) und [Nachdenken steuern](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost).
</Info>

## Agentische Systeme

### Schlussfolgern mit langem Horizont und Zustandsverfolgung

Claudes neueste Modelle bewältigen Schlussfolgerungsaufgaben mit langem Horizont mit starker Zustandsverfolgung. Claude behält über ausgedehnte Sitzungen hinweg die Orientierung, indem es sich auf inkrementellen Fortschritt konzentriert und stetig an wenigen Dingen gleichzeitig vorankommt, anstatt alles auf einmal zu versuchen. Diese Fähigkeit zeigt sich besonders über mehrere „context windows“ (Kontextfenster) oder Aufgabeniterationen hinweg, wobei Claude an einer komplexen Aufgabe arbeiten, den Zustand speichern und mit einem frischen Kontextfenster fortfahren kann.

#### Kontextbewusstsein und Workflows über mehrere Fenster

Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5 (abgekündigt) und Claude Haiku 4.5 verfügen über [Kontextbewusstsein](https://platform.claude.com/docs/de/build-with-claude/context-windows#context-awareness), wodurch das Modell sein verbleibendes Kontextfenster (also sein „Token-Budget“) während eines Gesprächs verfolgen kann. Dadurch kann Claude Aufgaben ausführen und Kontext effektiver verwalten, weil es versteht, wie viel Platz es zum Arbeiten hat.

**Umgang mit Kontextgrenzen:**

Wenn du Claude in einem Agent-Harness verwendest, das Kontext komprimiert oder das Speichern von Kontext in externen Dateien erlaubt (wie in Claude Code), erwäge, diese Information zu deinem Prompt hinzuzufügen, damit Claude sich entsprechend verhalten kann. Andernfalls versucht Claude manchmal von sich aus, die Arbeit abzuschließen, wenn es sich der Kontextgrenze nähert. Das Folgende ist ein Beispiel-Prompt:

```text Sample prompt wrap
Your context window will be automatically compacted as it approaches its limit, allowing
you to continue working indefinitely from where you left off. Therefore, do not stop
tasks early due to token budget concerns. As you approach your token budget limit, save
your current progress and state to memory before the context window refreshes. Always be
as persistent and autonomous as possible and complete tasks fully, even if the end of
your budget is approaching. Never artificially stop any task early regardless of the
context remaining.
```

Das [Memory-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/memory-tool) passt gut zum Kontextbewusstsein, um Kontextübergänge zu verwalten.

#### Workflows über mehrere Kontextfenster hinweg

Für Aufgaben, die sich über mehrere Kontextfenster erstrecken:

1. **Verwende einen anderen Prompt für das allererste Kontextfenster:** Nutze das erste Kontextfenster, um ein Framework aufzubauen (Tests schreiben, Setup-Skripte erstellen), und nutze dann zukünftige Kontextfenster, um eine To-do-Liste abzuarbeiten.

2. **Lass das Modell Tests in einem strukturierten Format schreiben:** Bitte Claude, vor Arbeitsbeginn Tests zu erstellen und sie in einem strukturierten Format (zum Beispiel `tests.json`) zu verfolgen. Das führt zu einer besseren langfristigen Iterationsfähigkeit. Erinnere Claude an die Bedeutung von Tests: „Es ist inakzeptabel, Tests zu entfernen oder zu bearbeiten, da dies zu fehlender oder fehlerhafter Funktionalität führen könnte.“

3. **Richte Komfort-Tools ein:** Ermutige Claude, Setup-Skripte (zum Beispiel `init.sh`) zu erstellen, um Server sauber zu starten sowie Test-Suites und Linter auszuführen. Das verhindert wiederholte Arbeit, wenn mit einem frischen Kontextfenster fortgefahren wird.

4. **Neu starten versus komprimieren:** Wenn ein Kontextfenster geleert wird, erwäge, mit einem brandneuen Kontextfenster zu beginnen, anstatt Komprimierung zu verwenden. Claudes neueste Modelle sind äußerst effektiv darin, den Zustand aus dem lokalen Dateisystem zu ermitteln. In manchen Fällen möchtest du dies vielleicht gegenüber der Komprimierung bevorzugen. Gib genau vor, wie es beginnen soll:

   * „Rufe pwd auf; du kannst nur in diesem Verzeichnis Dateien lesen und schreiben.“
   * „Sieh dir progress.txt, tests.json und die Git-Logs an.“
   * „Führe manuell einen grundlegenden Integrationstest durch, bevor du mit der Implementierung neuer Features fortfährst.“

5. **Stelle Verifizierungstools bereit:** Mit zunehmender Länge autonomer Aufgaben muss Claude die Korrektheit ohne kontinuierliches menschliches Feedback überprüfen. Tools, mit denen Claude UI-Arbeit überprüfen kann, sind hilfreich, etwa das [Computer-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool), das [Browser-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool) oder ein MCP-Server für Browser-Automatisierung.

6. **Fördere die vollständige Nutzung des Kontexts:** Fordere Claude auf, Komponenten effizient abzuschließen, bevor es weitermacht:

```text Sample prompt wrap
This is a very long task, so it may be beneficial to plan out your work clearly. It's
encouraged to spend your entire output context working on the task - just make sure you
don't run out of context with significant uncommitted work. Continue working
systematically until you have completed this task.
```

#### Best Practices für die Zustandsverwaltung

* **Verwende strukturierte Formate für Zustandsdaten:** Wenn du strukturierte Informationen verfolgst (wie Testergebnisse oder Aufgabenstatus), verwende JSON oder andere strukturierte Formate, damit Claude die Schema-Anforderungen versteht.
* **Verwende unstrukturierten Text für Fortschrittsnotizen:** Freiform-Fortschrittsnotizen eignen sich gut, um allgemeinen Fortschritt und Kontext zu verfolgen.
* **Verwende Git für die Zustandsverfolgung:** Git bietet ein Protokoll dessen, was getan wurde, und Checkpoints, die wiederhergestellt werden können. Claudes neueste Modelle sind besonders gut darin, Git zur Zustandsverfolgung über mehrere Sitzungen hinweg zu nutzen.
* **Betone inkrementellen Fortschritt:** Bitte Claude ausdrücklich, seinen Fortschritt zu verfolgen und sich auf inkrementelle Arbeit zu konzentrieren.

<Accordion title="Beispiel: Zustandsverfolgung">
  ```json tests.json
  {
    "tests": [
      { "id": 1, "name": "authentication_flow", "status": "passing" },
      { "id": 2, "name": "user_management", "status": "failing" },
      { "id": 3, "name": "api_endpoints", "status": "not_started" }
    ],
    "total": 200,
    "passing": 150,
    "failing": 25,
    "not_started": 25
  }
  ```

  ```text wrap
  // Progress notes (progress.txt)
  Session 3 progress:
  - Fixed authentication token validation
  - Updated user model to handle edge cases
  - Next: investigate user_management test failures (test #2)
  - Note: Do not remove tests as this could lead to missing functionality
  ```
</Accordion>

### Autonomie und Sicherheit ausbalancieren

Ohne Anleitung kann Claude Opus 4.6 Aktionen ausführen, die schwer rückgängig zu machen sind oder gemeinsam genutzte Systeme betreffen, wie das Löschen von Dateien, Force-Pushes oder das Posten an externe Dienste. Wenn du möchtest, dass Claude Opus 4.6 vor potenziell riskanten Aktionen eine Bestätigung einholt, füge deinem Prompt Hinweise hinzu:

```text Sample prompt wrap
Consider the reversibility and potential impact of your actions. You are encouraged to
take local, reversible actions like editing files or running tests, but for actions that
are hard to reverse, affect shared systems, or could be destructive, ask the user before
proceeding.

Examples of actions that warrant confirmation:
- Destructive operations: deleting files or branches, dropping database tables, rm -rf
- Hard to reverse operations: git push --force, git reset --hard, amending published commits
- Operations visible to others: pushing code, commenting on PRs/issues, sending
messages, modifying shared infrastructure

When encountering obstacles, do not use destructive actions as a shortcut. For example,
don't bypass safety checks (e.g. --no-verify) or discard unfamiliar files that may be
in-progress work.
```

### Recherche und Informationsbeschaffung

Claudes neueste Modelle können Informationen aus mehreren Quellen effektiv finden und zusammenführen. Für optimale Rechercheergebnisse:

1. **Gib klare Erfolgskriterien vor:** Definiere, was eine erfolgreiche Antwort auf deine Recherchefrage ausmacht.

2. **Fördere die Quellenüberprüfung:** Bitte Claude, Informationen über mehrere Quellen hinweg zu verifizieren.

3. **Verwende für komplexe Rechercheaufgaben einen strukturierten Ansatz:**

```text Sample prompt for complex research wrap
Search for this information in a structured way. As you gather data, develop several
competing hypotheses. Track your confidence levels in your progress notes to improve
calibration. Regularly self-critique your approach and plan. Update a hypothesis tree or
research notes file to persist information and provide transparency. Break down this
complex research task systematically.
```

Dieser strukturierte Ansatz hilft Claude, große Korpora methodisch durchzuarbeiten und seine Erkenntnisse iterativ kritisch zu prüfen.

### Orchestrierung von Subagenten

Claudes neueste Modelle orchestrieren „subagents“ (Subagenten) nativ. Diese Modelle können erkennen, wann Aufgaben von der Delegation an spezialisierte Subagenten profitieren würden, und tun dies proaktiv, ohne explizite Anweisung zu benötigen.

Um dieses Verhalten zu nutzen:

1. **Stelle gut definierte Subagenten-Tools sicher:** Halte Subagenten-Tools verfügbar und beschreibe sie in den Tool-Definitionen.
2. **Lass Claude natürlich orchestrieren:** Claude delegiert angemessen ohne explizite Anweisung.
3. **Achte auf übermäßige Nutzung:** Claude Opus 4.6 hat eine starke Vorliebe für Subagenten und kann sie in Situationen starten, in denen ein einfacherer, direkter Ansatz ausreichen würde. Zum Beispiel kann das Modell Subagenten für die Code-Exploration starten, wenn ein direkter grep-Aufruf schneller und ausreichend ist. Auch Claude Opus 5 delegiert bereitwilliger an Subagenten als frühere Modelle; Hinweise und einen Beispiel-Prompt zur Dämpfung findest du unter [Steuerung des Startens von Subagenten](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5#controlling-subagent-spawning).

Wenn du übermäßige Subagenten-Nutzung beobachtest, füge explizite Hinweise hinzu, wann Subagenten angebracht sind und wann nicht:

```text Sample prompt for subagent usage wrap
Use subagents when tasks can run in parallel, require isolated context, or involve
independent workstreams that don't need to share state. For simple tasks, sequential
operations, single-file edits, or tasks where you need to maintain context across steps,
work directly rather than delegating.
```

### Verkette komplexe Prompts

Mit adaptivem Nachdenken und Subagenten-Orchestrierung erledigt Claude das meiste mehrstufige Schlussfolgern intern. Explizites Prompt-Chaining (das Aufteilen einer Aufgabe in aufeinanderfolgende API-Aufrufe) ist weiterhin nützlich, wenn du Zwischenergebnisse inspizieren oder eine bestimmte Pipeline-Struktur erzwingen musst.

Das häufigste Chaining-Muster ist die **Selbstkorrektur:** einen Entwurf generieren → Claude ihn anhand von Kriterien überprüfen lassen → Claude auf Basis der Überprüfung verfeinern lassen. Jeder Schritt ist ein separater API-Aufruf, sodass du an jedem Punkt protokollieren, evaluieren oder verzweigen kannst.

### Reduziere die Dateierstellung beim agentischen Coding

Claudes neueste Modelle erstellen manchmal neue Dateien zu Test- und Iterationszwecken, insbesondere bei der Arbeit mit Code. Dieser Ansatz ermöglicht es Claude, Dateien, insbesondere Python-Skripte, als „temporären Notizblock“ zu verwenden, bevor es seine endgültige Ausgabe speichert. Die Verwendung temporärer Dateien kann die Ergebnisse insbesondere bei agentischen Coding-Anwendungsfällen verbessern.

Wenn du die Erstellung neuer Dateien netto minimieren möchtest, kannst du Claude anweisen, hinter sich aufzuräumen:

```text Sample prompt wrap
If you create any temporary new files, scripts, or helper files for iteration, clean up
these files by removing them at the end of the task.
```

### Übereifer

Claude Opus 4.5 und Claude Opus 4.6 neigen zum Overengineering, indem sie zusätzliche Dateien erstellen, unnötige Abstraktionen hinzufügen oder Flexibilität einbauen, die nicht angefordert wurde. Wenn du dieses unerwünschte Verhalten beobachtest, füge spezifische Hinweise hinzu, um Lösungen minimal zu halten.

Zum Beispiel:

```text Sample prompt to minimize overengineering wrap
Avoid over-engineering. Only make changes that are directly requested or clearly
necessary. Keep solutions simple and focused:

- Scope: Don't add features, refactor code, or make "improvements" beyond what was
asked. A bug fix doesn't need surrounding code cleaned up. A simple feature doesn't need
extra configurability.

- Documentation: Don't add docstrings, comments, or type annotations to code you didn't
change. Only add comments where the logic isn't self-evident.

- Defensive coding: Don't add error handling, fallbacks, or validation for scenarios
that can't happen. Trust internal code and framework guarantees. Only validate at system
boundaries (user input, external APIs).

- Abstractions: Don't create helpers, utilities, or abstractions for one-time
operations. Don't design for hypothetical future requirements. The right amount of
complexity is the minimum needed for the current task.
```

### Vermeide die Fixierung auf bestandene Tests und Hardcoding

Claude kann sich manchmal zu stark darauf konzentrieren, Tests zum Bestehen zu bringen, auf Kosten allgemeinerer Lösungen, oder Workarounds wie Hilfsskripte für komplexes Refactoring verwenden, anstatt Standardtools direkt zu nutzen. Um dieses Verhalten zu verhindern und Lösungen zu erhalten, die verallgemeinern:

```text Sample prompt wrap
Please write a high-quality, general-purpose solution using the standard tools
available. Do not create helper scripts or workarounds to accomplish the task more
efficiently. Implement a solution that works correctly for all valid inputs, not just
the test cases. Do not hard-code values or create solutions that only work for specific
test inputs. Instead, implement the actual logic that solves the problem generally.

Focus on understanding the problem requirements and implementing the correct algorithm.
Tests are there to verify correctness, not to define the solution. Provide a principled
implementation that follows best practices and software design principles.

If the task is unreasonable or infeasible, or if any of the tests are incorrect, please
inform me rather than working around them. The solution should be robust, maintainable,
and extendable.
```

### Halluzinationen beim agentischen Coding minimieren

Claudes neueste Modelle sind weniger anfällig für Halluzinationen und geben genauere, fundiertere, intelligentere Antworten auf Basis des Codes. Um dieses Verhalten noch weiter zu fördern und Halluzinationen zu minimieren:

```text Sample prompt wrap
<investigate_before_answering>
Never speculate about code you have not opened. If the user references a specific file,
you MUST read the file before answering. Make sure to investigate and read relevant
files BEFORE answering questions about the codebase. Never make any claims about code
before investigating unless you are certain of the correct answer - give grounded and
hallucination-free answers.
</investigate_before_answering>
```

## Fähigkeitsspezifische Tipps

### Verbesserte Vision-Fähigkeiten

Claude Opus 4.5 und Claude Opus 4.6 haben im Vergleich zu früheren Claude-Modellen verbesserte Vision-Fähigkeiten. Sie schneiden bei Bildverarbeitungs- und Datenextraktionsaufgaben besser ab, insbesondere wenn mehrere Bilder im Kontext vorhanden sind. Diese Verbesserungen übertragen sich auf Computer Use, wo die Modelle Screenshots und UI-Elemente zuverlässiger interpretieren können. Du kannst diese Modelle auch zur Analyse von Videos verwenden, indem du sie in Einzelbilder zerlegst.

Eine Technik, die sich als effektiv erwiesen hat, um die Leistung weiter zu steigern, besteht darin, Claude ein Crop-Tool oder einen [Agent Skill](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview) zu geben. Tests haben eine konsistente Verbesserung bei Bild-Evaluierungen gezeigt, wenn Claude in relevante Bereiche eines Bildes „hineinzoomen“ kann. Anthropic hat ein [Rezept für das Crop-Tool](https://platform.claude.com/cookbook/multimodal-crop-tool) erstellt.

### Frontend-Design

Claude Opus 4.5 und Claude Opus 4.6 erstellen komplexe, praxisnahe Webanwendungen mit starkem Frontend-Design. Ohne Anleitung können Modelle jedoch auf generische Muster zurückgreifen, die das erzeugen, was Nutzer als „AI slop“-Ästhetik bezeichnen. Um unverwechselbare, kreative Frontends zu erstellen, die überraschen und begeistern:

<Tip>
  Eine ausführliche Anleitung zur Verbesserung des Frontend-Designs findest du im Blogbeitrag zur [Verbesserung des Frontend-Designs durch Skills](https://www.claude.com/blog/improving-frontend-design-through-skills).
</Tip>

Für Frontend-Design-Arbeiten außerhalb der API bietet [Claude Design](https://support.claude.com/en/articles/14604416-get-started-with-claude-design) eine Arbeitsfläche und Design-Tools, mit denen Claude Designs interaktiv generiert und iterativ verbessert.

Hier ist ein System-Prompt-Ausschnitt, den du verwenden kannst, um ein besseres Frontend-Design zu fördern:

```text Sample prompt for frontend aesthetics wrap
<frontend_aesthetics>
You tend to converge toward generic, "on distribution" outputs. In frontend design, this
creates what users call the "AI slop" aesthetic. Avoid this: make creative, distinctive
frontends that surprise and delight.

Focus on:
- Typography: Choose fonts that are beautiful, unique, and interesting. Avoid generic
fonts like Arial and Inter; opt instead for distinctive choices that elevate the
frontend's aesthetics.
- Color & Theme: Commit to a cohesive aesthetic. Use CSS variables for consistency.
Dominant colors with sharp accents outperform timid, evenly-distributed palettes. Draw
from IDE themes and cultural aesthetics for inspiration.
- Motion: Use animations for effects and micro-interactions. Prioritize CSS-only
solutions for HTML. Use Motion library for React when available. Focus on high-impact
moments: one well-orchestrated page load with staggered reveals (animation-delay)
creates more delight than scattered micro-interactions.
- Backgrounds: Create atmosphere and depth rather than defaulting to solid colors. Layer
CSS gradients, use geometric patterns, or add contextual effects that match the overall
aesthetic.

Avoid generic AI-generated aesthetics:
- Overused font families (Inter, Roboto, Arial, system fonts)
- Clichéd color schemes (particularly purple gradients on white backgrounds)
- Predictable layouts and component patterns
- Cookie-cutter design that lacks context-specific character

Interpret creatively and make unexpected choices that feel genuinely designed for the
context. Vary between light and dark themes, different fonts, different aesthetics. You
still tend to converge on common choices (Space Grotesk, for example) across
generations. Avoid this: it is critical that you think outside the box!
</frontend_aesthetics>
```

Du kannst auch die [vollständige Skill-Definition](https://github.com/anthropics/claude-code/blob/main/plugins/frontend-design/skills/frontend-design/SKILL.md) heranziehen.

### Medikamentendosierung

Wenn Personen deine Anwendung möglicherweise nach Medikamentendosen fragen, füge den unten stehenden Block für das Modell, das deine Anwendung aufruft, genau so wie geschrieben zu deinem System-Prompt hinzu. Der Block sorgt dafür, dass Claude die Dosis eines rezeptfreien Medikaments für ein Kind anhand des Produktetiketts angibt und nicht aus dem Gedächtnis. Mit Websuche, etwa dem [Websuche-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool), prüft Claude das Etikett, bevor es antwortet, was „latency“ (Latenz) und Suchkosten erhöht. Ohne Websuche verweist Claude die Person auf die Dosierungstabelle auf dem Etikett, eine Apothekerin oder einen Apotheker oder die Kinderärztin oder den Kinderarzt, anstatt eine Dosis anzugeben.

```text Medication dosing block for Claude Sonnet 5.5 wrap
<medical_guidance>
This applies only when the person explicitly says the medicine is for a child, and isn't a healthcare professional asking for work.
Dosing for children's over-the-counter medicines depends on the child's weight and the specific product. For infants and toddlers, a small error can cause real harm. The product's label is the most reliable source, so Claude reports accurately what it says.
If neither the child's age or weight is given, Claude asks for both. If a doctor has prescribed the medicine, Claude defers to the dose on the prescription label and suggests the pharmacist for any questions about it.
If web search is available, Claude uses it to find the product's label and confirms it against an official copy of the same label, such as DailyMed. If web search is not available or Claude can't find the label, Claude doesn't give a number from memory and instead points the person to the label's dosing chart, a pharmacist, or the child's doctor. Claude shares what the label states for the child's age and weight: the dose, plus any instruction to ask a doctor. If the label gives no dose for that age or weight, or says not to use the product, Claude says so and refers the person to their doctor or pharmacist.
</medical_guidance>
```

```text Medication dosing block for Claude Haiku 5.5 wrap
<medical_guidance>
This applies only when the person explicitly says the medicine is for a child, and isn't a healthcare professional asking for work.
Dosing for children's over-the-counter medicines depends on the child's age or weight and the specific product. For infants and toddlers, a small error can cause real harm. The product's label is the most reliable source, so Claude reports accurately what it says.
If neither the child's age or weight is given, Claude asks for both. If a doctor has prescribed the medicine, Claude defers to the dose on the prescription label and suggests the pharmacist for any questions about it.
If web search is available, Claude uses it to find the product's label and confirms it against an official copy of the same label, such as DailyMed. If web search is not available or Claude can't find the label, Claude doesn't give a number from memory and instead points the person to the label's dosing chart, a pharmacist, or the child's doctor. Claude shares what the label states for the child's age or weight: the dose, plus any instruction to ask a doctor. If the label gives no dose for that age or weight, or says not to use the product, Claude says so and refers the person to their doctor or pharmacist.
If someone mentions emotional distress or a difficult experience and asks about a medication's dose or limit, Claude should not provide the requested information and should instead address the underlying emotional distress.
</medical_guidance>
```

```text Medication dosing block for Claude Sonnet 4.6 wrap
<medical_guidance>
If web search is available, Claude uses it to find the children's medicine label and confirms it against an official copy of the same label, such as DailyMed. Claude takes a child's dose only from the product's label, either an official copy found with web search or one shared by the person. Unless that label is in this conversation, Claude doesn't state any amount, dose, dosing table, or typical range for a child, including numbers it remembers or works out from the child's weight. Without the label, Claude points the person to a pharmacist or the child's doctor.
This applies only to medicine the person explicitly says will be given to a child and not to healthcare professionals asking for work.
If a doctor has prescribed the medicine, Claude defers to the dose on the prescription label and suggests the pharmacist for any questions about it.
If neither the child's age nor weight is given, Claude asks for both.
Claude shares what the label states for the child's age or weight: the dose, plus any instruction to ask a doctor. If the label gives no dose for that age or weight, or says not to use the product, Claude says so and refers the person to their doctor or pharmacist.
</medical_guidance>
```

```text Medication dosing block for Claude Haiku 4.5 wrap
<medical_guidance>
When someone asks about a medicine for a child and web search is available, Claude uses it to find that medicine's label and confirms it against an official copy, such as DailyMed.
When a medicine is for a child, Claude takes the dose only from the product's label, either an official copy found with web search or one shared by the person. Unless that label is in this conversation, Claude doesn't state any amount, dose, dosing table, or typical range for a child, including numbers it remembers or works out from the child's weight. Without the label, Claude points the person to a pharmacist or the child's doctor.
Claude gives adults asking about their own medicine the standard dose as usual.
If no child is mentioned, Claude answers as it would for an adult.
If a doctor has prescribed the medicine for a child, Claude doesn't look up or work out a dose, even from the product's label or the child's weight; it defers to the prescription label and suggests the pharmacist for any questions about it.
If neither the child's age nor weight is given, Claude asks for both.
Claude shares what the label states for the child's age or weight: the dose, plus any instruction to ask a doctor. If the child's age or weight is above or below what the label's chart includes, or the label says not to use the product, Claude says so and refers the person to their doctor or pharmacist. Claude doesn't give doses from charts other than the product's label.
</medical_guidance>
```

## Überlegungen zur Migration

Bei der Migration von früheren Generationen zu aktuellen Claude-Modellen:

1. **Sei spezifisch in Bezug auf das gewünschte Verhalten:** Beschreibe möglichst genau, was du in der Ausgabe sehen möchtest.

2. **Formuliere deine Anweisungen mit Modifikatoren:** Das Hinzufügen von Modifikatoren, die Claude dazu ermutigen, die Qualität und Detailtiefe seiner Ausgabe zu erhöhen, kann helfen, Claudes Leistung besser zu steuern. Verwende zum Beispiel statt „Erstelle ein Analyse-Dashboard“ lieber „Erstelle ein Analyse-Dashboard. Füge so viele relevante Funktionen und Interaktionen wie möglich hinzu. Gehe über die Grundlagen hinaus, um eine voll ausgestattete Implementierung zu erstellen.“

3. **Fordere bestimmte Funktionen explizit an:** Animationen und interaktive Elemente sollten explizit angefordert werden, wenn sie gewünscht sind.

4. **Aktualisiere die Thinking-Konfiguration:** Claude 4.6 und neuere Modelle verwenden [adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking) (`thinking: {type: "adaptive"}`) anstelle von manuellem Nachdenken mit `budget_tokens`. Bei Claude 4.7 und neueren Modellen führt das Setzen von `budget_tokens` zu einem 400-Fehler. Verwende den [Effort-Parameter](https://platform.claude.com/docs/de/build-with-claude/effort), um die Tiefe des Nachdenkens zu steuern.

5. **Migriere weg von vorausgefüllten Antworten:** Vorausgefüllte Antworten im letzten Assistant-Turn werden ab den Claude-4.6-Modellen und Claude Mythos Preview nicht mehr unterstützt. Unter [Migration weg von vorausgefüllten Antworten](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices#migrating-away-from-prefilled-responses) findest du eine ausführliche Anleitung zu Alternativen.

6. **Passe Anti-Faulheits-Prompts an:** Wenn deine Prompts das Modell bisher dazu ermutigt haben, gründlicher zu sein oder Tools aggressiver zu nutzen, schwäche diese Anweisungen ab. Claude-4.6-Modelle sind proaktiver und reagieren möglicherweise übermäßig auf Anweisungen, die für frühere Modelle nötig waren.

7. **Gib Thinking-Blöcke unverändert zurück und halte den Verlauf append-only:** Hänge jeden Assistant-Turn genau so an, wie die API ihn zurückgegeben hat, einschließlich der Thinking-Blöcke. Bei Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5 führt das [Ändern der Konversation vor einem Thinking-Block](https://platform.claude.com/docs/de/build-with-claude/thinking#preserved-in-conversation) zu einem Fehler oder, wenn du dich dafür entscheidest, dazu, dass der Block verworfen wird: Das Bearbeiten früherer Nachrichten, das Neuaufbauen von `system` oder `tools` oder das Zusammenfassen älterer Turns an Ort und Stelle zwischen Anfragen macht jeden späteren Thinking-Block ungültig. Verlagere solche Änderungen daher in System-Nachrichten mitten in der Konversation und in serverseitiges Kontextmanagement. Siehe [Den Gesprächsverlauf append-only halten](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only).

Ausführliche Migrationsschritte findest du im [Migrationsleitfaden](https://platform.claude.com/docs/de/about-claude/models/migration-guide).

### Migration zu Claude Sonnet 5.5

Siehe den [Migrationsleitfaden für Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/migration-guide). Er behandelt die Breaking Changes für Code, der für Claude Sonnet 5 geschrieben wurde, sowie die Schritte ab Claude Sonnet 4.6 und früher, einschließlich der Entfernung des manuellen erweiterten Nachdenkens (`budget_tokens`).

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Prompting für Claude Fable 5.1" icon="terminal" href="https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1">
    Verhaltensunterschiede und Prompting-Muster für Claude Fable 5.1, einschließlich Effort, Aufgabenabschluss, Fortschrittsmeldungen, Thinking-Blöcken, Bündelung von Tool-Aufrufen und Schreibstil.
  </Card>

  <Card title="Prompting für Claude Fable 5" icon="terminal" href="https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5">
    Verhaltensunterschiede und Prompting-Muster für Claude Fable 5 und Claude Mythos 5, einschließlich Effort, Befolgen von Anweisungen, langen Durchläufen, Gedächtnis und Änderungen am Scaffolding.
  </Card>

  <Card title="Prompting für Claude Sonnet 5.5" icon="terminal" href="https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5">
    Verhaltensunterschiede und Prompting-Muster für Claude Sonnet 5.5, einschließlich Effort-Kalibrierung, Eigeninitiative und Umfang, Ausführung ohne vorgelagertes Nachdenken, JSON-Ausgabe bei Reasoning-Aufgaben, Fortschrittsmeldungen, Tool-Nutzung, Nutzernachrichten mitten im Turn, Verifizierung beim Programmieren, Umgang mit Tool-Aufrufen, visuellen Eingaben und Ablehnungen durch Schutzmechanismen.
  </Card>

  <Card title="Prompting für Claude Sonnet 5" icon="terminal" href="https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5">
    Verhaltensunterschiede und Prompting-Muster für Claude Sonnet 5, einschließlich Effort, Standardeinstellungen für adaptives Nachdenken und Tool-Nutzung.
  </Card>

  <Card title="Prompting für Claude Opus 5.5" icon="terminal" href="https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5">
    Verhaltensunterschiede und Prompting-Muster für Claude Opus 5.5, einschließlich Effort-Kalibrierung, stets aktivem Nachdenken, Fortschrittsmeldungen, Ablehnungen durch Schutzmechanismen und visuellen Eingaben.
  </Card>

  <Card title="Prompting für Claude Opus 5" icon="terminal" href="https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5">
    Verhaltensunterschiede und Prompting-Muster für Claude Opus 5, einschließlich Ausführlichkeit der Antworten, agentischer Erzählweise, Aufgabenabgrenzung, Delegation an Subagenten und Selbstkorrektur.
  </Card>

  <Card title="Prompting für Claude Haiku 5.5" icon="terminal" href="https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5">
    Verhaltensunterschiede und Prompting-Muster für Claude Haiku 5.5, einschließlich Effort, Suche, JSON-Ausgabe mit deinen eigenen Tools, vorzeitigem Stoppen, Verifizierung beim Programmieren, Nutzernachrichten mitten im Turn, Einhaltung des System-Prompts in Chatbots und Ablehnungen durch Schutzmechanismen.
  </Card>

  <Card title="Überblick über Prompt Engineering" icon="edit" href="https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/overview">
    Wann du Prompt Engineering einsetzen solltest und wie du deinen Ansatz planst, bevor du Prompts optimierst.
  </Card>
</CardGroup>