Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du
.md an die URL der Seite anhängst.
Erziele bessere Ergebnisse mit Prompt Engineering.
Responses
Mit der OpenAI API kannst du ein großes Sprachmodell anhand eines Prompts Text generieren lassen, wie du es vielleicht von ChatGPT kennst. Modelle können Textantworten in nahezu jeder Form generieren, etwa Code, mathematische Gleichungen, strukturierte JSON-Daten oder natürlich klingende Prosa.
1
2
3
4
5
6
7
8
9
10require "openai"openai = OpenAI::Client.newresponse = openai.responses.create( model: "gpt-6-astra", input: "Write a one-sentence bedtime story about a unicorn.")puts(response.output_text)
1
2
3
4
5openai responses create \ --model "gpt-6-astra" \ --input "Write a one-sentence bedtime story about a unicorn." \ --raw-output \ --transform 'output.#(type=="message").content.0.text'
1
2
3
4
5
6
7curl "https://api.openai.com/v1/responses" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{ "model": "gpt-6-astra", "input": "Write a one-sentence bedtime story about a unicorn." }'
Die vom Modell generierten Inhalte findest du als Array in der Eigenschaft output der Antwort. In diesem Beispiel enthält das Array nur eine Ausgabe:
1234567891011121314[ { "id": "msg_67b73f697ba4819183a15cc17d011509", "type": "message", "role": "assistant", "content": [ { "type": "output_text", "text": "Under the soft glow of the moon, Luna the unicorn danced through fields of twinkling stardust, leaving trails of dreams for every child asleep.", "annotations": [] } ] }]
Das Array output enthält häufig mehr als ein Element! Es kann Tool-Aufrufe, Daten zu den von Reasoning-Modellen generierten Reasoning-Tokens und weitere Elemente enthalten. Verlass dich deshalb nicht darauf, die Textausgabe des Modells unter output[0].content[0].text zu finden.
Einige unserer offiziellen SDKs stellen für Modellantworten die Eigenschaft output_text bereit. Sie fasst alle Textausgaben des Modells in einer einzigen Zeichenkette zusammen. So kannst du direkt auf den generierten Text zugreifen.
Neben reinem Text kann das Modell auch strukturierte Daten im JSON-Format zurückgeben. Diese Funktion heißt strukturierte Ausgaben.
Die vom Modell generierten Inhalte findest du als Array in der Eigenschaft choices der Antwort. In diesem Beispiel enthält das Array nur eine Ausgabe:
123456789101112[ { "index": 0, "message": { "role": "assistant", "content": "Under the soft glow of the moon, Luna the unicorn danced through fields of twinkling stardust, leaving trails of dreams for every child asleep.", "refusal": null }, "logprobs": null, "finish_reason": "stop" }]
Neben reinem Text kann das Modell auch strukturierte Daten im JSON-Format zurückgeben. Diese Funktion heißt strukturierte Ausgaben.
Ein Modell auswählen
Wenn du Inhalte über die API generierst, ist die Wahl des Modells eine wichtige Entscheidung. In den Codebeispielen oben legst du es mit dem Parameter model fest. Hier findest du alle verfügbaren Modelle. Bei der Auswahl eines Modells für die Textgenerierung spielen folgende Faktoren eine Rolle.
Reasoning-Modelle erzeugen eine interne Gedankenkette, um den Prompt zu analysieren. Sie können komplexe Aufgaben besonders gut erfassen und Abläufe mit mehreren Schritten planen. In der Regel sind sie langsamer und teurer im Einsatz als GPT-Modelle.
GPT-Modelle sind schnell, kosteneffizient und sehr leistungsfähig. Sie profitieren von ausdrücklichen Anweisungen dazu, wie sie eine Aufgabe lösen sollen.
Große und kleine Modelle (mini oder nano) unterscheiden sich in Geschwindigkeit, Kosten und Leistungsfähigkeit. Große Modelle verstehen Prompts besser und können Probleme aus unterschiedlichen Fachgebieten besser lösen. Kleine Modelle sind in der Regel schneller und günstiger im Einsatz.
Im Zweifel ist gpt-6-astra eine gute Standardwahl, wenn du Texte für unterschiedliche Zwecke generieren oder Prompts schrittweise verbessern möchtest.
Prompt Engineering
Beim Prompt Engineering formulierst du Anweisungen so, dass ein Modell zuverlässig Inhalte generiert, die deinen Anforderungen entsprechen.
Modelle generieren Inhalte nicht deterministisch. Um mit einem Prompt die gewünschte Ausgabe zu erhalten, brauchst du deshalb sowohl eine systematische Vorgehensweise als auch ein Gespür für die richtige Formulierung. Mit bewährten Techniken kannst du regelmäßig gute Ergebnisse erzielen.
Einige Techniken des Prompt Engineering funktionieren bei jedem Modell, etwa der Einsatz von Nachrichtenrollen. Unterschiedliche Modelltypen wie Reasoning- und GPT-Modelle benötigen jedoch unter Umständen unterschiedliche Prompts, um die besten Ergebnisse zu erzielen. Selbst verschiedene Snapshots derselben Modellfamilie können unterschiedliche Ergebnisse liefern. Wenn du komplexere Anwendungen entwickelst, empfehlen wir dir daher ausdrücklich folgende Maßnahmen:
Lege für deine Anwendungen im Produktivbetrieb bestimmte Modell-Snapshots fest (etwa gpt-4.1-2025-04-14), damit sich das Modell konsistent verhält.
Entwickle Tests und Evaluationssuiten, die messen, wie sich deine Prompts auswirken. So kannst du die Leistung verfolgen, wenn du Prompts überarbeitest oder auf eine andere oder neuere Modellversion wechselst.
Die folgenden Werkzeuge und Techniken helfen dir, Prompts zu formulieren.
Nachrichtenrollen und das Befolgen von Anweisungen
Du kannst dem Modell Anweisungen mit unterschiedlichem Vorrang geben. Dazu verwendest du den API-Parameter instructions oder Nachrichtenrollen.
Mit dem Parameter instructions gibst du dem Modell übergeordnete Anweisungen für die Antwort. Du kannst den Ton und die Ziele vorgeben und Beispiele für korrekte Antworten nennen. Diese Anweisungen haben Vorrang vor einem Prompt im Parameter input.
Der Parameter instructions gilt nur für die aktuelle Anfrage zur Antwortgenerierung. Wenn du den Gesprächszustand mit dem Parameter previous_response_id verwaltest, sind die instructions aus früheren Gesprächsrunden im aktuellen Kontext nicht enthalten.
Du kannst dem Modell Anweisungen (Prompts) mit unterschiedlichem Vorrang geben. Dazu verwendest du Nachrichtenrollen.
Text mit Nachrichten unterschiedlicher Rollen generieren
developer-Nachrichten enthalten Anweisungen von Entwickelnden. Sie haben Vorrang vor user-Nachrichten.
user-Nachrichten enthalten Anweisungen von denjenigen, die die Anwendung nutzen. Sie sind den developer-Nachrichten nachgeordnet.
Vom Modell generierte Nachrichten haben die Rolle assistant.
Ein Gespräch über mehrere Runden kann mehrere Nachrichten dieser Typen enthalten. Sowohl du als auch das Modell können weitere Arten von Inhalten beisteuern. Mehr dazu erfährst du im Leitfaden zum Verwalten des Gesprächszustands.
Das Zusammenspiel von developer- und user-Nachrichten ähnelt dem einer Funktion und ihrer Argumente in einer Programmiersprache.
developer-Nachrichten geben wie eine Funktionsdefinition die Regeln und die Geschäftslogik des Systems vor.
user-Nachrichten liefern wie Funktionsargumente die Eingaben und die Konfiguration, auf die das Modell die Anweisungen aus der developer-Nachricht anwendet.
Prompts im Code versionieren
Speichere Prompts für den Produktivbetrieb direkt im Anwendungscode, anstatt wiederverwendbare Prompt-Objekte anzulegen. Wenn du Prompts im Code verwaltest, kannst du typisierte Eingaben, Code-Reviews, Tests und deinen gewohnten Deployment-Prozess nutzen, um das Modellverhalten zu ändern.
OpenAI stellt die Unterstützung für wiederverwendbare Prompt-Objekte in der API ein. Ab dem 3. Juni 2026 rückt das Erstellen solcher Prompts in den Hintergrund. Die Abschaltung von v1/prompts ist für den 30. November 2026 geplant. Den aktuellen Zeitplan findest du in der Übersicht zu auslaufenden Funktionen.
Wenn du neue Prompts entwickelst, gehe so vor:
Lege die Funktionen, die Prompts zusammensetzen, in einem kleinen Modul nahe am Code der zugehörigen Funktionalität ab.
Verwende typisierte Funktionsargumente oder Schemas für dynamische Werte wie Kundendaten, Dateien oder Aufgabenoptionen.
Übergib die generierten Werte für instructions und input direkt an die Responses API.
Ergänze repräsentative Testdaten, Tests und Evaluationsprüfungen, bevor du Prompts für den Produktivbetrieb änderst.
Veröffentliche Prompt-Änderungen über dein Deployment-System. Nutze Feature-Flags oder Konfigurationseinstellungen, wenn du Änderungen schrittweise ausrollen möchtest.
Wenn deine Integration bereits einen gespeicherten Prompt über eine Prompt-ID oder eine Version aufruft, überführe ihn mithilfe des Migrationsleitfadens für Prompt-Objekte in deinen Code.
Nachrichten mit Markdown und XML formatieren
In developer- und user-Nachrichten kannst du mit Markdown und XML-Tags verdeutlichen, wie dein Prompt aufgebaut ist und welche Inhalte zu den Kontextdaten gehören.
Mit Markdown-Überschriften und -Listen kannst du Abschnitte eines Prompts voneinander abgrenzen und dem Modell ihre Hierarchie verdeutlichen. Dadurch lassen sich deine Prompts auch während der Entwicklung leichter lesen. XML-Tags können kennzeichnen, wo ein Inhalt beginnt und endet, etwa ein als Referenz beigefügtes Dokument. Mit XML-Attributen kannst du außerdem Metadaten für Inhalte im Prompt definieren und in deinen Anweisungen darauf verweisen.
Eine Entwicklernachricht enthält in der Regel die folgenden Abschnitte in der angegebenen Reihenfolge. Welche Inhalte und welche Reihenfolge am besten funktionieren, kann je nach Modell variieren.
Identität: Beschreibe Zweck, Kommunikationsstil und übergeordnete Ziele des Assistenten.
Anweisungen: Erkläre dem Modell, wie es die gewünschte Antwort generieren soll. Welche Regeln soll es befolgen? Was soll es tun, und was darf es auf keinen Fall tun? Je nach Anwendungsfall kannst du diesen Abschnitt weiter untergliedern und etwa angeben, wie das Modell benutzerdefinierte Funktionen aufrufen soll.
Beispiele: Zeige mögliche Eingaben zusammen mit der jeweils gewünschten Ausgabe des Modells.
Kontext: Gib dem Modell zusätzliche Informationen, die es für die Antwort benötigen könnte, etwa private oder unternehmenseigene Daten, die in den Trainingsdaten fehlen, oder andere Daten, die für die Aufgabe besonders relevant sind. Platziere diese Inhalte möglichst gegen Ende des Prompts, da du je nach Anfrage unterschiedlichen Kontext mitgeben kannst.
Das folgende Beispiel zeigt, wie du eine developer-Nachricht mit Markdown und XML-Tags in Abschnitte gliederst und durch Beispiele ergänzt.
Beispiel-Prompt
Eine Entwicklernachricht zur Codegenerierung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24# IdentityYou are coding assistant that helps enforce the use of snake casevariables in JavaScript code, and writing code that will run inInternet Explorer version 6.# Instructions* When defining variables, use snake case names (e.g. my_variable) instead of camel case names (e.g. myVariable).* To support old browsers, declare variables using the older "var" keyword.* Do not give responses with Markdown formatting, just return the code as requested.# Examples<user_query>How do I declare a string variable for a first name?</user_query><assistant_response>var first_name = "Anna";</assistant_response>
API-Anfrage
Einen Prompt zur Codegenerierung über die API senden
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13import fs from"fs/promises";import OpenAI from"openai";constclient=newOpenAI();constinstructions=await fs.readFile("fixtures/prompt.txt", "utf-8");constresponse=await client.responses.create({ model: "gpt-6-astra", instructions, input: "How would I declare a variable for a last name?",});console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14from openai import OpenAIclient = OpenAI()with open("prompt.txt", "r", encoding="utf-8") as f: instructions = f.read()response = client.responses.create( model="gpt-6-astra", instructions=instructions, input="How would I declare a variable for a last name?",)print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.models.responses.ResponseCreateParams;ResponseCreateParams params = ResponseCreateParams.builder() .model("gpt-6-astra") .instructions( "You are a coding assistant. Answer with concise JavaScript examples and use semicolons.") .input("How would I declare a variable for a last name?") .build();client.responses().create(params).output().stream() .flatMap(item -> item.message().stream()) .flatMap(message -> message.content().stream()) .flatMap(content -> content.outputText().stream()) .forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18using OpenAI.Responses;#pragma warning disable OPENAI001string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;ResponsesClient client = new(key);string instructions = await File.ReadAllTextAsync("prompt.txt");CreateResponseOptions options = new(){ Model = "gpt-6-astra", Instructions = instructions,};options.InputItems.Add( ResponseItem.CreateUserMessageItem("How would I declare a variable for a last name?"));ResponseResult response = await client.CreateResponseAsync(options);Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11require "openai"client = OpenAI::Client.newinstructions = File.read(File.join(__dir__, "prompt.txt"))response = client.responses.create( model: "gpt-6-astra", instructions: instructions, input: "How would I declare a variable for a last name?")puts(response.output_text)
1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-6-astra", "instructions": "'"$(< prompt.txt)"'", "input": "How would I declare a variable for a last name?" }'
Kosten und Latenz mit Prompt-Caching senken
Platziere Inhalte, die du voraussichtlich in vielen API-Anfragen wiederverwendest, möglichst am Anfang deines Prompts und unter den ersten API-Parametern im JSON-Anfragetext für Chat Completions oder Responses. So kannst du Kosten und Latenz mit Prompt-Caching so weit wie möglich reduzieren.
Few-Shot-Lernen
Beim Few-Shot-Lernen führst du ein großes Sprachmodell an eine neue Aufgabe heran, indem du im Prompt einige Beispiele für Eingaben und die zugehörigen Ausgaben angibst. Ein Fine-Tuning des Modells ist dafür nicht nötig. Das Modell erkennt das Muster in den Beispielen und wendet es auf den Prompt an. Wähle möglichst unterschiedliche Eingaben und zeige jeweils die gewünschte Ausgabe.
Üblicherweise gibst du die Beispiele in einer developer-Nachricht in deiner API-Anfrage an. Die folgende developer-Nachricht zeigt dem Modell anhand von Beispielen, wie es positive und negative Bewertungen des Kundenservice einordnen soll.
# IdentitätDu bist ein hilfreicher Assistent und ordnest kurze Produktbewertungen den KategorienPositive, Negative oder Neutral zu.# Anweisungen* Antworte mit einem einzigen Wort ohne zusätzliche Formatierung oder Kommentare.* Gib je nach Stimmung der vorliegenden Produktbewertung ausschließlich eines der Wörter „Positive“, „Negative“ oder „Neutral“ aus.# Beispiele<product_review id="example-1">Ich liebe diese Kopfhörer. Der Klang ist einfach fantastisch!</product_review><assistant_response id="example-1">Positive</assistant_response><product_review id="example-2">Die Akkulaufzeit ist okay, aber die Ohrpolster fühlen sich billig an.</product_review><assistant_response id="example-2">Neutral</assistant_response><product_review id="example-3">Schrecklicher Kundenservice. Da kaufe ich nie wieder ein.</product_review><assistant_response id="example-3">Negative</assistant_response>
Relevanten Kontext mitgeben
Oft ist es sinnvoll, dem Modell im Prompt zusätzliche Informationen zu geben, die es für seine Antwort nutzen kann. Häufige Gründe dafür sind:
Du möchtest dem Modell unternehmenseigene Daten oder andere Informationen zugänglich machen, die nicht in seinen Trainingsdaten enthalten sind.
Du möchtest die Antwort auf bestimmte Quellen beschränken, die du als besonders hilfreich eingestuft hast.
Das Verfahren, eine Anfrage an das Modell um relevanten Kontext zu ergänzen, wird auch als Retrieval-Augmented Generation (RAG) bezeichnet. Du kannst Kontext auf verschiedene Weise hinzufügen. Beispielsweise kannst du eine Vektordatenbank abfragen und den zurückgegebenen Text in den Prompt einfügen. Mit dem integrierten Tool zur Dateisuche von OpenAI kannst du Inhalte auf Grundlage hochgeladener Dokumente generieren lassen.
Die Größe des Kontextfensters berücksichtigen
Bei einer Anfrage kann das Modell nur eine begrenzte Datenmenge als Kontext verarbeiten. Diese Speichergrenze heißt Kontextfenster. Seine Größe wird in Tokens angegeben, also in Einheiten, in die deine Eingabedaten, etwa Texte oder Bilder, zerlegt werden.
Die Größe des Kontextfensters variiert je nach Modell. Sie reicht vom niedrigen sechsstelligen Bereich bis zu einer Million Tokens bei neueren GPT-4.1-Modellen. In der Modelldokumentation findest du die genaue Größe für jedes Modell.
Prompts für aktuelle Modelle formulieren
GPT-Modelle wie gpt-6-astra profitieren von präzisen Anweisungen. Gib im Prompt ausdrücklich die Logik und die Daten an, die das Modell für die Aufgabe braucht. Der aktuelle Leitfaden hilft dir beim Einstieg, wenn du das neueste Modell optimal nutzen möchtest.
Wenn du gpt-6-astra für Programmieraufgaben einsetzt, haben sich folgende Vorgaben im Prompt bewährt: Definiere die Rolle des Agenten, gib anhand von Beispielen eine strukturierte Tool-Nutzung vor, verlange gründliche Tests auf Korrektheit und lege Markdown-Regeln für eine sauber formatierte Ausgabe fest.
Klare Vorgaben zu Rolle und Arbeitsablauf
Weise dem Modell die Rolle eines Agenten für Softwareentwicklung mit klar definierten Aufgaben zu. Erkläre, wie es bei Programmieraufgaben Tools wie functions.run verwenden soll. Gib auch an, wann es bestimmte Modi meiden soll. Beispielsweise soll es Code nur bei Bedarf interaktiv ausführen.
Tests und Validierung
Weise das Modell an, Änderungen mit Unit-Tests oder Python-Befehlen zu testen und Patches sorgfältig zu prüfen. Tools wie apply_patch können selbst bei einem Fehler „Done“ zurückgeben.
Beispiele für Tool-Aufrufe
Zeige an konkreten Beispielen, wie das Modell Befehle mit den bereitgestellten Funktionen aufrufen soll. Dadurch arbeitet es zuverlässiger und hält sich eher an die vorgesehenen Abläufe.
Markdown-Regeln
Weise das Modell an, übersichtliches, semantisch korrektes Markdown zu erzeugen. Es soll je nach Inhalt Inline-Code, abgegrenzte Codeblöcke, Listen und Tabellen verwenden und Dateipfade, Funktionen und Klassen in Backticks setzen.
eignet sich sowohl für die Entwicklung neuer Frontends als auch für die Mitarbeit an großen, etablierten Codebasen. Für optimale Ergebnisse empfehlen wir die folgenden Bibliotheken:
Styling und Benutzeroberfläche: Tailwind CSS, shadcn/ui, Radix Themes
Symbole: Lucide, Material Symbols, Heroicons
Animation: Motion
Web-Apps von Grund auf entwickeln
GPT-5 kann mit einem einzigen Prompt das Frontend einer Web-App generieren. Beispiele sind dafür nicht erforderlich. So kann ein Prompt aussehen:
123456Du beherrschst die Webentwicklung auf höchstem Niveau und kannst mit einem einzigen Prompt beeindruckende, interaktive und innovative Websites von Grund auf entwickeln. Deine Stärke sind erstklassige One-Shot-Lösungen.Gehe in vier Schritten vor:Schritt 1: Erstelle ein Bewertungsraster und verfeinere es, bis du davon vollständig überzeugt bist.Schritt 2: Überlege, was eine erstklassige One-Shot-Web-App ausmacht. Erstelle daraus ein <ONE_SHOT_RUBRIC> mit 5–7 Kategorien. Behalte das Raster für dich. Es ist ausschließlich für den internen Gebrauch bestimmt.Schritt 3: Nutze das Raster, um die Lösung für den vorliegenden Prompt schrittweise zu optimieren. Falls sie noch nicht in allen Kategorien den höchsten Anforderungen genügt, verbessere sie und versuche es erneut.Schritt 4: Halte die Lösung so einfach wie möglich und erreiche das Ziel vollständig. Vermeide externe Abhängigkeiten wie Next.js oder React.
Integration in große Codebasen
Bei der Frontend-Entwicklung in größeren Codebasen haben wir die besten Ergebnisse erzielt, wenn die Prompts Anweisungen zu folgenden Punkten enthielten:
Grundsätze: Lege Standards für die visuelle Qualität fest, verwende modulare, wiederverwendbare Komponenten und achte auf ein einheitliches Design.
UI/UX: Mache Vorgaben zu Typografie, Farben, Abständen, Layout, Interaktionszuständen (etwa beim Überfahren mit dem Mauszeiger, bei leeren Inhalten oder beim Laden) und Barrierefreiheit.
Struktur: Lege die Datei- und Ordnerstruktur fest, damit sich der neue Code nahtlos integrieren lässt.
Komponenten: Gib Beispiele für wiederverwendbare Wrapper und zeige, wie sich Backend-Aufrufe vom übrigen Code trennen lassen.
Seiten: Stelle Vorlagen für häufig verwendete Layouts bereit.
Anweisungen für den Agenten: Fordere das Modell auf, Designannahmen zu bestätigen, Projektgerüste anzulegen, Standards durchzusetzen, APIs zu integrieren, Zustände zu testen und den Code zu dokumentieren.
Wenn du gpt-6-astra für agentische und länger laufende Aufgaben einsetzt, fordere das Modell auf, die Arbeit von Anfang bis Ende zu planen. Es soll wichtige Tool-Aufrufe vor der Ausführung erklären und den Fortschritt mit einem Tool für Aufgabenlisten verfolgen.
Planung und Ausdauer
Weise das Modell an, die Anfrage vollständig zu bearbeiten, bevor es die Kontrolle zurückgibt. Dazu soll es die Anfrage in Teilaufgaben zerlegen und nach jedem Tool-Aufruf prüfen, ob noch etwas fehlt.
Denk daran, dass du ein Agent bist. Bearbeite die Anfrage vollständig, bevor du deinen Gesprächsbeitrag beendest und die Kontrolle an die Person zurückgibst, die die Anfrage gestellt hat. Zerlege die Anfrage in alle erforderlichen Teilaufgaben und bestätige für jede einzelne, dass sie erledigt ist. Höre nicht auf, wenn du erst einen Teil der Anfrage bearbeitet hast. Beende deinen Beitrag erst, wenn du sicher bist, dass das Problem gelöst ist. Sei darauf vorbereitet, mehrere Anfragen zu beantworten. Beende den Aufruf erst, wenn die Person bestätigt hat, dass sie fertig ist.Plane die nächsten Schritte anhand des vorgesehenen Arbeitsablaufs gründlich, bevor du weitere Funktionen aufrufst. Prüfe nach jedem Funktionsaufruf das Ergebnis eingehend, damit du sowohl die Anfrage als auch alle zugehörigen Teilaufgaben vollständig bearbeitest.
Wichtige Tool-Aufrufe vorab erklären
Bitte das Modell, vor einem Tool-Aufruf zu erklären, warum es das Tool verwendet. Beschränke diese Erklärungen auf wesentliche Schritte.
Erkläre vor jedem Tool-Aufruf, warum du das Tool aufrufst.
Fortschritt mit Kriterienrastern und Aufgabenlisten verfolgen
Nutze ein Tool für Aufgabenlisten oder ein Kriterienraster, um die Planung zu strukturieren und keinen Schritt zu übersehen.
Berücksichtige beim Formulieren von Prompts für ein Reasoning-Modell die Unterschiede zu einem GPT-Modell. Reasoning-Modelle erzielen bei Aufgaben in der Regel bessere Ergebnisse, wenn du ihnen nur übergeordnete Vorgaben machst. GPT-Modelle hingegen profitieren von präzisen Anweisungen.
Du kannst dir den Unterschied zwischen Reasoning- und GPT-Modellen so vorstellen:
Ein Reasoning-Modell ähnelt einem erfahrenen Teammitglied. Du gibst ihm ein Ziel und kannst darauf vertrauen, dass es die Details selbst erarbeitet.
Ein GPT-Modell ähnelt einem Teammitglied mit weniger Erfahrung. Es arbeitet am besten, wenn du ihm genaue Anweisungen für das gewünschte Ergebnis gibst.
Weitere Empfehlungen zur Arbeit mit Reasoning-Modellen findest du in diesem Leitfaden.
Nächste Schritte
Jetzt kennst du die Grundlagen der Texteingabe und -ausgabe. Mit den folgenden Ressourcen kannst du das Gelernte ausprobieren und vertiefen.