Practical ChatGPT Custom Instruction Examples for Knowledge Work

Summary

• Custom Instructions work best when you write them like a reusable operating manual: role, goals, constraints, and output format.
• Use a small set of instruction “blocks” (tone, structure, sourcing, assumptions, and QA checks) and swap them per task.
• For knowledge work, the highest-leverage instructions are: clarify-first questions, explicit deliverable formats, and decision criteria.
• Keep sensitive data out of instructions and prompts; treat them as reusable templates, not a vault for secrets.
• Pair Custom Instructions with a repeatable “save-find-reuse” workflow so your best instruction blocks don’t get lost across tools.

Custom Instructions can turn ChatGPT from “helpful but inconsistent” into “predictable enough for daily knowledge work” by telling it how to think, what to prioritize, and how to format results. The practical challenge is that many examples online are either too generic (“be concise”) or too rigid (“always do X”), which breaks as soon as you switch from a marketing brief to a technical spec.

This guide gives you copy/paste-ready Custom Instruction examples for consultants, marketers, researchers, developers, and content teams, plus a simple way to maintain multiple instruction sets without constantly rewriting them. Where platform behavior can change (Custom Instructions, Memory, Projects, Gemini equivalents), the focus here is on durable patterns you can apply even if UI labels move around.

How to think about Custom Instructions (so they stay useful)

Strong Custom Instructions do three jobs:

• Define your default working style (how you want answers structured, how much detail, what to ask before proceeding).
• Set boundaries (what not to do, what to avoid, what to flag as uncertain).
• Standardize outputs (so you can reuse results in docs, tickets, briefs, and emails with less cleanup).

A practical way to write them is as modular blocks. Instead of one long paragraph, you maintain a few short blocks you can mix and match:

• Role + context (who you are, what you do, what “good” looks like)
• Clarify-first behavior (what questions to ask before drafting)
• Output format (headings, tables, bullets, checklists, JSON, etc.)
• Quality checks (assumptions, edge cases, risks, next steps)
• Style constraints (tone, reading level, length)

Before you paste: safety and scope rules that prevent regret

• Do not store secrets in Custom Instructions (passwords, credentials, private keys, authentication codes, customer PII, or anything you would not paste into a shared document).
• Avoid brittle absolutes like “always” and “never” for content style. Prefer “default to” and “if X, then Y.”
• Separate “how to respond” from “what to know.” Custom Instructions are best for behavior and formatting. Put project-specific facts in the prompt or in your own reusable context snippets.
• Assume you will switch tools. Write instructions that still make sense if you later run them in another model or editor.

Practical Custom Instruction template (copy/paste)

Use this as a base, then swap the bracketed parts per role.

Custom Instruction examples by knowledge-work role

1) Consultant: problem framing + decision-ready deliverables

Custom Instructions example:

• You are my consulting analyst. Prioritize: problem definition, constraints, stakeholder goals, and decision criteria.
• Start by restating the problem in 1-2 sentences and listing what is known vs unknown.
• When giving recommendations, provide 2-3 options with trade-offs, risks, and a suggested choice.
• Use MECE-style grouping when listing issues or workstreams.
• End with a “Client-ready” section I can paste into an email.

Works well for: discovery notes, strategy memos, operating model outlines, meeting follow-ups.

2) Marketer: positioning, messaging, and campaign assets

Custom Instructions example:

• You are my marketing partner. Optimize for clarity, specificity, and audience-fit.
• Before writing copy, ask: target audience, awareness stage, offer, proof points, and channel.
• When I request copy, provide: 3 angles, 5 headline options, and 2 CTA options.
• Flag vague claims and rewrite them into concrete, supportable language.
• Default tone: confident, practical, not salesy.

Works well for: landing pages, email sequences, ad variants, messaging frameworks.

3) Researcher / analyst: structured synthesis and uncertainty handling

Custom Instructions example:

• You are my research assistant. Separate facts, assumptions, and open questions.
• When summarizing, use: Key points, Implications, Counterpoints, and What to verify next.
• If you are unsure, say so and propose what information would resolve it.
• Prefer neutral language; avoid overstating confidence.
• When I provide notes, extract: definitions, entities, claims, and a glossary.

Works well for: literature-style summaries of provided text, interview synthesis, competitive notes (from your own inputs), internal briefs.

4) Developer: requirements, edge cases, and implementation-ready outputs

Custom Instructions example:

• You are my senior engineering assistant. Ask clarifying questions about constraints, environment, and acceptance criteria.
• When proposing solutions, include: approach, complexity considerations, edge cases, and test ideas.
• When writing code, include brief comments and a short usage example.
• If multiple approaches exist, compare them and recommend one based on constraints.
• Prefer precise language; avoid hand-wavy steps.

Works well for: design notes, refactor plans, test plans, code review checklists, API usage examples.

5) Content team: editorial consistency and production checklists

Custom Instructions example:

• You are my editorial assistant. Optimize for scannability, accuracy, and usefulness.
• Default structure: Summary bullets, main sections with clear headings, examples, and a final checklist.
• When rewriting, preserve meaning, remove fluff, and keep terminology consistent.
• When I provide a brief, restate: audience, intent, and success criteria before drafting.
• Flag missing inputs (product details, constraints, claims that need support).

Works well for: blog drafts, SOPs, help-center articles, content refreshes.

Instruction “micro-blocks” you can reuse across roles

These are short blocks you can paste into Custom Instructions or into the first message of a new chat when you want a temporary behavior change.

Clarifying questions block

• Before answering, ask the minimum set of questions needed to avoid rework. If I do not answer, proceed with assumptions and list them.

Output-as-table block

• When comparing options, use a table with: Option, Pros, Cons, Risks, When to choose.

“Show your work” without verbosity

• Explain reasoning briefly in 3-6 bullets. If the reasoning is long, summarize and offer to expand.

Checklist finisher

• End with a checklist of next actions I can follow in order.

Meeting follow-up block

• When I paste meeting notes, produce: decisions, open questions, action items (owner + due date placeholders), and risks.

How Custom Instructions relate to Memory, Projects, and “reusable context”

Custom Instructions are best for stable preferences (format, tone, how to ask questions, how to present trade-offs). For anything that changes by client, campaign, repository, or quarter, you will still need a way to provide fresh context.

Depending on your setup, you might use:

• Project-based workspaces (when available in your AI tool) to keep related chats and context together.
• Memory-like features (when enabled) for lightweight preferences. Treat these as convenience, not as a system of record.
• Reusable context snippets you maintain yourself (brand voice, product facts, ICP definitions, coding standards, research rubrics).

Because these features and names can change over time, the durable approach is: keep your “instruction blocks” and “context snippets” in a place you can search quickly, then paste what you need into the tool you are using.

A repeatable workflow for saving and reusing your best instruction sets (Windows-friendly)

Most knowledge workers end up with multiple variants: one instruction set for client strategy, another for technical writing, another for code review, and so on. The friction is not writing them once; it is finding the right version when you need it.

Workflow: Save - Find - Reuse

• Save: Keep each instruction set as a named snippet in your own system (for example: “Consulting - Decision memo,” “Marketing - Landing page,” “Dev - Code review”). Store separate “micro-blocks” (clarify-first, table output, checklist finisher) so you can compose quickly.
• Find: When you start a new task, search for the closest matching snippet (e.g., “decision criteria,” “landing page,” “edge cases”) and pull it up.
• Reuse: Paste the instruction set into Custom Instructions (for longer-lived defaults) or into the first message of a new chat (for task-specific behavior). For Gemini or other tools without the same instruction UI, the same snippets still work as a first-message “operating mode.”

Where clipboard managers and snippet tools fit (without risky assumptions)

If you already use a clipboard manager or snippet manager, you can store instruction blocks there and retrieve them by search. If you do, keep the content non-sensitive and treat it like reusable text templates. If you need to share instructions across tools (ChatGPT, Gemini, docs, tickets), prioritize a setup where you can quickly search and copy/paste the right block.

Example: turning one vague instruction into a reusable “knowledge-work” instruction set

Vague: “Be concise and professional.”

Reusable:

• Default to a 3-bullet summary, then details under clear headings.
• Ask clarifying questions when the request lacks audience, constraints, or success criteria.
• When recommending, provide options with trade-offs and a suggested choice.
• End with next steps as a checklist.

This version is still “professional,” but it is also operational: it tells the model what to do when information is missing and how to package the output so you can use it immediately.

Common mistakes (and fixes) when writing Custom Instructions

• Mistake: Packing in project facts.
  Fix: Put stable behavior in Custom Instructions; paste project facts as a “context block” per task.
• Mistake: Over-constraining tone.
  Fix: Use “default tone” plus exceptions (e.g., “If writing to executives, be more direct”).
• Mistake: No failure mode.
  Fix: Add “If uncertain, say what you need to verify” and “List assumptions.”
• Mistake: One instruction set for everything.
  Fix: Maintain 2-5 role-based sets and a handful of micro-blocks.

One practical table: choose the right instruction style for the task

CTA: keep your best instruction blocks searchable across tools

If you want a Windows workflow for saving copied text locally, searching past clips, favoriting important clips, and separately saving reusable prompts you can paste into ChatGPT or Gemini, try CopyCharm. If you enable AI Access sync and authorize the ChatGPT connector, ChatGPT can search and retrieve only supported synced data (it cannot access unsynced local data); for Gemini and other apps, the workflow is still search/retrieve in the app, then copy/paste where you need it.

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