How to Put Role, Goals, and Context Into Custom Instructions

Summary

• Custom Instructions work best when you separate Role (who the assistant is), Goals (what “good” looks like), and Context (what the assistant should assume).
• Keep instructions stable and reusable; put changing details (today’s task, a specific client, a one-off dataset) in the chat or a project brief instead.
• Write instructions as testable behaviors (format, tone, constraints, and “ask clarifying questions when…”), not as vague preferences.
• Use a two-layer approach: global defaults in Custom Instructions + per-workstream “context packs” you paste when needed.
• Review and iterate with a simple checklist: reduce contradictions, remove sensitive data, and confirm the model can follow your output format reliably.

If you use Custom Instructions to “set the assistant up” for your work, the hard part is deciding what belongs there versus what should live in a per-project brief or a reusable snippet. This guide shows a practical way to put role, goals, and context into Custom Instructions so you get consistent outputs without overloading the model or accidentally baking in details that change every week.

This is written for consultants, marketers, researchers, developers, and content teams who run repeatable AI workflows across tools (ChatGPT, Gemini, and others) and want instructions that are easy to maintain.

What “Role, Goals, and Context” mean (and why separating them matters)

When Custom Instructions get messy, it’s usually because they mix three different things:

• Role: The stance the assistant should take (e.g., “act as a technical editor,” “act as a product marketer,” “act as a research assistant”).
• Goals: The outcomes you want consistently (e.g., “be concise,” “surface risks,” “provide options,” “cite assumptions,” “end with next steps”).
• Context: The background the assistant should assume (e.g., your audience, your product constraints, your preferred writing conventions, your tech stack).

Keeping these separate helps you:

• Reduce contradictions (e.g., “be extremely concise” vs “be exhaustive”).
• Make instructions reusable across tasks.
• Debug outputs faster (“Is the role wrong, the goal unclear, or the context missing?”).

What belongs in Custom Instructions vs. the chat (or a project brief)

Custom Instructions are best for stable preferences and stable constraints. Put anything that changes frequently somewhere else (a per-project brief, a reusable snippet, or the first message of a new thread).

Important safety note: Do not store passwords, API keys, private keys, authentication codes, or other secrets in Custom Instructions, chats, clipboard tools, or snippet libraries.

A practical template: Role + Goals + Context (copy/paste and customize)

Use this as a starting point. Keep it short enough that you can maintain it, but specific enough that you can tell when the assistant followed it.

1) Role (who you want the assistant to be)

• Role statement: “Act as a [role] helping a [your job function/team].”
• Scope boundaries: “If a request needs legal/medical/financial advice, provide general info and suggest consulting a qualified professional.”
• Collaboration style: “If requirements are unclear, ask up to 3 clarifying questions before drafting.”

Example (consultant):
“Act as a senior strategy consultant. Be direct and structured. If the prompt is ambiguous, ask up to 3 clarifying questions, then propose a reasonable assumption set and proceed.”

2) Goals (what “good output” looks like)

Write goals as observable behaviors. Good goals are easy to check.

• Structure: “Start with a 3-5 bullet summary, then details.”
• Decision support: “Provide 2-3 options with tradeoffs and a recommendation.”
• Quality control: “List assumptions and risks; flag missing inputs.”
• Style: “Use plain English; avoid hype; avoid filler.”

Example (marketer):
“Optimize for clarity and conversion. Provide 3 headline options, 3 subhead options, and a short rationale. Keep claims qualified; avoid unverifiable superlatives.”

3) Context (what the assistant should assume)

Context is where you encode your “defaults.” Keep it stable and non-sensitive.

• Audience: “Write for [persona], assume [knowledge level].”
• Brand voice: “Tone: [direct/helpful/technical], avoid [jargon/emoji/etc.].”
• Constraints: “We support [platforms], we do not support [platforms].”
• Preferences: “Prefer examples, checklists, and step-by-step instructions.”

Example (developer):
“Assume Windows environment. Prefer minimal dependencies. When giving code, include a short explanation, edge cases, and a quick test plan.”

How to write Custom Instructions that stay effective over time

Use “defaults,” not “details”

A good rule: if you expect it to change within a month, it probably does not belong in Custom Instructions. Put it in a reusable snippet or the first message of a thread instead.

Make instructions non-conflicting

Common conflicts to remove:

• “Be concise” + “Include everything” (choose one, or define when to expand).
• “Ask questions first” + “Don’t ask questions” (define a threshold: ask only when blocked).
• “Use a friendly tone” + “No fluff” (define “friendly” as “polite, direct”).

Prefer “when/then” behaviors

Models follow conditional rules better than vague preferences.

• Instead of: “Be thorough.”
• Try: “If the task is ambiguous, ask clarifying questions. If it is clear, produce a draft plus a short checklist of risks.”

Define output formats you can reuse

If you want consistent deliverables, specify a stable format. Examples:

• Consulting memo: Summary → Situation → Options → Recommendation → Risks → Next steps
• Research note: Question → Assumptions → Findings → Confidence/limits → Sources provided by user (if any) → Next questions
• Engineering plan: Goal → Constraints → Approach → Pseudocode → Edge cases → Test plan

Role/Goals/Context examples by job type (ready to adapt)

Consultants

Role: “Act as a senior consultant. Be structured and pragmatic.”
Goals: “Provide options with tradeoffs; recommend one; include risks and assumptions.”
Context: “Audience is busy executives; keep it skimmable; avoid jargon unless defined.”

Marketers and content teams

Role: “Act as a conversion-focused content strategist and editor.”
Goals: “Generate multiple angles; keep claims qualified; include CTA suggestions and objections.”
Context: “Write in clear international English; avoid idioms; use short paragraphs and scannable headings.”

Researchers and analysts

Role: “Act as a research assistant focused on clarity and uncertainty.”
Goals: “Separate facts from assumptions; propose what data would resolve uncertainty; provide a concise synthesis.”
Context: “Prefer tables for comparisons; define terms; note limitations.”

Developers

Role: “Act as a senior software engineer and code reviewer.”
Goals: “Give minimal working examples; explain tradeoffs; include edge cases and tests.”
Context: “Assume Windows; prefer secure-by-default patterns; never request or store secrets.”

How Custom Instructions interact with other “context” features (and what to do instead)

AI platforms change quickly, and features like “memory,” “projects,” “gems,” “personalization,” or “saved info” can affect what the assistant remembers or prioritizes. Rather than relying on any single feature name, use a resilient workflow:

• Custom Instructions: Your stable defaults (role/goals/context).
• Per-workstream context pack: A reusable snippet you paste when starting a new thread for a specific client, product, or research track.
• Per-task brief: The exact inputs for today (requirements, constraints, source text).

This approach keeps your “always-on” instructions clean while still giving the model enough context to do good work.

Repeatable workflow: save, find, and reuse your best instruction blocks (Windows-friendly)

If you work across multiple AI tools, the friction is rarely writing instructions once - it is finding the right version when you need it and reusing it consistently.

Step 1: Create three reusable blocks

• Global Custom Instructions block: Your stable role/goals/context defaults.
• Workstream context packs: One per recurring area (e.g., “B2B SaaS launch,” “User research synthesis,” “Python data cleaning,” “SEO brief writing”).
• Output format snippets: Memo template, PRD template, test plan template, etc.

Step 2: Store them somewhere you can search quickly

You can use a notes app, a snippet manager, or a clipboard-history tool - the key is being able to search and retrieve the exact block you need without rewriting it. If you use a clipboard manager, keep your instruction blocks clearly separated from anything sensitive, and avoid copying secrets into your clipboard history.

Step 3: Reuse with a consistent “paste order”

• Start a new chat/thread.
• Paste the workstream context pack (only if needed).
• Paste the task brief (today’s inputs and constraints).
• Ask for the deliverable using your output format snippet.

This keeps Custom Instructions stable while still giving you repeatable, high-signal context per task.

Common mistakes (and quick fixes)

• Mistake: Putting client-specific details into Custom Instructions.
  Fix: Move them into a per-client context pack you paste only when needed.
• Mistake: Writing goals as vibes (“be smart,” “be helpful”).
  Fix: Convert to behaviors (“provide 3 options,” “ask 2 clarifying questions,” “end with next steps”).
• Mistake: Over-constraining tone and format so outputs become rigid.
  Fix: Specify a default format, then allow exceptions (“If the user asks for a different format, follow it.”).
• Mistake: Forgetting to tell the assistant what to do when uncertain.
  Fix: Add an uncertainty rule (“state assumptions; ask questions; propose a plan to validate”).

A simple review checklist (run this monthly)

• Role: Is it still the role you want day-to-day?
• Goals: Are they testable and non-conflicting?
• Context: Is it stable, non-sensitive, and still true?
• Length: Can you read it quickly and understand it?
• Results: Did it improve consistency across your last 10 tasks?

If you want a Windows-native way to keep your instruction blocks searchable alongside other copied text, you can use CopyCharm to save copied text locally, search past clips, favorite important clips, and separately save reusable prompts so you can retrieve and reuse your role/goals/context blocks across tools. (For Gemini, email, documents, and other apps, the workflow is manual: search/retrieve in the app, then copy/paste into the destination.)

Frequently Asked Questions

Back to FAQ Table of Contents

Back to FAQ Table of Contents

Back to FAQ Table of Contents

Back to FAQ Table of Contents

Back to FAQ Table of Contents

Back to FAQ Table of Contents

Back to FAQ Table of Contents

Back to FAQ Table of Contents

Related Guides

• What Is an AI Context Pack?
• How to Prepare Better Context for ChatGPT
• How to Organize Copied Text for AI Work
• Source-Labeled Context for AI: Why It Matters
• ChatGPT Context Pack for Consultants