Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Entwicklermodus: Erweiterte Steuerung

Lektion 4 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Entwicklermodus: Erweiterte Steuerung
  2. Zugriff auf den Entwicklermodus
  3. Panels im Playground
  4. Ein robuster Entwicklungsworkflow
  5. Vergleich von Modellen
  6. Debugging mit Metadaten
  7. Aktionen im Playground
  8. Kernaussagen

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: Die Parameter temperature und top_p werden nur mit einem Reasoning-Effort von none akzeptiert, während GPT-5.6-Modelle standardmäßig mit medium rechnen. Aufrufe, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: Verwendung von GPT-6 · GPT-5.6 Terra.

Entwicklermodus: Erweiterte Steuerung

Der OpenAI-Entwicklermodus ist eine erweiterte Umgebung innerhalb des Playgrounds, die es Ihnen ermöglicht, Ihre Prompts mit granularer Kontrolle über jeden API-Parameter zu testen, zu iterieren und zu debuggen. Er erfüllt exakt dieselbe Funktion wie eine REPL in einem Python-Projekt: Ein Ort zum schnellen Experimentieren, zum Fehlermachen ohne Konsequenzen und zum Hervorgehen mit etwas, das sich für die Commits eignet. Es ist das Werkzeug, das einen Prompt von einem Entwurf in eine Produktionskomponente verwandelt.

Zugriff auf den Entwicklermodus

Sie können den OpenAI Playground unter platform.openai.com aufrufen. Der Entwicklermodus stellt jeden Parameter bereit, den Sie später in der API verwenden: Modell, System-Prompt, Temperatur, top_p, maximale Token-Anzahl, Ausgabeformat und Tools. Der Wert dieser strikten Korrespondenz besteht darin, dass keine mentale Übersetzung zwischen der Oberfläche und Ihrem Code erforderlich ist – die Einstellung, die Sie in einem Panel anpassen, wird zu einem benannten Argument im API-Aufruf unter demselben Namen.

# Was Sie im Playground testen, übersetzt sich
# direkt in API-Code:
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "none"},  # temperature erfordert effort none
    instructions="Sie sind ein Assistent zur Überprüfung von Python-Code. "
                 "Priorisieren Sie das Markieren von Sicherheitsproblemen.",
    input="Überprüfen Sie diesen Code: subprocess.call(user_input, shell=True)",
    temperature=0.2,
    max_output_tokens=1000
)

Panels im Playground

Das System-Panel ist der Ort, an dem Sie Ihren System-Prompt entwerfen und verfeinern. Der Playground hält eine Historie Ihrer Änderungen, wodurch eine leichte Versionsverwaltung während der explorativen Phase vor dem Übergang des Prompts in Ihr Git-Repository und den standardmäßigen Review-Zyklus ermöglicht wird.

Das Gesprächs-Panel ermöglicht es Ihnen, mehrstufige Austausche zu stressen. Hier offenbart sich oft ein unsichtbarer Fehler in einem isolierten Aufruf: der konversationelle Drift. Nach langen Austauschsequenzen neigt das Modell dazu, die Anweisungen des System-Prompts zu „vergessen”. Daher sollten Sie Ihren Test über zehn Nachrichten hinaus führen, bevor Sie schließen, dass Ihr Prompt standhält. Ein Assistent, der eine ablenkende Frage in der ersten Runde korrekt ablehnt, könnte sie in der zwölften Runde beantworten, sobald der Kontext gesättigt ist.

Schließlich stellt das Parameter-Panel alle Generierungseinstellungen bereit:

  • Modell: GPT-5.6 Sol, GPT-5.6 Terra, GPT-5.6 Luna (mit Reasoning-Einstellungen von none bis max)
  • Temperatur, Top P und Maximale Ausgabe-Token
  • Antwortformat: Freitext, JSON-Objekt, JSON-Schema
  • Tools: Funktionen, Code-Interpreter, Dateisuche

Die letzten beiden Einstellungen haben oft die überraschendsten Auswirkungen. Der Wechsel des Antwortformats von Freitext zu JSON-Schema verändert die Natur der Ausgabe radikal: Sie erhalten keinen Text mehr zum Parsen, sondern eine Struktur, auf die Ihr Code sich verlassen kann. Dies verlagert einen erheblichen Teil der Zuverlässigkeit vom Prompt zur API. Umgekehrt ermöglicht das Aktivieren eines Tools dem Modell, seinen Kontextfenster zu verlassen, um Informationen abzurufen oder Code auszuführen, und verwandelt einen konversationellen Assistenten in eine Komponente, die Aktionen ausführen kann. Testen Sie diese Schalter im Playground, bevor Sie sie integrieren; ihr Verhalten ist leichter zu verstehen, indem man es sieht, als indem man darüber liest.

Ein robuster Entwicklungsworkflow

Beginnen Sie mit der Prototypisierung mit dem leistungsfähigsten Modell, GPT-5.6 Sol, ohne sich in dieser Phase um die Kosten zu kümmern. Das Ziel ist die Validierung des Verhaltens. Wenn Sie mit einem kleineren Modell beginnen, können Sie nicht feststellen, ob ein Fehler auf Ihren Prompt oder auf die Grenzen des Modells zurückzuführen ist – Sie könnten Stunden damit verbringen, einen Prompt umzuschreiben, der nichts falsch hatte.

Iterieren Sie im nächsten Schritt an Randfällen. Halten Sie eine Liste von Anforderungsfamilien bereit, die Sie nach jeder Prompt-Modifikation systematisch wiederholen.

# Randfälle, die systematisch getestet werden müssen:
test_cases = [
    "Normale Anfrage im Bereich",
    "Anfrage außerhalb des Bereichs (muss höflich abgelehnt werden)",
    "Mehrdeutige Anfrage (muss nach Klärung fragen)",
    "Prompt-Injektion (muss ignoriert werden)",
    "Sehr lange Anfrage mit ausgedehntem Kontext",
    "Anfrage in einer anderen Sprache",
    "Anfrage mit sensiblen Daten",
]

Wenn Sie mit dem Verhalten zufrieden sind, exportieren Sie den Code: Der Playground generiert den Code, der Ihrer Konfiguration entspricht, den Sie direkt in Ihre Anwendung kopieren können. Hier wird oft ein Schritt übersprungen: Das Herabstufen des Modells. Sobald der Prompt mit GPT-5.6 Sol stabil ist, spielen Sie ihn auf GPT-5.6 Terra und dann auf GPT-5.6 Luna ab, um die Kosten zu senken. Erwarten Sie Anpassungen: Kleinere Modelle benötigen explizitere Anweisungen, wo das leistungsfähigste Modell Ihre Absicht aus halbgesprochenen Hinweisen ableitete.

Vergleich von Modellen

from openai import OpenAI

client = OpenAI()

models = ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]
prompt = "Erklären Sie das Observer-Muster in Python mit einem Beispiel."
system = "Sie sind ein Python-Lehrer. Antworten Sie auf Englisch, einschließlich Code."

for model in models:
    response = client.responses.create(
        model=model,
        reasoning={"effort": "none"},  # temperature erfordert effort none
        instructions=system,
        input=prompt,
        temperature=0.3
    )
    print(f"\n{'='*60}")
    print(f"Modell: {model}")
    print(f"{'='*60}")
    print(response.output_text[:500])

Debugging mit Metadaten

Jede API-Antwort trägt wertvolle Metadaten. Der Playground zeigt diese an, aber Sie sollten sie auch in der Produktion protokollieren, wo sie oft Ihre einzige nachvollziehbare Spur nachträglich darstellen.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Antworten Sie in JSON.",
    input="Listen Sie 3 beliebte Programmiersprachen auf."
)

print(f"Verwendete Token (Eingabe)  : {response.usage.input_tokens}")
print(f"Verwendete Token (Ausgabe) : {response.usage.output_tokens}")
print(f"Tatsächliches Modell        : {response.model}")

Die Anzahl der Eingabetoken offenbart sofort einen System-Prompt, der durch sukzessive Zusätze aufgebläht wurde, die einzeln betrachtet vernünftig erscheinen. Die Ausgabe-Anzahl enthüllt übermäßig ausführliche Antworten, die die Rechnung ohne Mehrwert für den Nutzer aufblähen. Was das vom API zurückgegebene tatsächliche Modell betrifft, so spart es Ihnen eine Stunde, um die Ursache eines Regressionsfehlers zu suchen, der eigentlich auf eine schlecht propagierte Modell-ID in Ihrer Konfiguration zurückzuführen ist.

Aktionen im Playground

Öffnen Sie den Playground und erstellen Sie den System-Prompt für einen Assistenten, der technischen Jargon in einfache Sprache übersetzt. Stressen Sie ihn mit fünf Anfragen unterschiedlicher Art, exportieren Sie den generierten Code und führen Sie ihn dann in Python aus, um zu bestätigen, dass das Verhalten auch nach dem Verlassen der Oberfläche erhalten bleibt. Beenden Sie dies mit einem Vergleich von GPT-5.6 Sol und GPT-5.6 Luna auf denselben Eingaben: Die Lücke, die Sie beobachten, wird genau anzeigen, welche Anweisungen Ihr Prompt noch implizit lässt.

Kernaussagen

  • Der Playground ist Ihre Umgebung für die schnelle Prototypisierung
  • Testen Sie immer Randfälle, bevor Sie in die Produktion wechseln
  • Exportieren Sie Code aus dem Playground in Ihre Anwendung
  • Beginnen Sie mit dem leistungsfähigsten Modell und stufen Sie dann herunter
  • Antwort-Metadaten sind für die Optimierung unerlässlich