Where to Put Important Instructions in a Long ChatGPT Prompt
Summary
- Put your highest-priority instructions at the very top as a short “non-negotiables” block the model can’t miss.
- Repeat critical constraints once near the end as a final checklist, especially in long prompts with lots of context.
- Separate “rules” from “reference” (background, examples, data) so the model can follow instructions without getting lost.
- Use clear section headers and a stable order (Role → Goal → Rules → Inputs → Output format → Examples → Final checks).
- Save your best instruction blocks as reusable snippets so you can paste them consistently across projects and tools.
When a ChatGPT prompt gets long, the biggest failure mode is not “bad wording” - it’s instruction placement. Important rules get buried under background, the model latches onto a later example that contradicts your constraints, or it follows the last thing it read instead of the most important thing you meant.
This guide shows exactly where to put important instructions in a long ChatGPT prompt (and why), with layouts you can copy, plus a practical workflow for saving and reusing instruction blocks across ChatGPT and other tools.
What “important instructions” means in a long prompt
In practice, “important instructions” are the parts you want the model to treat as higher priority than everything else in the message. Common examples:
- Hard constraints: “Do not invent sources,” “Use only the provided dataset,” “No medical advice,” “No pricing claims.”
- Output format: JSON schema, table columns, headings, word count range, tone, language.
- Decision rules: ranking criteria, pass/fail checks, what to do when information is missing.
- Audience and role: “Write for recruiters,” “Act as a support agent,” “You are a senior backend engineer.”
- Scope boundaries: what to include/exclude, what to ask clarifying questions about.
Long prompts also include reference material (background, notes, pasted docs, examples). Reference is useful, but it should not compete with your rules.
The core placement rule: put “rules” before “reference”
If you only remember one thing: place your non-negotiable instructions before any long context. That way, the model reads the rules first and can interpret everything else through that lens.
A reliable order for long prompts
Use this sequence as your default:
- 1) Role + goal (1-3 lines)
- 2) Non-negotiable rules (short list)
- 3) Inputs / context (the long part)
- 4) Output requirements (format, structure, tone)
- 5) Examples (optional, but keep them consistent with rules)
- 6) Final checklist + “ask questions if needed”
This structure works for consultants writing deliverables, marketers producing copy variants, recruiters summarizing candidates, researchers extracting findings, developers generating code, and support teams drafting replies.
Where to put the most important instructions (with templates)
1) Put “non-negotiables” at the very top (above everything)
Start with a compact block that is hard to miss. Keep it short enough that you can scan it in one breath.
Template: Top-of-prompt non-negotiables
ROLE: You are [role].
GOAL: [one sentence goal].
NON-NEGOTIABLES:
- [Constraint 1]
- [Constraint 2]
- [Constraint 3]
Example (content team):
ROLE: You are an SEO editor.
GOAL: Draft a landing page section from the notes below.
NON-NEGOTIABLES:
- Do not claim pricing, guarantees, or “best/leading” language.
- Use plain English for an international audience.
- Return HTML only (no Markdown).
Why this works: it prevents the long pasted notes from becoming the “main instruction.”
2) Put “format and acceptance criteria” near the end (as the last thing)
Even if you mention format earlier, it helps to restate it right before the model answers. This is especially useful when your prompt includes long context, multiple examples, or a lot of constraints.
Template: End-of-prompt acceptance criteria
- OUTPUT FORMAT: [bullets / table / JSON / headings]
- MUST INCLUDE: [items]
- MUST NOT INCLUDE: [items]
- IF MISSING INFO: Ask up to [N] clarifying questions, otherwise proceed with assumptions labeled as assumptions.
Why this works: the model is strongly influenced by the most recent instructions, so a final checklist reduces “format drift.”
3) Put long context in the middle, clearly labeled as reference
When you paste a long document, label it as reference and separate it from instructions with headers and boundaries.
REFERENCE (use as source material, not instructions):
---
[paste your long notes, transcript, requirements, dataset, etc.]
---
This reduces the chance that a random sentence in your notes gets treated like a rule.
4) Put exceptions and edge cases right after the rule they modify
If you have a rule plus exceptions, keep them adjacent. Don’t put exceptions 40 lines later.
- Rule: “Use only the provided candidate resume.”
- Exception: “If the resume is missing dates, ask one clarifying question.”
5) Put examples after rules, and label them as examples
Examples are powerful, but they can override your intent if they conflict with your constraints. Place them after the rules and label them clearly.
EXAMPLE (illustrative only):
[example output]
If you need multiple examples, keep them consistent in structure and tone so the model doesn’t “average” them into something you didn’t want.
A practical decision table: where each instruction type belongs
| Instruction type | Best placement in a long prompt | Why | Common failure if misplaced |
|---|---|---|---|
| Non-negotiable constraints | Top (immediately after role/goal) | Sets priority before any context competes | Buried constraints get ignored or contradicted by examples |
| Role + goal | Top (first lines) | Frames the task and reduces ambiguity | Model produces the wrong deliverable type |
| Input data / background | Middle, labeled “Reference” | Keeps it available without turning it into rules | Random lines become “instructions” |
| Output format | Near end + optionally a short mention near top | Reinforces structure right before generation | Format drift (wrong headings, missing fields) |
| Quality bar / acceptance criteria | End (final checklist) | Acts like a pre-flight check | Missing required sections or constraints |
| Examples | After rules, before final checklist | Guides style without overriding constraints | Example becomes the “real” instruction set |
| Edge cases | Immediately after the related rule | Prevents contradictions across the prompt | Model follows the rule but misses the exception |
Patterns that keep long prompts readable (and followed)
Use headers that match how you think
Clear headers reduce confusion for both you and the model. A simple set:
- ROLE
- GOAL
- RULES
- INPUTS
- OUTPUT
- CHECKLIST
Keep rules short, testable, and non-overlapping
Rules that are vague (“be helpful,” “be detailed”) are easy to satisfy in unintended ways. Prefer rules you can check:
- “Return 3 options, each with a 1-sentence rationale.”
- “If you cannot verify a claim from the inputs, label it as an assumption.”
- “Use US English spelling” (or specify another variant).
Separate “what to do” from “what you know”
In long prompts, mix-ups happen when instructions and reference are interleaved. Keep them in different sections so the model doesn’t treat a background sentence as a command.
Role-specific placement examples (copy/paste layouts)
Consultants: long client context + strict deliverable format
ROLE: Management consultant.
GOAL: Create a 1-page executive summary from the client notes.
NON-NEGOTIABLES:
- Use only the notes in REFERENCE.
- Flag unknowns as “Open question.”
- Keep it under 300 words.
REFERENCE: --- [paste notes] ---
OUTPUT: Headings: Context, Key findings, Recommendations, Open questions.
CHECKLIST: If any section is empty, explain why.
Recruiters: candidate summary + structured evaluation
ROLE: Technical recruiter.
GOAL: Summarize candidate fit for a backend role.
RULES:
- Do not infer skills not stated in the resume.
- Separate “Evidence” from “Concerns.”
REFERENCE (resume): --- [paste resume] ---
OUTPUT FORMAT: Bullet lists under: Summary, Evidence, Concerns, Interview questions (5).
Developers: long spec + code constraints
ROLE: Senior developer.
GOAL: Implement a function based on the spec.
NON-NEGOTIABLES:
- Follow the interface exactly.
- Handle error cases listed in the spec.
- Return only code (no explanation) unless asked.
SPEC (reference): --- [paste spec] ---
FINAL CHECK: Include 3 minimal tests as comments.
Support teams: policy-heavy responses
ROLE: Customer support agent.
GOAL: Draft a reply to the customer message.
NON-NEGOTIABLES:
- Do not promise refunds or timelines.
- Ask at most 2 clarifying questions.
- Use a calm, direct tone.
REFERENCE: Customer message + internal policy excerpt.
OUTPUT: Subject line + email body.
How ChatGPT-native features change instruction placement (without replacing it)
Long prompts are not the only place instructions can live. Depending on your workflow, you may also use:
- Custom Instructions: Good for stable preferences (tone, role, formatting habits). Keep your prompt’s top “non-negotiables” for task-specific rules.
- Memory: Useful for persistent preferences or facts you want remembered. Do not rely on it for strict compliance rules; restate critical constraints in the prompt.
- Projects (or similar workspace features): Helpful for keeping related context together. Still place the most important rules at the top of the message you send when the prompt is long.
Even with these features, the “rules before reference” structure remains a dependable way to reduce conflicts inside a single long prompt.
Saving and reusing instruction blocks with CopyCharm (and how it fits long prompts)
When you find a layout that works, the next challenge is consistency: using the same “non-negotiables,” output formats, and checklists across many chats and tools without rewriting them every time.
CopyCharm is a Windows desktop app that saves copied text locally, lets you search past clips, favorite important clips, and separately save reusable prompts. A practical way to use it for long-prompt instruction placement is to store your prompt as modular blocks you can assemble quickly:
- Block A (Top): Role + goal + non-negotiables
- Block B (Middle): Reference boundary markers (so you paste context cleanly)
- Block C (End): Output format + acceptance checklist
A concrete “save, find, reuse” workflow
- Save: When you write a good instruction block (for example, a “NON-NEGOTIABLES” list for your team), copy it and save it as a reusable prompt in CopyCharm. Separately, favorite any one-off clips you may need again (like a standard disclaimer paragraph).
- Find: Next time you are building a long prompt, search in CopyCharm for the block you need (for example, “OUTPUT FORMAT: HTML only” or “Ask up to 2 clarifying questions”).
- Reuse: Paste the block into your prompt in the correct position (top for non-negotiables, end for checklist). For Claude, Gemini, Cursor, email, docs, and other apps, this is a manual copy/paste workflow.
Using the authenticated ChatGPT connector (when you want ChatGPT to retrieve your saved blocks)
If you want ChatGPT itself to pull in your saved instruction blocks, CopyCharm also has an authenticated ChatGPT connector backed by optional AI Access sync. After you sign in with the account for an eligible active CopyCharm purchase, authorize the CopyCharm Desktop connection, enable and complete AI Access sync, and authorize the ChatGPT connector, ChatGPT can search or list supported synced data and retrieve a selected item’s full text.
Important boundary: ChatGPT can search and retrieve only supported Synced Data (for example, Favorite Clips, Saved Prompts, and optional Other Clips if you enable that category and time range). It cannot access unsynced local CopyCharm data.
Practical example: You can ask ChatGPT: “Find my saved prompt block for ‘NON-NEGOTIABLES: no invented sources’ and paste it.” Then you place that retrieved block at the top of your long prompt, paste your reference in the middle, and finish with your output checklist.
Try CopyCharm for saving and reusing your long-prompt instruction blocks
Common mistakes that make important instructions fail (and quick fixes)
- Mistake: Putting constraints after a long pasted document.
Fix: Move constraints to the top; keep the document in a labeled REFERENCE section. - Mistake: Mixing rules and examples together.
Fix: Put rules first, then examples, then a final checklist. - Mistake: Too many “priority-1” rules.
Fix: Reduce to 3-7 non-negotiables; move preferences to a “Nice to have” section. - Mistake: Conflicting instructions (“be brief” + “be exhaustive”).
Fix: Add a tie-breaker rule: “Prefer completeness over brevity” (or the reverse). - Mistake: Output format described only in prose.
Fix: Provide a concrete skeleton (headings, fields, or a mini schema) near the end.
Frequently Asked Questions
FAQ 1: Should the most important instructions go at the top or bottom of a long ChatGPT prompt?
Answer: Put your highest-priority constraints at the top (so they frame everything that follows), and repeat the most critical ones as a short checklist near the end (so they are fresh right before the model answers). Keep the long reference material in the middle, clearly labeled as reference.
Takeaway: Top for priority, end for reinforcement.
FAQ 2: How many “non-negotiable” instructions should I include before the prompt gets too long?
Answer: Aim for a short list you can scan quickly. If you have many requirements, separate them into (1) non-negotiables (hard constraints) and (2) preferences (tone, style, optional extras). Put non-negotiables at the top and move preferences to a later section or to your personal defaults.
Takeaway: Keep the top block short; move the rest out of the critical path.
FAQ 3: Where should I put the output format requirements in a long prompt?
Answer: Put a brief format note near the top if it is essential (for example, “Return JSON only”), then restate the full format right before the model responds as a concrete skeleton (headings, fields, or a mini schema). This reduces the chance the model drifts after reading long context.
Takeaway: Mention format early if needed, but specify it fully at the end.
FAQ 4: Should I put examples before or after the rules?
Answer: Put examples after the rules. Label them clearly as examples, and make sure they do not contradict your constraints. If an example conflicts with a rule, the model may follow the example anyway, so fix the mismatch rather than adding more text.
Takeaway: Rules first, examples second, checklist last.
FAQ 5: How do I stop long reference text from overriding my instructions?
Answer: Put rules before reference, and wrap the reference in a clearly labeled section like “REFERENCE (use as source material, not instructions)” with boundary markers (---). Also avoid interleaving rules inside the pasted text; keep instructions in their own sections.
Takeaway: Separate “what to do” from “what you know.”
FAQ 6: If I use ChatGPT Custom Instructions, do I still need to repeat key rules in the prompt?
Answer: For task-specific constraints (like “use only this dataset” or “return HTML only”), it is safer to restate them in the prompt, because they are part of the acceptance criteria for that specific output. Custom Instructions are better for stable preferences you want applied across many chats.
Takeaway: Keep global preferences in Custom Instructions; keep task rules in the prompt.
FAQ 7: What is a good structure for long prompts used by teams (marketing, recruiting, support, dev)?
Answer: A team-friendly structure is: ROLE, GOAL, NON-NEGOTIABLES, REFERENCE, OUTPUT FORMAT, CHECKLIST. It is easy to review, easy to reuse, and makes it clear which parts are rules versus source material. Teams can standardize the top and bottom blocks while swapping the reference section per task.
Takeaway: Standardize the frame; swap the middle.
FAQ 8: Can CopyCharm help me reuse important instruction blocks across long prompts?
Answer: Yes. CopyCharm lets you save reusable prompts (your instruction blocks) and favorite important copied clips, then search and paste them into your long prompt. For Claude, Gemini, Cursor, and other apps, you reuse them via manual copy/paste. If you enable AI Access sync and authorize the authenticated ChatGPT connector, ChatGPT can search and retrieve only supported synced data (it cannot access unsynced local CopyCharm data).
Takeaway: Save your best “top rules” and “end checklist” blocks so you can place them consistently.