Custom GPT Instructions: Examples and a Reusable Template
Summary
- Use Custom GPT Instructions to define a GPT's role, boundaries, tone, and step-by-step workflow so outputs stay consistent across chats.
- This article includes a reusable instructions template you can copy, plus fill-in guidance for different use cases.
- You'll get concrete examples (support, sales, tutoring, analysis, writing) and what to change when results drift.
- Learn practical guardrails: what to do with missing info, how to handle citations, and how to avoid overconfident fabrication.
- See a repeatable way to save, find, and reuse your best instruction blocks (including an optional CopyCharm workflow).
Custom GPT Instructions template + examples: copy the reusable block below, fill in your role, inputs, constraints, and output format, then iterate with a short test set.
What "Custom GPT Instructions" are (and what they are not)
Custom GPT Instructions are the persistent directions you give a Custom GPT so it behaves consistently: how it should think through tasks, what it should ask you, what it must avoid, and how it should format results. They are different from the one-off prompt you type in a single chat message.
They also differ from built-in platform features like chat history, Projects, or Memory. Those features (availability can vary by account and plan) may help with continuity, but instructions are where you define the GPT's operating rules. If you rely on Memory or prior chat context alone, your GPT can drift when a new conversation starts or when context is missing.
The reusable Custom GPT Instructions template (copy/paste)
Paste this into your Custom GPT Instructions, then replace the bracketed fields. Keep it as short as possible while still being unambiguous.
## 1) Role and mission
You are: [ROLE]
Mission: [WHAT SUCCESS LOOKS LIKE IN 1-2 SENTENCES]
Primary audience: [WHO YOU'RE HELPING]
Domain: [INDUSTRY / TOPIC AREA]
## 2) Operating principles (non-negotiables)
- Be accurate and explicit about uncertainty. If you don't know, say what you need.
- Do not invent facts, quotes, sources, links, or numbers.
- If the user request conflicts with policy or safety, refuse briefly and offer a safe alternative.
- Keep outputs practical and actionable.
## 3) Inputs you should request (when missing)
Before answering, check for:
- Goal: [WHAT YOU NEED TO KNOW]
- Context: [SYSTEM / PRODUCT / AUDIENCE / CONSTRAINTS]
- Constraints: [TIME, BUDGET, TOOLS, LENGTH]
- Examples: [SAMPLES, REFERENCES, PAST OUTPUTS]
If any are missing, ask up to [1-3] targeted questions. If the user says "just do it," proceed with reasonable assumptions and list them.
## 4) Workflow (how you should work)
Follow this process:
1) Restate the task in one sentence.
2) List assumptions (only if needed).
3) Produce the output in the required format.
4) Add a short "Next steps" section with options to refine.
## 5) Output format requirements
Use: [BULLETS / TABLES / JSON / SECTIONS]
Tone: [FRIENDLY / DIRECT / FORMAL / BRAND VOICE]
Length: [SHORT / MEDIUM / LONG] with a hard limit of [X] words if needed.
Include: [CHECKLISTS / EXAMPLES / EDGE CASES]
Avoid: [JARGON / EMOJIS / SALESY LANGUAGE / LEGAL ADVICE]
## 6) Quality checks
Before finalizing:
- Verify the output matches the user's goal and constraints.
- Remove filler and repetition.
- Flag anything that requires confirmation.
## 7) Boundaries and escalation
If the user asks for:
- Medical/legal/financial advice: provide general info and suggest a professional.
- Sensitive personal data handling: minimize data and ask for consent.
- Proprietary/confidential content: warn the user and proceed cautiously.
## 8) Optional: house style (if relevant)
- Preferred spelling: [US English]
- Formatting: [HEADINGS, SHORT PARAGRAPHS, CODE BLOCKS]
- Examples should be: [REALISTIC / GENERIC / INDUSTRY-SPECIFIC]How to fill the template (so it actually works)
1) Make the mission testable
Vague missions ("help with marketing") produce vague behavior. A testable mission includes a deliverable and a success condition.
- Weak: "Help users write better emails."
- Stronger: "Draft customer support emails that resolve the issue, match our tone, and include a clear next step in under 150 words."
2) Turn preferences into rules
If you care about structure, say exactly what structure you want. If you care about safety, define what the GPT should do when it lacks information.
- Instead of: "Be concise."
- Use: "Use 5-8 bullets, then a 2-sentence wrap-up. No preamble."
3) Add "ask-first" triggers
Many instruction sets fail because the GPT guesses when it should ask. Add triggers like:
- "If the user asks for a plan, ask for timeline and constraints."
- "If rewriting copy, ask for audience, offer, and channel if missing."
- "If analyzing data, ask for definitions of metrics and the time range."
4) Specify what not to do
Negative constraints reduce unwanted behavior. Examples:
- "Do not claim you tested anything."
- "Do not cite sources unless the user provides them."
- "Do not output private personal data; ask the user to redact."
Custom GPT Instructions examples (ready to adapt)
Each example below is intentionally short. You can paste one into your template's Role/Mission/Workflow sections and adjust the output format.
Example 1: Customer support reply drafter
Role: Customer Support Reply Drafter
Mission: Write a helpful, accurate reply that resolves the user's issue and proposes the next step.
Ask-first: product name/version, what they expected, what happened, error message, steps tried.
Workflow: diagnose likely cause, propose 2-3 fixes, then ask for confirmation.
Output: Subject line + email body. 120-180 words. Friendly, calm tone.
Avoid: blaming the user, promising refunds or policy outcomes.Example 2: Sales discovery call question builder
Role: Sales Discovery Assistant
Mission: Generate discovery questions that uncover pain, impact, decision process, and timeline.
Ask-first: ICP, product category, deal stage, call length.
Output: 12 questions grouped into: Goals, Current process, Pain/impact, Stakeholders, Budget/timeline, Next steps.
Avoid: aggressive language, assumptions about budget.Example 3: Tutor that checks understanding
Role: Tutor
Mission: Teach the concept clearly, then verify understanding with short questions.
Workflow: explain in simple terms, give a worked example, then ask 2 check questions.
Output: Headings: Explanation, Example, Quick Check, Answers.
Avoid: skipping steps; if the user is stuck, offer a simpler analogy.Example 4: Analyst that separates facts from assumptions
Role: Business Analyst
Mission: Provide structured analysis while clearly separating facts, assumptions, and recommendations.
Workflow: restate goal, list assumptions, analyze options, recommend with trade-offs.
Output: Sections: Summary, Assumptions, Options (table), Recommendation, Risks.
Avoid: invented metrics; if numbers are missing, propose what to measure.Example 5: Brand-voice copy rewriter
Role: Brand Voice Rewriter
Mission: Rewrite text to match the provided voice while preserving meaning.
Ask-first: target channel (email/landing page/ad), audience, desired CTA, brand voice sample.
Output: 3 variants + a short note explaining key changes.
Avoid: adding new claims, adding testimonials, or implying guarantees.Limitations to plan for (so your instructions don't backfire)
Instructions cannot replace missing inputs
Even strong instructions won't magically supply product details, policies, or internal facts you haven't provided. Your instructions should define what to do when information is missing: ask questions, proceed with assumptions, or provide a checklist of what to gather.
Overly long instructions can dilute priorities
If you add too many rules, the GPT may follow the wrong ones first. Keep a short "non-negotiables" list and move nice-to-haves into optional sections.
Be careful with "always" rules
Rules like "always ask three questions" can be annoying when the user wants a quick rewrite. Prefer conditional rules: "Ask questions only when missing info would change the answer."
A simple test-and-iterate method (10 minutes)
- Create a mini test set: 5 prompts you expect to use repeatedly (one easy, one ambiguous, one edge case).
- Run them: Check whether the GPT asks the right questions, follows format, and avoids unwanted claims.
- Patch the instructions: Add one rule at a time (ask-first triggers, output format, avoid list).
- Re-test: Confirm the patch fixed the issue without breaking the other cases.
How to save and reuse instruction blocks without rewriting them every time
Even if you use Custom GPTs, you'll still end up with reusable instruction blocks: a house style, a "facts vs assumptions" policy, a standard output format, or a safety boundary section. The practical challenge is finding the right block quickly when you're creating a new GPT or adjusting an existing one.
A concrete CopyCharm workflow for Custom GPT Instructions
CopyCharm is a Windows desktop app that saves copied text locally, lets you search past clips, favorite important clips, and separately save reusable prompts. For Custom GPT Instructions, that can be useful when you want a personal library of instruction modules you can paste into new GPTs.
- What you save: Copy your best instruction blocks (for example: "Ask-first triggers," "Output format: table," "No invented sources") and save them as Saved Prompts. If you copy a great instruction set from a doc or chat, it can also live as a searchable clip; mark key ones as Favorite Clips.
- When you find it: When you're building or revising a Custom GPT, search in CopyCharm for the block you need (for example: "assumptions section" or "rewrite 3 variants").
- How you reuse it: Copy from CopyCharm and paste into your Custom GPT Instructions field, then adjust the bracketed parts.
Optional: letting ChatGPT retrieve your saved instruction blocks (supported synced data only)
If you want ChatGPT to help you pull up your saved instruction blocks, CopyCharm offers 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 recent supported Synced Data and retrieve a selected item's full text.
Important boundary: ChatGPT can only access supported data that you chose to sync (Favorite Clips, Saved Prompts, and optionally Other Clips within your selected time range). It cannot access unsynced local CopyCharm data. Retrieval is user-directed, and it does not modify ChatGPT Memory, Projects, native chat history, or account settings.
CTA: If you want a reusable library for instruction blocks you can search and paste (and optionally make available to ChatGPT via synced data), you can explore CopyCharm at https://copycharm.ai.
Frequently Asked Questions
FAQ 1: What should I put in Custom GPT Instructions?
Answer: Include (1) the GPT's role and mission, (2) non-negotiable rules (accuracy, uncertainty, safety boundaries), (3) what inputs to request when missing, (4) a simple workflow the GPT should follow, and (5) output format requirements (tone, length, structure). Add a short "avoid" list for common failure modes you see.
Takeaway: Good instructions define behavior, questions to ask, and output format, not just a vague persona.
FAQ 2: What is a good Custom GPT Instructions template I can reuse?
Answer: Use a modular template with sections for Role/Mission, Operating principles, Inputs to request, Workflow, Output format, Quality checks, and Boundaries. The template in this article is designed so you can swap modules (for example, change only the output format section when moving from emails to analysis).
Takeaway: Reusable templates work best when they are modular and easy to edit.
FAQ 3: How long should Custom GPT Instructions be?
Answer: Long enough to remove ambiguity, short enough that priorities stay clear. If your instructions are getting lengthy, keep a tight "non-negotiables" section near the top and move optional preferences into a separate section. If outputs drift, add one targeted rule rather than a large block of new text.
Takeaway: Clarity beats length; add rules only when they fix a real failure case.
FAQ 4: How do I stop a Custom GPT from making up facts?
Answer: You can't fully prevent errors, but you can reduce them by adding explicit constraints: "Do not invent facts, quotes, sources, links, or numbers," plus a required behavior when information is missing (ask targeted questions or list assumptions). Also instruct it to label uncertainty and to separate "facts" from "assumptions" in the output when appropriate.
Takeaway: Add explicit anti-fabrication rules and a clear missing-info workflow.
FAQ 5: Should my instructions tell the GPT to ask questions first?
Answer: Yes, but make it conditional. Tell it what to check for (goal, audience, constraints, examples) and to ask only the minimum number of questions needed. If the user wants a fast answer, instruct the GPT to proceed with reasonable assumptions and list them briefly.
Takeaway: "Ask-first" works best as a trigger, not a rigid rule.
FAQ 6: How do I write instructions for consistent formatting (tables, bullets, JSON)?
Answer: Specify the exact structure and constraints: required headings, bullet count ranges, table columns, or a JSON schema. Also add a quality check like "Validate the output matches the required format before finalizing." If you need multiple formats, tell it when to use each (for example, "Use a table for comparisons; use bullets for action steps").
Takeaway: Formatting consistency comes from explicit structures, not tone guidance.
FAQ 7: Why does my Custom GPT follow instructions sometimes but not others?
Answer: Common causes include conflicting rules (two sections that imply different priorities), missing inputs (the GPT guesses), and instructions that are too vague to enforce ("be helpful"). Tighten priorities by making non-negotiables explicit, adding ask-first triggers, and defining a single output format. Then test with a small set of prompts and patch one issue at a time.
Takeaway: Reduce conflicts, clarify triggers, and iterate with a small test set.
FAQ 8: Can CopyCharm help me reuse Custom GPT instruction blocks across projects?
Answer: If you work on Windows, CopyCharm can store copied instruction blocks locally, help you search past clips, and let you save reusable prompts separately so you can paste them into new Custom GPT Instructions quickly. If you enable AI Access sync and authorize the authenticated ChatGPT connector, ChatGPT can search and retrieve only supported synced data (such as Saved Prompts and Favorite Clips you chose to sync), not unsynced local CopyCharm data.
Takeaway: Use CopyCharm as a searchable library for instruction modules, with optional synced retrieval inside ChatGPT.