Build Hour: GPT-5

OpenAI’s recent Build Hour session, featuring Bill Chen, Eric Han, and Anoop Kotha, offered a technical deep-dive into GPT-5, presenting it as a significant leap forward in steerable reasoning, particularly for coding and agentic tasks.

GPT-5: Core Capabilities and Performance

GPT-5 represents a “step function in increase in code quality.” It demonstrates a marked improvement in generating high-quality, functional front-end UI and proves to be an incredibly collaborative and steerable coding partner. This is supported by significant performance gains on key benchmarks like Sweetbench and Ador Polyglot for multi-language code editing.

Beyond coding, the model excels at long-running agentic tasks that involve complex chains of tool calls. It exhibits strong instruction-following, provides clear explanations of its actions via preambles, and can proactively self-correct if it deviates from an optimal path.

The Responses API: Unlocking Full Potential

A central theme of the session was the strong recommendation to migrate from the legacy completions API to the new responses API to fully leverage GPT-5’s capabilities. The responses API is a stateful, feature-rich successor that unlocks the model’s reasoning power.

Key advantages include:

• Chain of Thought Reasoning: The API returns a reasoning item containing the model’s intermediate “chain of thought” tokens. Passing this item back in subsequent calls allows the model to retain its train of thought, leading to much more coherent and intelligent behavior over long interactions. For organizations that cannot use the stateful nature (store=true), an encrypted_content token is provided to achieve the same benefit.
• Improved Performance: Persisting the reasoning state enables better prompt caching, as the prefix of the request remains consistent. This makes interactions “cheaper, more intelligent, and faster.”
• Developer Experience: The API offers a cleaner interface, for instance, accessing output via response.output.text is more straightforward than parsing choices[0].content.

Bill Chen emphasized this point as the single most important takeaway: “Please, please, please use the responses API to use the model in this unhandicapped way.”

New Steerability Parameters

GPT-5 introduces several new parameters to give developers finer control over its behavior:

• reasoning: minimal: This setting instructs the model to perform the least amount of reasoning necessary to fulfill a request. It delivers the intelligence of GPT-5 but with a latency profile closer to a non-reasoning model, ideal for latency-sensitive applications.
• Free-form Function Calling: Developers can now define custom tools using plain text, eliminating the need for finicky JSON escaping. This simplifies the process of creating agents that can, for example, apply code patches directly.
• verbosity: This parameter controls the length of the final output. It also influences the verbosity of tool calls. For coding tasks, verbosity: high was shown to produce more readable code with better error handling and comments, whereas low produces more concise, minimal code.

Live Demos and Future Directions

Eric Han demonstrated GPT-5’s power by building a functional Minecraft clone from scratch using the Codex CLI. The demo highlighted the model’s process:

1. Planning: GPT-5 first outlines a high-level plan of what it intends to build.
2. Execution: It then works through a checklist of tasks, showing the code patches it applies at each step.
3. Iteration: The generated application could be interactively modified with natural language prompts, such as “add pink flowers onto all the blocks,” showcasing the model’s steerability and understanding of user intent.

Looking ahead, the research team is focused on enhancing web development capabilities, building models that can work “in a loop” to iterate on applications with you (building, testing, and refining), and further improving long-horizon agentic coherence.

Advanced Prompting Techniques

Anoop Kotha, author of the GPT-5 prompting guide, shared a “prompting cheat sheet”:

1. Avoid Conflicting Instructions: GPT-5 interprets prompts very literally. Vague or contradictory instructions can confuse it, whereas older models might “vibe and infer” their way to a decent answer. Precision is key.
2. Use XML for Structure: Internal tests showed that structuring prompts with XML tags yielded the best performance compared to Markdown, JSON, or YAML.
3. Practice Metaprompting: Instead of just telling the model to “fix” an issue, first ask it why it produced a certain output. Understanding its reasoning allows for a more precise and effective correction.
4. Control Agentic Eagerness: You can steer the model’s proactivity. To encourage it to complete long tasks, add a “persistence check” to the prompt. To make it more collaborative and less eager, you can instruct it to limit its search depth or defer to the user for input.
5. Leverage Preambles: Prompt the model to provide an upfront plan and narrate its steps before and during tool execution. This improves transparency and allows for better monitoring of agentic workflows.

Customer Spotlight: Charlie Labs

Riley, founder of Charlie Labs, showcased an autonomous TypeScript coding agent that operates within a developer’s existing workflow (GitHub, Slack, Linear). Charlie uses the responses API and a single powerful tool, run a bash command, to perform tasks like reading files, running tests, and applying code patches using the apply patch method.

Switching to GPT-5 resulted in a 16% improvement on their internal PR-creation evaluation with the old prompt, which increased to a 29% improvement after prompt optimization. This highlights the significant performance gains achievable when combining the new model with refined prompting strategies.

• Tags:
• Code Generation
• Agentic AI
• Prompt Engineering
• AI
• OpenAI
• GPT-5
• Responses API