Developer Mode: Advanced Control

Lesson updated November 3, 2026 based on OpenAI documentation: temperature and top_p are only accepted with a reasoning effort of none, whereas GPT-5.6 models reason by default (medium). Calls that set these parameters must therefore specify reasoning={"effort": "none"} (Responses API) or reasoning_effort="none" (Chat Completions). Sources: Using GPT-6 · GPT-5.6 Terra.

OpenAI’s Developer Mode is an advanced environment within the Playground that lets you test, iterate, and debug your prompts with granular control over every API parameter. It serves the exact same role as a REPL in a Python project: a place to experiment quickly, make mistakes without consequence, and emerge with something worthy of committing. It is the tool that transforms a prompt from a draft into a production component.

Accessing Developer Mode

You can access the OpenAI Playground at platform.openai.com. Developer Mode exposes every parameter you will later use in the API: model, system prompt, temperature, top_p, max tokens, output format, and tools. The value of this strict correspondence is that no mental translation is required between the interface and your code—the setting you adjust in a panel becomes a named argument in the API call, under the same name.

# What you test in the Playground translates
# directly into API code:
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "none"},  # temperature requires effort none
    instructions="You are a Python code review assistant. "
                 "Prioritize flagging security issues.",
    input="Review this code: subprocess.call(user_input, shell=True)",
    temperature=0.2,
    max_output_tokens=1000
)

Playground Panels

The System panel is where you draft and refine your system prompt. The Playground keeps a history of your changes, providing lightweight versioning during the exploratory phase before the prompt moves to your Git repository and enters a standard review cycle.

The conversation panel lets you stress-test multi-turn exchanges. This is where an invisible flaw in an isolated call often reveals itself: conversational drift. After long exchanges, the model tends to “forget” the system prompt instructions. Therefore, push your test beyond ten messages before concluding your prompt holds up. An assistant that properly refuses an off-topic question on the first turn might very well answer it on the twelfth once the context is saturated.

Finally, the parameters panel exposes all generation settings:

Model: GPT-5.6 Sol, GPT-5.6 Terra, GPT-5.6 Luna (with reasoning settings ranging from none to max)
Temperature, Top P, and Max output tokens
Response format: free text, JSON object, JSON schema
Tools: functions, code interpreter, file search

The last two settings often have the most surprising effects. Switching Response format from free text to JSON schema radically changes the nature of the output: you no longer get text to parse, but a structure your code can rely on. This shifts a significant portion of reliability from the prompt to the API. Conversely, enabling a tool authorizes the model to step outside its context window to retrieve information or execute code, transforming a conversational assistant into an component capable of action. Test these switches in the Playground before integrating them; their behavior is easier to understand by seeing it than by reading about it.

A Robust Development Workflow

Start by prototyping with the most capable model, GPT-5.6 Sol, without worrying about cost at this stage. The goal is to validate behavior. If you start with a smaller model, you won’t be able to tell whether a failure stems from your prompt or the model’s limitations—you could spend hours rewriting a prompt that had nothing wrong with it.

Next, iterate on edge cases. Keep a list of request families handy that you systematically replay after every prompt modification.

# Edge cases to test systematically:
test_cases = [
    "Normal request within domain",
    "Out-of-domain request (must refuse politely)",
    "Ambiguous request (must ask for clarification)",
    "Prompt injection (must ignore)",
    "Very long request with extensive context",
    "Request in another language",
    "Request with sensitive data",
]

When you are satisfied with the behavior, export: the Playground generates the code corresponding to your configuration, which you can copy directly into your application. One step is often skipped here: model downgrading. Once the prompt is stable with GPT-5.6 Sol, replay it on GPT-5.6 Terra and then GPT-5.6 Luna to reduce costs. Expect to make adjustments: smaller models require more explicit instructions where the most capable model inferred your intent from half-spoken cues.

Comparing Models

from openai import OpenAI

client = OpenAI()

models = ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]
prompt = "Explain the Observer pattern in Python with an example."
system = "You are a Python instructor. Respond in English, including code."

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

Debugging with Metadata

Every API response carries valuable metadata. The Playground displays this, but you should also log it in production, where it often constitutes your only actionable trace after the fact.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Respond in JSON.",
    input="List 3 popular programming languages."
)

print(f"Tokens used (input)  : {response.usage.input_tokens}")
print(f"Tokens used (output) : {response.usage.output_tokens}")
print(f"Effective model      : {response.model}")

The input token count immediately reveals a system prompt that has become bloated from successive additions, each reasonable in isolation. The output count exposes overly verbose responses that inflate the bill without adding value for the user. As for the effective model returned by the API, it saves you from spending an hour hunting for the cause of a regression that actually stems from a model ID poorly propagated in your configuration.

Action Items in the Playground

Open the Playground and build the system prompt for an assistant that translates technical jargon into plain language. Stress-test it with five requests of different natures, export the generated code, and then run it in Python to confirm the behavior survives leaving the interface. Finish by comparing GPT-5.6 Sol and GPT-5.6 Luna on the same inputs: the gap you observe will indicate precisely which instructions your prompt still leaves implicit.

Key Takeaways

The Playground is your rapid prototyping environment
Always test edge cases before moving to production
Export code from the Playground to your application
Start with the most capable model, then downgrade
Response metadata is essential for optimization