OpenAI ships its GPT-5.2 prompting guide with reasoning_effort defaulting to none and a scope-lock instruction baked into the recommended system prompt: “Implement EXACTLY and ONLY what the user requests. No extra features, no added components, no UX embellishments.” Read that twice. The company that built the model is telling you, in its own documentation, that the biggest risk with a capable agent is not that it does too little. It is that it does too much, and that the fix is not a longer set of steps. It is a tighter definition of the finish line.
That is the shift almost nobody updated their prompting habits for. The models most teams are pointing at production in mid-2026, Claude Opus 5, GPT-5.6, Gemini 3.6, all plan before they act. They decompose a request, sequence tool calls, check their own work, and keep going until they decide they are done. When you hand a model like that a numbered list of steps, you are not helping it. You are overriding the part of it that got better. Outcome-based prompting is the correction: you specify what “done” looks like, the constraints it has to respect, and where to stop, and you let the model own the path in between.
I have spent the last several months moving internal agents from prototype to something a telecom operations team actually leans on, and the single largest quality jump came from deleting steps out of prompts, not adding them. Here is what that looks like in practice, and where it backfires.
What “agent-first” actually changed
For years the reliable prompting move was to think for the model. You broke the task into stages, spelled out each one, and the model followed the rail because it could not reliably build its own. That is the world the older prompt engineering fundamentals were written for, and those fundamentals still hold for single-shot text generation.
Agentic models broke the assumption underneath it. When GPT-5.5 stopped being a chatbot and started being an agent, the product changed from “text in, text out” to a system that orchestrates tools and reasons over long-running tasks. Anthropic’s guidance now states the principle plainly: tell the model what you want to see, not how to produce it, because, in their words, “modern models like Claude benefit especially from explicit direction” about the goal. Your step-by-step decomposition is now competing with a better decomposition the model would have generated itself, one that adapts to what it finds mid-task instead of what you guessed before it started.
The practical failure mode is specific. A rigid step list makes the model brittle. Step 3 assumes an output from step 2 that did not materialize, and instead of routing around the gap, the agent either stalls or invents the missing piece to satisfy your script. You told it how, so it optimized for following your how, not for the result you actually wanted.
Specify the outcome, the constraints, and the stop condition
The replacement is not vaguer prompting. It is more precise about different things. Three of them.
The outcome. State what a successful result contains, in checkable terms. Not “analyze the churn data” but “produce a ranked list of the three customer segments with the steepest month-over-month churn, each with the single metric that moved most and a one-line hypothesis.” Anthropic’s best-practices guidance frames this as defining success before you optimize: you need “a clear definition of what success looks like” and “a way to test against those criteria,” otherwise you are optimizing blind. The outcome statement is that definition, moved into the prompt itself.
The constraints. These are the non-negotiables the model must respect regardless of the path it picks: format, word count, data it may and may not touch, tools it is allowed to call, actions that require a human. Constraints are where you keep control after you have given up the steps. GPT-5.2’s recommended scope block is a constraint, not an instruction: it forbids scope drift (“no extra features”) and tells the model that when a request is ambiguous, it should “choose the simplest valid interpretation.” That one line prevents more bad agent behavior than any ten-step recipe I have written.
The stop condition. This is the piece most people leave out, and it is the one that separates a demo from something you can run unattended. An agentic model will keep working until it decides it is finished, so you have to tell it what finished means. OpenAI’s GPT-5 prompting guide is unusually concrete here. To bound an over-eager agent, it recommends explicit early-stop criteria such as “you can name exact content to change” or “top hits converge (~70%) on one area,” a hard tool-call budget (“an absolute maximum of 2 tool calls”), and an escape hatch that lets the model proceed “even if it might not be fully correct” rather than looping forever in search of certainty.
The control moved to the dials, not the sentences
Once the path belongs to the model, your leverage moves from prose to parameters. Every frontier model now ships with an effort dial, and OpenAI’s own framing is that this is the primary knob for autonomy. Lower reasoning_effort to “reduce exploration depth but improve efficiency and latency” when you want a fast, bounded agent. Raise it when the task genuinely needs the model to grind.
The same guide describes a matched pair of prompt patterns for the two directions. To make an agent less eager, you combine lower effort with tight stop criteria and small tool budgets. To make it more eager, you add persistence language: “only terminate your turn when you are sure that the problem is solved,” and “never stop or hand back to the user when you encounter uncertainty,” paired with an instruction to make a reasonable assumption and document it rather than pausing to ask. Notice that neither pattern lists steps. Both shape behavior around the outcome and the boundaries.
Tool design carries part of the load that used to live in your prompt, too. Anthropic’s engineering team calls tools “contracts between deterministic systems and non-deterministic agents,” and argues for high-leverage tools with clear, distinct names and human-readable outputs over thin wrappers around raw APIs. A well-named tool that returns clean context is an instruction the model reads every time it considers using it. If you are wiring agents to real systems, that contract layer, often through a production MCP setup, is where a lot of your “how” should actually live, encoded once in the tool rather than repeated in every prompt.
Guardrails are the reason this is safe, not reckless
Handing the path to the model sounds like handing it the keys. It is the opposite, if you write the boundaries deliberately. Gartner projects that more than 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear value, and inadequate risk controls. “Inadequate risk controls” is a prompting problem as much as a governance one. Most of the handoff and coordination failures that sink multi-agent systems trace back to underspecified boundaries, not underspecified steps.
Four guardrails carry most of the weight:
- Scope lock. The “exactly and only what was requested, simplest valid interpretation” clause. It is the cheapest insurance against an agent gold-plating a task into a mess.
- Uncertainty permission. Anthropic’s guidance is to give the model “explicit permission to express uncertainty rather than guessing,” which it notes “reduces hallucinations and increases reliability.” An agent allowed to say “I could not verify this” is worth more than one that fabricates to look complete.
- Stop conditions. Covered above, and worth repeating because it is the most-skipped line in every prompt I audit.
- Human-in-the-loop actions. Name the specific operations, sending anything external, writing to production, spending money, that require approval regardless of how confident the agent is. This is a constraint, and it belongs in the prompt and, ideally, enforced in the tool layer too.
These matter more as tasks run longer. Context degrades over a long agent session, the failure mode I covered in the piece on context rot, so a boundary the model read cleanly at turn 2 can blur by turn 40. Restating the outcome and the constraints at each new task node, rather than assuming they persist, is standard practice now for exactly this reason.
When step-by-step still wins
Outcome-based prompting is not a universal upgrade, and pretending it is would be the same mistake in the other direction. Prescribe the steps when the steps are the point.
Regulated and compliance workflows are the clearest case. If a process has to be executed a specific way for audit or legal reasons, the sequence is the requirement, and you want the model on a rail, not improvising a cheaper path to the same output. Deterministic pipelines where you already know the optimal sequence are another: if there is genuinely one right way and no judgment involved, spelling it out removes variance you do not want. And low-effort or non-reasoning model tiers, the cheap high-volume routing options you would use for classification or extraction, still benefit from explicit structure because they are not doing the planning that makes outcome prompting work.
The rule I use: the more judgment the task requires and the more capable the model, the more you should lean on outcomes. The more the exact procedure is itself the deliverable, the more you should lean on steps. Most real work sits between, which usually means an outcome statement with two or three hard constraints and one or two must-do steps, not a ten-step script and not a one-line wish.
A template that survives contact with production
Here is the skeleton I hand new team members, stripped to the shape. Fill the brackets, delete what does not apply.
Goal: [what a correct result contains, in checkable terms]
Constraints: [format, length, data in/out of bounds, allowed tools]
Scope: Do exactly and only what is asked. If ambiguous, take the simplest valid reading.
Autonomy: [proceed and document assumptions] OR [ask before any external/production action]
Stop when: [the concrete condition that means done], or after [N] tool calls, whichever comes first. If uncertain, proceed and flag what you could not verify.
That is five lines doing the work a page of steps used to do worse. The goal replaces the narration. The constraints and scope replace the fences you used to build by omission and hope. The autonomy and stop lines replace the supervision you cannot provide when the agent runs on its own.
The teams shipping agents that hold up are not the ones with the cleverest step lists. They are the ones who got specific about the finish line and the boundaries and then trusted the model with the middle. If you are still writing prompts the way you did for a 2024 chatbot, that is the habit to break first. The model already changed. The way you talk to it should have changed with it. For a grounding in what these systems actually are before you prompt one, the plain-English explanation of AI agents and the layer-by-layer agent stack are the two places to start.
Sources: Anthropic, prompt engineering best practices; OpenAI, GPT-5 prompting guide; OpenAI, GPT-5.2 prompting guide; Anthropic Engineering, writing effective tools for AI agents; Gartner, over 40% of agentic AI projects canceled by 2027; Simon Willison, GPT-5.5 prompting guide.