How to Use ChatGPT Custom Instructions

Quick-Start (Copy This Right Now)

A freelance consultant set up ChatGPT's custom instructions once, in about two minutes, typing a vague sentence about wanting "professional but friendly" responses, and never revisited it. Six months later she was still manually explaining her industry, her typical client type, and her preferred response length in nearly every new conversation — the exact repetitive typing custom instructions exist to eliminate, made worse by the fact that she genuinely believed she'd already set them up properly.

That failure is common, and it's almost always because the two custom instruction fields — what you want ChatGPT to know about you, and how you want it to respond — get filled with vague, general statements instead of specific, actionable ones.

Here's a stronger starting point for the "what should ChatGPT know about you" field:

I work as a [specific role] in [specific industry]. My most common tasks involve [2-3 specific recurring task types]. When I ask about [common topic], assume I mean [specific context] unless I say otherwise.

What this does: specific recurring task types and default assumptions eliminate the need to re-explain your context in every new conversation, which is the entire point of custom instructions — without this specificity, a vague "I'm a marketer" statement doesn't actually save you from restating your actual context each time.

Understanding the Variables

The "what should ChatGPT know about you" field works best with concrete, stable facts — your role, your industry, your typical audience, recurring terminology specific to your work — rather than personality traits or general preferences, which belong in the second field instead.

The "how should ChatGPT respond" field works best with specific behavioral instructions rather than vague tone descriptions. "Be concise" is vague — concise compared to what? "Default to bullet points for lists of 3 or more items, and keep initial responses under 150 words unless I ask for more detail" is specific enough to actually shape behavior consistently.

Step-by-Step: Building Instructions That Actually Hold Up

Step 1: Audit what you re-explain most often.

Here are the last 10 things I've asked you across recent conversations: [paste or summarize a rough list]
What context or preference am I repeating across multiple conversations that could be moved into a standing instruction instead?

Step 2: Draft specific, behavioral instructions.

Based on that pattern, help me draft custom instructions for both fields. Make each instruction specific and testable — something that would produce a noticeably different response if followed versus not followed, not a vague aspiration.

Step 3: Test against a real recent question.

Here's a question I recently asked: [paste question]. Answer it again, but this time follow the draft instructions we just wrote. Does the response actually change in the way I intended?

A management consultant used this three-step process after realizing she'd been manually specifying "keep this at an executive summary level, not a detailed breakdown" in nearly every prompt for months. Moving that into her standing instructions, phrased specifically rather than vaguely, eliminated that repeated typing across nearly all of her subsequent conversations.

Pro-Level Variations

For instructions that need to vary depending on the type of task, rather than applying universally, a useful pattern separates general standing preferences from more specific per-project context that gets added at the start of a relevant conversation instead of baked into global custom instructions:

[In custom instructions]: I work across multiple client projects. Ask me which project or context this relates to if it's not clear, rather than assuming.
[At the start of a project-specific conversation]: This conversation relates to [specific project]. Context: [specific project details].

⚡ Pro tip: Not everything belongs in global custom instructions. Highly stable facts about your general role and default preferences belong there; project-specific or temporary context belongs at the start of individual conversations instead, since baking temporary details into global settings means they'll incorrectly apply to unrelated future conversations too.

A software engineer working across several different codebases uses this split deliberately: her custom instructions specify her general coding style preferences and experience level, which apply everywhere, while codebase-specific details — a particular framework version, an internal library's conventions — get stated fresh at the start of each relevant conversation instead of cluttering her global settings with details that only matter for one specific project.

Troubleshooting Common Issues

Issue: ChatGPT seems to ignore custom instructions after a long conversation. Fix: in very long conversations, standing instructions can lose prominence relative to more recent messages. Restating a key instruction briefly partway through a long conversation, rather than assuming it holds perfectly for the entire session, helps keep behavior consistent.

⚠️ Common mistake: writing custom instructions once and never revisiting them as your actual needs change. A freelancer's custom instructions written for a previous client type or previous typical task often don't match current needs, and outdated standing instructions can actively produce worse responses than no instructions at all, since they're shaping behavior around a context that no longer applies.

Setting a Reminder to Actually Revisit Instructions

Since outdated custom instructions are a genuinely common and easy-to-miss failure mode, it's worth building in a deliberate check rather than relying on remembering to update them whenever your situation changes.

[As a standing reminder, roughly every few months]: Here are my current custom instructions: [paste them]. Given how my work has changed recently — [briefly describe any changes], are any of these instructions now outdated or missing something that's become a recurring need?

What this does: treating custom instructions as something to periodically audit, rather than a one-time setup task, catches the slow drift between what your instructions describe and what your actual current work looks like. A freelancer who changed her primary client industry six months ago but never updated her custom instructions is effectively asking ChatGPT to optimize for a version of her work that no longer exists.

⚡ Pro tip: A simple recurring calendar reminder — even just once a quarter — to reread and update custom instructions catches drift before it accumulates into the kind of significant mismatch that quietly undermines their usefulness for months without you noticing.

What Custom Instructions Can't Fix

It's worth naming a limitation clearly: custom instructions shape general behavior across conversations, but they're not a substitute for providing specific context relevant to an individual question. A well-written standing instruction that says "I work in healthcare compliance" doesn't mean you can skip mentioning the specific regulation or specific situation relevant to today's particular question. Custom instructions handle the stable, recurring context so you don't have to retype it every time — they don't anticipate every specific detail a genuinely new question might need.

⚠️ Common mistake: assuming thorough custom instructions mean you never need to provide additional context again. Custom instructions reduce repetitive typing for stable facts about your general situation; they don't replace situation-specific details that change from question to question.

A Realistic Example of Both Fields Working Together

To make this concrete, here's what a fully worked example looks like for a specific persona — a freelance UX researcher who works across multiple client industries.

[What ChatGPT should know about you]:
I'm a freelance UX researcher. My work typically involves synthesizing interview and survey data into actionable recommendations for product teams. I often need to translate research findings for non-research stakeholders like engineers and executives who don't share my research background.

[How ChatGPT should respond]:
When I ask for help synthesizing research, default to organizing findings by theme rather than by individual participant, unless I specify otherwise. When I ask for help communicating findings to stakeholders, ask which audience type it's for before assuming a technical or non-technical framing. Keep initial responses focused and skip generic caveats about research limitations unless I specifically ask about methodology concerns.

What this does: this example shows both fields working together — the first field establishes stable facts about the role and its recurring challenges, while the second field translates those facts into specific behavioral defaults that actually change how responses get structured, rather than just describing a general tone. Notice that the second field even includes an instruction to ask a clarifying question in a specific situation, rather than assuming — which is itself a specific, testable behavior rather than a vague preference.

⚡ Pro tip: If you're unsure whether an instruction belongs in the "what to know" field or the "how to respond" field, ask whether it's a fact about your situation (know) or a rule about behavior (respond). Facts and behavioral rules serve different purposes, and mixing them into one long paragraph in either field tends to produce vaguer instructions than separating them clearly.

Your Turn

Audit what you find yourself re-explaining across conversations, and turn those patterns into specific, testable custom instructions rather than vague aspirational ones. Revisit them periodically as your actual needs shift, and keep genuinely temporary or project-specific context out of global settings. Save a running list of instruction drafts you're testing somewhere handy — PromptABCD is useful for tracking which specific instruction phrasings actually produced the behavior change you wanted, rather than relying on memory for what worked last time you tweaked them.