The Only Prompt Formula That's Actually Backed by Research

Current as of August 2026. Model behavior around prompting shifts with every release — see the DYOR note at the bottom.

The formula is short: goal, place, boundaries, done-criteria, output format. Everything else sold to you as "prompt engineering" is either unproven or already outdated.

The biggest systematic review of prompting research, The Prompt Report, went through 1,565 selected papers and distilled them into 58 documented techniques. The most useful part of that review isn't the taxonomy, though — it's the case study. The lead author spent 20 hours by hand tuning a prompt and landed an F1 score of 0.53. An automated optimizer (DSPy) found one in ten minutes that scored 0.548 and beat him outright.

The Skeleton

Five parts, in order:

1. GOAL — what's actually broken and how you can see it
2. PLACE — files, folders, functions
3. BOUNDARIES — what stays untouched
4. DONE — how the result gets checked
5. FORMAT — what shows up in the answer

Each one gets a before-and-after below, pulled from Anthropic's own documentation and from engineering write-ups.

1. Goal: Symptom, Not Area

Before: "Fix the login bug." That names an area. There's no symptom, no reproduction steps. The model starts by exploring — reading dozens of files just to figure out what you mean — and burns its context doing it. Anthropic names this as its own failure mode: unbounded investigation.

The quieter, more expensive problem: under a vague description like "the login bug," the model picks the most likely guess and fixes the wrong thing entirely.

Users are reporting: after a session expires,
login stops working.
 
Look at the auth flow in src/auth/, especially
the token refresh logic.
 
Write a failing test that reproduces the issue
first, then fix it.

2. Place: One Folder, Not the Whole Repo

Naming a location cuts the search space from dozens of files down to one directory. Pointing to a reference file works even better — let the model read how something's already built instead of describing the convention in words.

Look at how the widgets on the homepage are
built. HotDogWidget.php is a good reference.
 
Build the calendar widget the same way: month
picker with year-by-year paging.
 
Write it from scratch — no libraries beyond
what's already in the project.

A reference file beats a description because it doesn't go stale alongside the prompt. Change the convention in the code, and the model reads the new version automatically.

3. Boundaries: Name What Stays Whole

Leave a task without boundaries and the model fills the gap on its own. Anthropic documents this directly in newer models: a tendency toward over-engineering — extra files, abstractions built for a single call site, flexibility nobody asked for baked in "for later."

The dangerous part is that all of it compiles and passes tests. It only surfaces during diff review, once the change has already taken root.

Create POST /api/orders.
 
Only create files inside Features/Orders/.
Don't touch Program.cs except to register the
new route. Don't add new packages.
 
Don't introduce abstractions for a single
call site.
 
If you think this needs to go beyond these
boundaries — say so first, don't just do it.

That last paragraph is the release valve. Without it, the model either quietly steps over the line or gets stuck.

4. Done: Something the Model Can Check Without You

Anthropic's own phrasing on this is direct: the model stops when the work looks done, and without a way to verify, "looks done" is the only signal available. Without that, you become the verification loop — and every mistake waits for you to notice it.

The criterion needs to be something the model can read for itself: a test run, a build, a type check, a screenshot compared against a mockup.

GET /api/products takes over 3 seconds to
respond on 1,000 records. Target: P99 under
200ms.
 
Check for N+1 queries, missing indexes,
unnecessary change tracking.
 
Propose the changes with expected impact
first. Implement after I respond.

One catch worth knowing: a requirement the model can't verify, it will just declare met. "Make it nicer" isn't something it can see — there's no eye looking at the rendered page — so success gets claimed based on whatever edits were made. The fix is a screenshot: capture the result, compare it to the mockup, list the differences, then correct them.

5. Format: Show the Proof

Ask for command output, not a summary of it. A restated claim of success can't be checked. Reading someone else's actual output is faster than rerunning everything yourself to confirm it.

One detail the documentation states plainly, against intuition: the formatting style of your own prompt leaks into the response. Want plain text back? Strip the markdown out of your prompt first — the amount of markdown in the answer drops with it.

"Think Step by Step" Doesn't Work Anymore

In 2022, that phrase looked like magic: on the models of the day, accuracy on MultiArith jumped from 17.7% to 78.7% just by adding it. That single result is where the habit came from. Today it does something different.

A meta-analysis of over 100 papers, published at ICLR 2025, broke the gains down by task type: symbolic reasoning +14.2 points, math +12.3, logic +6.9. On everything else — 56.8% versus 56.1% without the chain, a gap within noise.

On models that reason natively, the picture gets worse. A Wharton benchmark on 198 PhD-level questions found o3-mini up 2.9%, o4-mini up 3.1%, and Gemini Flash 2.5 down 3.3% — while response time grew 20–80%.

OpenAI states this directly in its own docs: asking reasoning models to think step by step is unnecessary, since they already do it internally. Anthropic recommends a manual chain in tags only as a substitute for reasoning that's been turned off.

Expert Personas: The Evidence Doesn't Support It

The largest check on this ran 162 personas against 2,410 factual questions across four model families. A persona in the system prompt didn't outperform no persona at all.

A separate finding from the same study explains why the trick feels like it works: pick the best-performing persona for each question after the fact, and the gain looks huge. Predicting the right persona in advance is a different story — those predictions are often no better than picking one at random.

There's real downside too: on one model, role prompts made reasoning worse on seven of twelve datasets. A 2026 follow-up across 1,140 questions found a trade rather than a win — expertise depth goes up, clarity goes down, and the overall score barely moves.

Tips, Threats, and All Caps

A promise of payment and a threat were both tested directly on two serious benchmarks. The finding, stated plainly: no meaningful effect on outcomes. Individual phrasings shift results on specific questions, but there's no way to predict which way in advance.

Politeness has three separate studies with three separate answers — one finds a bump from rudeness, one from politeness, one finds no reliable effect either direction. There's no stable rule here.

Caps lock is the one place Anthropic gives a direct recommendation, and it's against using it. Newer models react more strongly to the system prompt, and text like "THIS IS CRITICAL, YOU MUST" now triggers behavior in places it shouldn't. The advice straight from the documentation: drop the aggressive phrasing and write in plain language.

Examples Set the Shape, Not the Content

A 2022 study tested this hard: the correct answers inside the examples were deliberately scrambled, and quality barely dropped. What actually mattered were three other things: what kinds of answers exist at all, what a typical input looks like, and how the answer is structured.

Four years later, a check on current models landed in the same place: examples align the output format, while the models lean on the instructions themselves and tend to ignore the demonstrations. Once the format is spelled out in words, examples stop paying for themselves.

Anthropic recommends 3–5 examples wrapped in tags so the model can tell them apart from instructions. The effect they name is an honest one: format, tone, and structure — not content.

Formatting Matters More Than It Should

A study from ICLR 2024 ran through semantically identical layouts of the same prompt — different separators, different spacing, different casing. The accuracy spread on one model hit 76 points. That sensitivity doesn't shrink as the model gets bigger, and it doesn't shrink when you add examples.

The practical takeaway: pick one template and keep it fixed, then vary the content inside it. Comparing two prompts with different formatting tells you nothing about the content — you're only measuring the formatting.

Strict JSON Breaks Reasoning

Forcing a strict format at the decoding level costs more than it looks like. On grade-school math, one model dropped from 86.5% to 23.4%, another from 76.6% to 49.3%. The tighter the format constraint, the bigger the drop.

The flip side is measured too: on classification, format helps — narrowing the space of possible answers cuts selection errors. The working compromise between the two extremes: let the model reason freely first, then convert to the strict format as a separate step.

The Middle of a Long Prompt Falls Apart

Give a model a stack of documents where exactly one holds the answer, and move that document's position around. Accuracy: 75.8% when it's first, 53.8% when it's in the middle, 63.2% when it's last. With no documents supplied at all — 56.1%.

Read those four numbers again. A needed document sitting in the middle performs worse than not giving the model any documents at all.

Anthropic recommends putting long data at the top of the prompt, with the question and instructions underneath it. By their own measurements, that adds up to 30% on complex, multi-document inputs.

Asking It to "Check Itself" Without an External Signal Backfires

Asking a model to double-check its own answer, when it has nothing outside itself to compare against, makes the answer worse. On grade-school math: 95.5% to start, 91.5% after one round of self-checking, 89.0% after two.

The mechanism is that the model can't actually tell whether it was wrong — and the doubt planted by the request pulls it away from the correct answer instead of toward it. What works instead is an external signal: a test, a compiler, a type checker, command output. That's the entire reason the fourth part of the formula exists.

Checklist: Before You Hit Send

• The symptom is named — what's visible from the outside, and under what conditions
• A starting point is named — folder, file, or function
• What stays untouched is listed: files, dependencies, neighboring modules
• There's a release valve — stepping outside the boundaries requires asking first
• The done-criteria is something the model can check on its own
• One task per prompt — everything else goes in a separate session
• No persona, no tips, no threats, no caps lock — none of them showed a measurable effect
• Long data sits above the question, not below it
• Command output is required as proof, not a summary of it

⚠️ DYOR: Prompting research moves fast, and what holds for today's models may not hold for the next generation. Treat this as an August 2026 snapshot and check current sources before betting a workflow on any single number here.