Search for a command to run...
The perfect prompt doesn't instruct the model on what it already knows how to do.
I’m a senior software engineer loving clean code, and declarative designs. S.O.L.I.D. and agile methodologies fan.
No comments yet. Be the first to comment.
Approve the logic once, then let it run the same way forever.
Different stages need different brains.
One Second Brain doesn't scale past one skull.
Style errors double when nobody enforces them.
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 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 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 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 only the rules that are actually non-negotiable.
Replace a bare "be concise" with what to keep and what to cut: 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, 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 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, and drop step-by-step process instructions in favor of describing the outcome.
State clear, verifiable exit criteria, the same ones you'd expect from a human collaborator.
Better results, not just shorter ones: OpenAI reports 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, exactly as OpenAI's guidance states.
As always, you need a human in the loop 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 isn't the same as leaving out real constraints.
Business rules, 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 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, 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:
<PASTE THE OLD PROMPT HERE>
[X] Semi-Automatic
This trimming approach targets reasoning models with an explicit effort parameter and strong default self-verification.
Older or smaller models without those defaults may still need the explicit scaffolding this tip removes.
[X] Beginner
https://maximilianocontieri.com/ai-coding-tip-003-force-read-only-planning
https://maximilianocontieri.com/ai-coding-tip-006-review-every-line-before-commit
https://maximilianocontieri.com/ai-coding-tip-009-compact-your-context
https://maximilianocontieri.com/ai-coding-tip-015-force-the-ai-to-obey-you
https://maximilianocontieri.com/ai-coding-tip-022-give-ai-a-harness-to-work-with
https://maximilianocontieri.com/ai-coding-tip-024-force-a-criteria-check-before-the-task-ends
https://maximilianocontieri.com/ai-coding-tip-027-force-code-standards
A prompt written for last year's model is a prompt full of instructions the current model already follows on its own.
Verification, depth, and caution used to be things you had to ask for.
Now they're defaults, and asking for them again just adds noise the model has to work around, like reminding a surgeon to wash their hands before every single incision.
Once useful.
Now just insulting.
Keep the four things a model still can't infer, effort, scope, length, and autonomy, and delete everything else that was only ever compensating for a model that's no longer the one answering.
Prompting 2026 - Guía Definitiva
Prompt Pruning
Prompt Minimalism
Outcome-First Prompting
Effort-Level Prompting
The reasoning_effort parameter (OpenAI) and the extended-thinking budget parameter (Anthropic) set explicit depth instead of a "think hard" instruction.
The views expressed here are my own.
I am a human who writes as best as possible for other humans.
I use AI proofreading tools to improve some texts.
Most AI detectors will flag this article as AI-generated. That's expected. It's a technical article. It has a rigid format and clear steps to follow.
That's exactly the pattern those tools are trained to catch. I've apparently been "writing like an AI" for decades, long before AI existed. This is a technical article, not a novel.
I welcome constructive criticism and dialogue.
I shape these insights through 30 years in the software industry, 25 years of teaching, and writing over 500 articles and a book.
This article is part of the AI Coding Tip series.