Transcription
Hello. Today, we are diving into, well, such an interesting topic as how to properly communicate with GPT5, or more precisely, how to create effective prompts for it. We will rely on the official OpenAI guide, and the analysis by Matthew Berman will help us. The main goal is to understand how to get the maximum out of it, especially when it's supposed not just to answer, but, well, to do something, plan, find information, use some tools, these agentic tasks. Yes, absolutely correct. And the guide, it kind of emphasizes that the model, of course, is already good, as they say, out of the box, but for complex things, especially if it's development or some kind of automation, well, standard prompts are no longer enough, customization is needed. And the key points here are, firstly, controlling the model's initiative, and secondly, uh, the depth of its, so to speak, reasoning. Let's start with initiative then. This agentic activity, how does it work? That is, we can tell the model: "Act on your own" or vice versa: "Do only what I say." Exactly. Imagine, well, a slider. On one side, complete freedom. Go, explore, plan, do it yourself, and on the other, a clear command. Solve this specific sub-task and wait for the next one. Understand? And this is very closely related to another parameter, reasoning effort. GPT5 by default is, well, very meticulous. It will dig deep, check all documents, search the web to give the most accurate answer. But this is not always necessary. That is, if accuracy to the last decimal place is not critical, you can somehow reduce its meticulousness to make it faster, for example. Yes. Yes. And OpenAI directly says that many tasks are actually solved excellently at medium, and even at low levels of this effort. We reduce it, we get the answer faster, and, by the way, cheaper in tokens. This is an important trade-off. You just need to find the balance for your specific task. The guide even has examples of how to write this in system messages. Clear. We've dealt with behavior, it seems. But how does the model gather information? Can the search process itself be influenced? Oh, very much so. You can, you know, set a whole strategy for it, write it in the prompt. A whole strategy, what does that mean? Well, for example, the goal is to quickly gather enough context. Methods: start, say, broadly, then simultaneously launch several more focused sub-prompts. For example, web search using different keywords. Read only what's at the top. Avoid duplicating requests, definitely cache results. Like that. Wow, it's like we're delegating a whole research project to it. And can you stop it earlier if the answer is already found? Of course, you can set early stopping criteria. For example, stop if you can accurately name the content for modification or if 70% of the top results point to the same thing. This saves resources. Understand? There is also escalation logic. If signals contradict each other or the area is unclear, launch another series of clarifying requests. You can even set cycles. Search, execution plan, verification. And new search only if verification failed. The main thing is to prefer action over further search, if possible. And can you restrict it even more strictly, say, by the number of calls to some external tools? Absolutely, the guide actually has an example. The search depth is very low. Goal: provide a correct answer as quickly as possible, even if it's not absolutely accurate. And there, a maximum of two tool calls. That is, you can only interact with something external twice. If more time or calls are needed, do not continue, but inform the user what you found and what questions remain. Understand. This is like an economical mode, right? But there is also the opposite approach. Persistence, this is when maximum meticulousness is needed. The prompt then sounds something like this: "You are an agent, continue until the user's request is fully resolved. Complete a turn only when absolutely sure. Never stop or ask the user in case of uncertainty. Explore or choose the most reasonable approach and continue. Do not ask a human for confirmation or clarification, decide yourself, document, and move on." Wow! This is another extreme for some super-responsible tasks, apparently, specifically for situations where exhaustive analysis is needed. Listen, and when the model performs such a complex multi-step process, you'd want to understand what it's doing there. Not just sit and wait for the final result. That's what tool preambles were invented for. Models are trained to communicate their plans, progress through them, but the most interesting thing is that their clarity, style, content, all of this can be customized in the prompt. Do you want it to explain every little thing in detail, or do you want it to give a brief plan at the beginning, and that's it? Here's an example of customization from the guide. Always start by rephrasing the user's goal. Then immediately describe a structured plan. As you execute, briefly describe each step, clearly marking progress. At the end, summarize the work done separately from the initial plan. That is, we see not only what was achieved, but also how it got there, what tools it used. Yes, this is useful for debugging, and just for understanding. Absolutely. It provides transparency and control. And from a development perspective, technically, are there any recommendations for the API, what's better to use? Yes, and this is a very important point. OpenAI for these agentic tasks recommends using the new Responses API, not the old Chat Completions API. Why? Because the Responses API allows reusing context between calls. This is a key improvement for agentic workflows. The model, as it were, remembers its thought chain, its previous reasoning. It doesn't need to build a plan from scratch every time after calling a tool. This, firstly, speeds up work, and secondly, reduces cost, fewer tokens are used. And overall efficiency increases. They even provide improvement figures on the Tabench benchmark. There are 78.2 points with the Responses API versus 73.9 with Chat Completions. This is statistically significant, especially for tasks that require many steps and tools. Understand. Let's move on to coding now. They say GPT5 is especially good at frontend. Is that true? Yes, the source confirms this. They write that the model creates not just working code, but also, well, such a good-looking frontend. OpenAI even provides a list of technologies on which the model was apparently best trained and which it understands well. These are NextJS, TypeScript, React, of course, HTML, Tailwind CSS, also SH 7 UI, RX Teams, icons, like Material Symbols, Hero Icons, Lite, Motion animation, Sunserif fonts, like Inter, Guist Mono, IBM Plex, Suns, Monroe. Using this stack increases the chances of success, so to speak. Interesting, and how best to formulate a prompt for coding? Are there any special techniques? There is one curious technique, especially for creating web applications. Well, like in one pass, one-shot. It is recommended to ask the model to first create a rubric for evaluating the quality of its own work. To write a technical specification for itself, it seems. A rubric with criteria, and then iteratively work on the code until the result meets this rubric on all points, well, usually five to seven categories. Prompt example. First, think about the rubric, use it for internal iteration. If the result does not achieve the highest scores in all categories, start over. This engages its planning abilities and, importantly, self-reflection. Great. And if you need to modify existing code, not create from scratch? Well, the model already tries to analyze the context, like package.json, and so on. But this can and should be enhanced. It's better to explicitly state the key aspects of the codebase in the prompt. What are your guiding principles? Well, like modularity, reusability, avoiding duplication, consistency, simplicity. What stack is used? Frameworks, styles, state management, what directory structure is adopted, what are the best UI, UX practices, visual hierarchy, accessibility, and so on. Essentially, yes, create a file with coding rules for your project for the model, like an internal guideline. Very interesting to hear about the experience of real users. Like Cursor AI code editor. They were among the first to test GPT5. What did they encounter? What conclusions did they draw? Oh, this is perhaps the most telling. Firstly, they encountered excessive verbosity from the model. It provided too many text updates, some comments about its work, which simply hindered the developer's workflow. How did they solve it? They set the Verbosity API parameter to low for general text. But in the prompt itself, they asked the model to be verbose only in describing the code. That is, clear variable names, good comments - yes, but talk less about the process. Clever. What else happened? Secondly, the model often re-asked the user or asked for guidance on the next steps. This, of course, slowed down work on long and complex tasks. The solution here was to add to the context not only information about available tools but also more details about the behavior of the Cursor product itself, how exactly its edits would be shown to the user. This, as it were, pushed the model to act more autonomously. There was such a prompt example: "Consider that your edits will be shown to the user as suggestions. This means they can be proactive. The user can also reject them. And they should be well-written for quick review." That is, they gave it more context about its role in the process. Exactly. But the main surprise wasn't even that. What was it? It was too curious and meticulous for their tasks. Imagine, the prompts they used before to make previous models more thorough, with GPT5 they had the opposite effect. The model started to show excessive activity, digging where it wasn't asked. The Cursor team literally had to weaken their prompts. They removed prefixes like "maximize," softened the wording about thoroughness and depth of analysis. This helped the model better decide for itself when to use its internal knowledge and when to access external tools. What a twist. So, old proven prompting strategies can not only not work but even harm with GPT5. Absolutely correct. This is perhaps the key takeaway from their experience. You need to reconsider approaches, retrain to work with the new model. It's different. It turns out that GPT5's high accuracy in following instructions is not only its strength but also a potential problem if the instructions are, say, unclear or even contradictory. Exactly. Logical consistency and non-contradictoriness of prompts become critically important. If in one place you say: "Never schedule a meeting without confirmation," and in another: "Automatically schedule the nearest slot without contact," the model can get confused or do something wrong. OpenAI even advises correcting such conflicts in the prompt, possibly with the help of AI itself, i.e., using meta-prompting. What is meta-prompting? It's when you ask GPT5 to help optimize a prompt for itself. For example, "Analyze this prompt. Explain which phrases can be added or removed to more stably achieve the desired behavior or prevent unwanted behavior." And then you insert the prompt itself. Interesting approach. A self-learning system in a sense. Yes. And there are a couple more points. There is the Verbosity parameter. It controls the length of the final answer, unlike reasoning effort, which affects the length of the reasoning process. These are different things. And there is the Minimal Reasoning option. Minimal Reasoning is the fastest option for tasks where latency is critical, but here performance depends even more on prompt quality. Recommendations for this mode: ask the model to provide a brief explanation of its thoughts at the beginning of the answer, use very detailed tool preambles, formulate instructions for these tools as clearly as possible, and directly write down the planning steps in the prompt itself, because the model has fewer reasoning tokens for internal planning. Understand? So, we, as it were, take part of the planning upon ourselves in the prompt, right? And one more minor but important thing, Markdown formatting. You need to explicitly ask it to use it, but only when it is semantically correct for code, lists, tables. It even specifies how to format file names, functions, use backticks. Like that. And for all this fine-tuning, does OpenAI offer any tool to help developers? Yes, it offers one. In the playground, there is an Optimize button. You can enter your developer message there. It's similar to a system message and the main user prompt. The tool analyzes them and suggests an improved version of this developer message. And what's valuable is that it doesn't just suggest, but shows specific changes and explains the reason for each change. For example, an instruction has been added to start with a checklist for clearer planning. You can even ask it to make additional changes, say, "Make GPT5 explain everything in detail," and it will show the result. There is also a compare versions mode. It sounds like a great way not only to improve a specific prompt but also to generally learn to better understand what works for GPT5 and what doesn't. Absolutely. It's both a tool and a learning aid simultaneously. Well, let's summarize. It seems the main conclusion from this entire breakdown of the GPT5 guide is that we are moving towards much finer, granular control over the model's behavior. This is especially true for these complex agentic tasks. It's no longer just "write me some text," but rather "configure behavior and..." Yes, exactly. We see a focus on managing agentic activity, reasoning effort, detailed context gathering strategies, the importance of transparency through tool preambles, choosing the right API, Responses API is clearly preferable, specific techniques for coding, like self-evaluation by rubric. And, of course, the need to iteratively refine prompts, possibly with meta-prompting or tools like the prompt optimizer. And the Cursor experience vividly shows that old approaches that worked before may need to be reconsidered, even to weaken some instructions. This, of course, opens up huge possibilities, but it also seems to require much greater understanding, greater effort from the user or developer. Absolutely, this is no longer just using a tool, but in a way, managing it. And this, by the way, leads us to an interesting question for the future, which is worth thinking about. If we gain such detailed control over the AI's reasoning and actions, where does the line now lie between a tool we use and a digital assistant, well, almost an employee, that we manage, and what new skills will people need to most effectively lead such increasingly advanced digital assistants. I think this is a topic for a separate conversation.