AI Coding Tip 031 - Stop Over-Prompting Reasoning Models A developer advises against over-prompting reasoning models, noting that modern models already verify and pace themselves, so extra instructions like 'double-check your work' cause over-verification and wasted tokens. The guidance recommends using explicit effort settings, clear decision criteria, and a structured prompt template instead of vague or redundant instructions. The perfect prompt doesn't instruct the model on what it already knows how to do. TL;DR: Reasoning models already verify and pace themselves, so drop those prompts and set real effort, scope, length, autonomy. You still write prompts for a model that evolved and stopped needing them. "Double-check your work," "think step by step," "be concise," and a wall of REQUIRED/MANDATORY rules get pasted into every request, the same gratuitous context https://dev.to/mcsee/code-smell-197-gratuitous-context-4gk you'd flag in a variable name, on the assumption that more instruction always buys better output, as if the model just needed one more all-caps reminder to remember how to think. Current reasoning models as of August 2026 already verify their own steps and pace their own depth. Those extra lines don't add safety, they add friction, waste tokens, and the model spends effort fighting your instructions instead of the task. Forced verification instructions cause reasoning models to over-verify, burning tokens https://dev.to/mcsee/ai-coding-tip-009-compact-your-context-3io9 on redundant checks the model would have run anyway. "Think deeply" as a universal prefix no longer maps to anything: modern APIs expose an explicit effort level, so a vague plea does nothing a real setting wouldn't do better. ALWAYS/NEVER absolutes written for judgment calls turn a nuanced decision into a rule the model follows literally, even when the literal reading is wrong. "Be concise" without specifics leaves the model guessing what to cut, so it either pads the response https://dev.to/mcsee/ai-coding-tip-009-compact-your-context-3io9 or cuts something you needed. Contradictions inherited from older prompt versions, the same rule stated twice, slightly differently, in two sections, leave the model to arbitrate a conflict you never meant to create, sometimes by hallucinating its own resolution. Missing autonomy rules mean the model either stalls asking permission for trivial calls or barrels ahead on changes you wanted to review first. Delete forced verification lines like "double-check your work" or "review before answering," since Anthropic's guidance on Opus 5 states directly: "If your prompt contains explicit verification instructions... remove them: they cause over-verification in modern models." Replace "think deeply" or "think hard" with the model's official effort selector low / medium / high / max , and start low, raising it only when a task actually needs the extra depth. Turn ALWAYS/NEVER language into decision criteria instead of blanket orders, and reserve absolute words for invariants that are genuinely always true, the same way you'd force the model to obey https://dev.to/mcsee/ai-coding-tip-015-force-the-ai-to-obey-you-49mc only the rules that are actually non-negotiable. Replace a bare "be concise" with what to keep and what to cut https://dev.to/mcsee/ai-coding-tip-009-compact-your-context-3io9 : name the sections that matter and the ones that don't. Deduplicate inherited rules so each constraint lives in exactly one place in the prompt, stated once. State an explicit autonomy policy as a harness https://dev.to/mcsee/ai-coding-tip-022-give-ai-a-harness-to-work-with-274a , the way OpenAI's GPT-5.6 guide does: "For requests to analyze, review, or plan, inspect and report. Don't implement changes unless asked," the same read-only planning step https://dev.to/mcsee/ai-coding-tip-003-force-read-only-planning-1d1m you'd force on any other run. Set explicit length in the request itself, a paragraph, a table, three bullets, instead of leaving "how long" to the model's judgment. Rewrite the prompt using the 2026 template: Role, Objective, Success criteria, Constraints, Output format, and Stopping rules, the same explicit exit condition you'd force before closing out any task https://dev.to/mcsee/ai-coding-tip-024-force-a-criteria-check-before-the-task-ends-51ij , and drop step-by-step process instructions in favor of describing the outcome. State clear, verifiable exit criteria https://dev.to/mcsee/ai-coding-tip-024-force-a-criteria-check-before-the-task-ends-51ij , the same ones you'd expect from a human collaborator. Better results, not just shorter ones: OpenAI reports https://developers.openai.com/cookbook/examples/gpt-5/gpt-5-6 prompting guide that trimming their internal agent prompts, cutting repeated instructions, unnecessary examples, and irrelevant tool descriptions, raised evaluation scores by 10 to 15%. Lower token cost: The same trimming dropped token consumption between 41 and 66%, and cost by up to 67%. Less over-verification: Removing forced double-check instructions stops the model from re-verifying work it already verified as part of normal reasoning. Effort matches the task: An explicit effort level replaces a vague "think hard," so simple requests stay cheap and hard ones get the depth they need. Fewer surprise expansions: A stated scope stops the model from turning a one-file fix into a refactor of the whole module. No arbitration needed: A prompt with one copy of each rule leaves nothing for the model to reconcile on its own. This shift tracks a change in what the model already does by default. Older models needed to be told to verify, to slow down, to stay on topic, because without that scaffolding they skipped steps. Reasoning models like GPT-5.6, Opus 5, and Kimi-3 already run an internal verification pass and already pace their depth against the task, so the same scaffolding stops helping and starts duplicating work the model was going to do anyway. The fix isn't a shorter prompt for its own sake, since a short but vague prompt still fails. It's a prompt where every remaining line does something no default behavior already covers: the real role, the real objective, the real constraints, and the four settings the model can't infer on its own, effort, scope, length, and autonomy. Autonomy is the one most prompts still skip, because apparently deciding when the model gets to act on its own is less fun than writing a ninth verification clause nobody needed. A three-level policy works for most tasks: act without asking on reversible, low-risk steps, confirm before anything destructive or hard to undo, and for pure analysis or planning requests, inspect and report without touching code https://dev.to/mcsee/ai-coding-tip-003-force-read-only-planning-1d1m , exactly as OpenAI's guidance states. As always, you need a human in the loop https://dev.to/mcsee/ai-coding-tip-006-review-every-line-before-commit-bmm to verify the task is complete. Think deeply about this task and be very careful. Always double-check your work before answering. Never skip validation, ever, no matter what. Be concise. Refactor the payment module. Role: Senior backend engineer refactoring a payment module. Objective: Extract the retry logic in PaymentGateway into its own class. Success criteria: Existing tests pass. Retry behavior stays the same. No new public methods on PaymentGateway. Constraints: Don't touch the database schema. Don't add new dependencies. Output format: A diff, followed by a two-sentence summary of what moved. Stopping rules: If a test needs new mocking infrastructure to pass, stop and ask before adding it. Otherwise proceed without confirming each file. Effort: medium. Trimming a prompt https://dev.to/mcsee/ai-coding-tip-009-compact-your-context-3io9 isn't the same as leaving out real constraints. Business rules https://dev.to/mcsee/what-is-wrong-with-software-5pa , security limits, and data boundaries stay in the prompt no matter how short the rest of it gets, since those aren't scaffolding, they're the same kind of non-negotiable rule you'd force through a hook https://dev.to/mcsee/ai-coding-tip-027-force-code-standards-58nf instead of a wish. The effort selector is model-specific. Confirm the exact parameter name and accepted values for the model you're calling before relying on it, since low / medium / high / max doesn't map identically across every provider. An autonomy policy still needs real stopping rules https://dev.to/mcsee/ai-coding-tip-024-force-a-criteria-check-before-the-task-ends-51ij , not just permission to act freely. "Act without asking" without a boundary is how a reversible-looking step turns into an irreversible one. Older prompts you've relied on for months may still carry verification and hedging language written for older models. Re-check them against the current model's defaults instead of assuming last year's tuning still applies. You don't have to do that rewrite by hand. Feed the old prompt into a meta-prompt that applies this tip's own rules and hands back a trimmed version. Rewrite the prompt below for a reasoning model. Remove: forced verification lines "double-check your work", "review before answering" , "think deeply" or "think hard" phrasing, SIEMPRE/NUNCA rules written for judgment calls instead of real invariants, a bare "be concise" with no specifics, and any rule that's stated more than once. Add: an explicit effort level low, medium, high, or max , an explicit scope boundary, an explicit output length, and an explicit autonomy policy act without asking, confirm first, or inspect and report only . Keep every real business rule, security limit, and data boundary from the original prompt untouched. Don't invent new constraints that weren't already there. Output using this structure: Role, Objective, Success criteria, Constraints, Output format, Stopping rules. Old prompt: