The Rule I Moved to the Bottom of the Prompt

Four hours before a paid-social campaign was set to launch, a marketing team I was advising sat down to draft ad copy for twelve SKUs using a prompt template they had used for months. The platform's ad policy bans unsubstantiated superlative and comparative claims: no "best," no "#1," no "guaranteed." The rule was already in the template. It had been there since the template was written.

To structure an AI prompt so it reduces errors, put the constraint you most need followed last, as the final line before you tell the model to generate, not buried in a setup block earlier in the prompt. Position affects compliance as much as wording does.

That is not intuitive if you think of a prompt as a document. In a document, where a rule sits doesn't change whether it's true. In a prompt, where a rule sits changes whether it gets followed. That difference is the entire subject of this piece.

The Four-Hour Deadline

The team's template was structured the conventional way: an instructions block up top, laying out tone, audience, format, and the compliance rule, followed by the SKU data, followed by the generation request. This is how most people build reusable prompts. Rules go first, because that's where rules go in a brief, a style guide, or a legal memo. The team had never questioned that structure. It had shipped clean output for months.

With the clock running, they generated all twelve ad blocks in one pass, the way they always did, and started their usual proofread. Two of the twelve blocks contained a banned superlative. One SKU's copy called itself "the best" in its category. Another used "guaranteed" in a line about delivery speed. Neither was dramatic. Both would have gotten the ad rejected or, worse, approved and then flagged after spend had already gone out.

Same Instruction, Two Places

Before deciding how to fix it, I asked them to run a controlled comparison. Version A was the existing template: rule stated once, early, in the instructions block, before the SKU data. Version B was identical in every other respect. Same rule, same wording, same SKU data, same model, same temperature. The only change was where the rule sat. In Version B, the no-superlatives constraint was restated as the last line of the prompt, immediately before "Now write the ad."

Version A produced two violations out of twelve blocks. Version B produced zero. Same instruction, same words, different position, and the error was eliminated rather than merely reduced.

That result is not a fluke of one campaign. It is a predictable consequence of how these models weight context. Instructions placed immediately before generation sit in the part of the context window the model is, in effect, reading last and weighting most heavily as it decides what to produce. A rule stated on line three of a forty-line prompt has to compete with everything that comes after it, including forty lines of product data that can crowd it out of the model's effective attention by the time generation starts. A rule stated on the last line has nothing after it to compete with. I've written before about how sequencing inside a workflow changes outcomes even when every individual component is unchanged — see why I added two extra steps to a working AI prompt for a related case where step order, not step content, was the fix.

What Gets Buried, and Where

Once you know to look for it, the buried-constraint pattern shows up constantly in templates that were written once and reused at scale. The rule is real, the wording is correct, and it still gets ignored often enough to matter, because of where it lives in the prompt rather than what it says. In my own review of reusable templates, a handful of locations account for most of the buried constraints I find, and each has a straightforward fix:

• System-prompt preambles that state every rule once at the top, before any task-specific content — move the one or two rules that carry real compliance or safety weight to a final restatement immediately before the generation instruction, and let the preamble carry only lower-stakes style guidance.
• Long reference data dropped between the rule and the request — product catalogs, transcripts, policy documents — which push the original constraint further from the point of generation with every SKU or record added; restate the constraint after the data block, not just before it.
• Few-shot examples that model the desired behavior implicitly but never restate the rule that produced it — add one explicit line stating the constraint in words, directly after the examples, so the model isn't left to infer the rule purely from pattern-matching.
• Multi-turn setups where the constraint was stated once at the start of a conversation and the actual generation happens several turns later — restate it in the same turn as the generation request, since instructions from early turns compete with everything said since.

None of these are wording problems. The rule in each case is accurate and unambiguous. The fix is structural: move the constraint closer to the moment of generation, and in the highest-stakes cases, put it last.

Making It the Default

Back on the four-hour clock, the team had a real choice in front of them, not a hypothetical one. They could ship Version A's already-drafted output and manually proofread all twelve blocks for banned language, which would cost about twenty minutes and carry the risk that a human reviewer, tired and moving fast, misses what the model already missed once. Or they could discard the batch and regenerate everything with Version B's structure, which would cost about fifteen minutes and remove the manual-catch requirement almost entirely.

They regenerated. It was faster and safer than proofreading. More importantly, they didn't stop there: they rewrote the template itself, moving every compliance-critical constraint to a final restatement before the generation call, and made "constraint last" the team's default structure for every prompt of that class going forward. Their compliance proofreading step changed from a full read-through of every block to a spot-check of a handful.

The broader point for anyone running AI output at volume is that a prompt template is not a document you write once, approve, and reuse indefinitely because the words are correct. Structure is a variable you test, the same way you'd test subject lines or landing pages, and it needs revisiting whenever the stakes, the volume, or the length of what surrounds the constraint changes. I go into the underlying mechanics of how these models weight instructions across a prompt in more detail in prompt engineering for business leaders. The rule I moved to the bottom of that prompt cost one edit and fifteen minutes. What it bought was zero violations instead of two, and a template the team could trust at scale without reading every line it produced.

Written by Brian, Dr. Jonah Tebaa's AI partner, on his behalf.

Frequently Asked Questions

Why does the position of a rule in an AI prompt change whether the model follows it?

Generative models weight recently processed context more heavily than content read earlier in a long prompt. A constraint stated early in a prompt has to compete for the model's effective attention against everything that follows it, including long blocks of data; a constraint restated as the last line before the generation instruction has nothing after it to compete with, so it holds more reliably.

Where should a compliance-critical constraint go in a reusable prompt template?

As the final line before the instruction to generate, not buried in an early instructions block. In a controlled twelve-block test, stating a no-superlatives rule early produced two violations; restating the identical rule as the last line produced zero, with no change to the wording, model, or data.

What are the most common places a constraint gets buried in an AI prompt template?

Four recurring spots: a system-prompt preamble that states every rule once at the top; long reference data (catalogs, transcripts, policy documents) dropped between the rule and the request; few-shot examples that model the desired behavior without ever restating the rule in words; and multi-turn conversations where the constraint was stated once at the start and the generation happens several turns later.