+150 XP

ChatGPT · Custom instructions and consistent results

Custom instructions let you set your role, tone and output format once so every chat follows them without re-pasting a preamble. Instead of starting each conversation with "Act as a senior data analyst, be concise, use British English," you configure it in one place and ChatGPT applies it silently to every new chat.

This sounds small. It is not. Custom instructions are the cheapest, highest-return personalization in the OpenAI ecosystem, and most professionals fill them in once, badly, and never touch them again.

What custom instructions actually are

Custom instructions are persistent text that gets injected into the context of every new conversation. You set them in ChatGPT under Settings → Personalization. The official reference lives at help.openai.com on custom instructions. Labels shift a little between app versions, but the page currently has three parts:

  1. A base style or personality preset (for example Default, Robot, Nerd, Cynic or Listener). This is a quick dial for overall tone.
  2. Custom instructions: a free-text field for how ChatGPT should respond. It covers tone, format, length and what to avoid.
  3. About you: a nickname, your occupation, and a "more about you" field. It covers your work, your audience and your constraints.

The preset is a starting point. The custom instructions field and the "more about you" field are where the real control is, because they let you write specific rules instead of picking a mood.

These are different from memory, which learns facts about you across conversations on its own. Custom instructions are explicit and stable. Memory is inferred and evolving. You write custom instructions; ChatGPT writes memory. Both feed the model, but you fully control the first. You can review or switch off memory on the same settings page.

Before and after: the house-style example

Here is a generic prompt with no custom instructions:

You: Write a short update about our API rate limit change.
ChatGPT: Sure! Here's a friendly update you can use: "Hi everyone! 🎉 We're excited to share that we've updated our API rate limits..."

Enthusiastic, emoji-laden, vague. Now the same prompt with personalization filled in.

More about you:

I'm a developer-relations lead at a B2B fintech API company.
My audience is technical: backend engineers integrating our REST API.
We publish changelog entries and email notices. Compliance reviews everything.

Custom instructions (how to respond):

Write in plain, direct English. No emoji, no exclamation marks, no "I'm excited to".
Lead with the change and its effective date. State the old value and the new value.
Include one sentence on the action the reader must take.
Default to under 120 words unless I ask for more. Use British spelling.

Same prompt, new result:

ChatGPT: Rate limit increase, effective 14 March 2026. The default limit on /v2/transactions rises from 100 to 300 requests per minute. Existing integrations need no code changes; the new ceiling applies automatically. If you currently implement client-side throttling at 100 RPM, you may raise it to 300 to improve throughput. Burst limits and the 429 retry-after header are unchanged.

That is your house style, applied automatically, in every new chat, with zero prompt overhead. The model is doing the same work. You have removed the ambiguity it would otherwise fill with defaults.

How to write instructions that hold

The mistake is writing aspirational fluff ("be helpful and smart"). The model is already trying to be helpful. Instructions only matter where they resolve a choice the model would otherwise make for you.

Be specific about defaults, not vibes

"Be concise" is weak. The model has no number. Compare:

Weak:    Keep answers short and to the point.
Strong:  Default to under 150 words. For code, give the snippet first,
         then at most three bullets of explanation. Skip preamble like
         "Great question".

Encode format, because format is where time is lost

If you always paste output into Slack, Jira or a CMS, say so:

When I ask for a Jira ticket, output: a one-line summary, a description
in plain text (no markdown headers), and a bulleted acceptance criteria
list. Do not wrap the whole thing in a code block.

State what to suppress

Negative instructions are powerful here. "Do not hedge with 'it depends' unless you then give me the deciding factor." "Do not apologise." "If you are uncertain, say so in one line and give your best answer anyway."

Keep them short and orthogonal

These fields share the context with everything else in the chat. Bloated instructions dilute the signal, and a preset that says one thing while your text says another produces mixed results. Aim for tight, non-overlapping rules, and pick the preset closest to what you wrote. A dozen sharp lines beat three paragraphs of prose.

How to Use ChatGPT Custom Instructions

Watch on YouTube

Where custom instructions stop, and Projects begin

Custom instructions are global. They apply to every standalone chat. But your house style for client emails is not the same as your house style for SQL debugging. Cramming both into the global field creates contradictions.

This is what Projects solve. A Project is a workspace with its own instructions, its own uploaded files and its own chat history, separate from your global settings. Inside a Project, you set project-specific instructions that layer on top of (and can override) your global ones.

A clean division of labour:

  • Global custom instructions: who you are, your language, your universal anti-patterns (no emoji, British spelling). The stuff true everywhere.
  • Project instructions: the rules for one body of work. "This Project is the Q2 onboarding redesign. Reference the uploaded PRD. Assume the reader is a product manager, not an engineer."

So when you spin up a "Compliance Comms" Project, you do not re-type your tone rules. You inherit them and add the project-specific ones. See help.openai.com on Projects for file and instruction scoping.

Knowledge check

1. What is the primary purpose of custom instructions in ChatGPT?

2. What is the key distinction between custom instructions and memory in ChatGPT?

3. Why does the lesson call custom instructions 'the cheapest, highest-leverage personalization'?

MULTIPLE CHOICE

4. Select ALL statements that correctly describe the two main custom instruction boxes.

Select all the correct answers.

MULTIPLE CHOICE

5. In the house-style example, what problems with the default (no instructions) output did the custom instructions fix? Select ALL that apply.

Select all the correct answers.

When you need more than instructions: Custom GPTs

If you keep rebuilding the same context, files and tone for something other people will use, you have outgrown personal instructions. That is a Custom GPT. It is a packaged, shareable assistant with its own instructions and knowledge files. You can switch on built-in capabilities such as web search, code execution and image generation. You can also add Actions, which are calls to external APIs you describe with a schema.

Do not confuse these with ChatGPT's account-level apps (formerly called Connectors), which link your own ChatGPT to services like Google Drive or GitHub. Those belong to you. A Custom GPT's Actions belong to the GPT.

The relationship is a ladder:

ToolScopeShareableBest for
Custom instructionsEvery chat, just youNoYour personal default behavior
Project instructionsOne workspaceLimited (shared Projects on some plans)One ongoing body of work
Custom GPTA named assistantYes, via link or GPT StoreA repeatable role others will reuse

The instructions field in a Custom GPT is the same idea as your custom instructions, scaled up: it is the system prompt for that assistant. Everything you learned about writing tight, specific, format-first rules applies directly when you build one.

The same principle in the API

Custom instructions are ChatGPT's UI for what the API calls system instructions. When you move from the ChatGPT app to the OpenAI platform, your "how to respond" rules become the instructions parameter on the Responses API, or a system message in Chat Completions.

This is the bridge worth seeing once: the discipline you build writing good custom instructions transfers directly to production code.

python
from openai import OpenAI

client = OpenAI()

HOUSE_STYLE = (
    "Write in plain, direct English. No emoji, no exclamation marks. "
    "Lead with the change and its effective date. State old and new values. "
    "Default to under 120 words. Use British spelling."
)

response = client.responses.create(
    model="gpt-5",
    instructions=HOUSE_STYLE,
    input="Write a short update about our API rate limit change.",
)

print(response.output_text)

Notice HOUSE_STYLE is literally your custom instructions text, lifted into a constant you reuse across every call. A good instruction set is a reusable asset, not a one-off. Swap in a smaller model such as gpt-5-mini for high-volume, low-stakes jobs; the instructions stay the same.

If you need the output in a fixed shape (not just a tone), stop describing the format in prose and use structured outputs. They constrain the model to a JSON schema you define. Instructions handle *style*; structured outputs handle *shape*. Use both together: instructions for "be terse and British," a schema for "return exactly these fields."

A practical audit of your current instructions

Open Settings → Personalization now and check what is there:

  1. Do they resolve real choices? Delete any line the model already does by default ("be accurate").
  2. Is there a number anywhere? Length, count of bullets, max examples. If not, the model is guessing.
  3. Do they name your output destination? Slack, email, code, a CMS. Format follows destination.
  4. Have you said what to suppress? Hedging, apologies, emoji, preamble.
  5. Does the personality preset agree with your text? A chatty preset fights a "be terse" rule.
  6. Are they global-true? Anything that only applies to one project belongs in a Project.

Run a test: paste an identical prompt with instructions on, then turn them off and run it again. The difference is exactly what your instructions are buying you. If there is no difference, your instructions are not earning their place.

Key Takeaways

  • Write instructions that resolve choices, not vibes. Replace "be concise" with a word count, and replace "be professional" with named formatting tied to where the output goes.
  • Use negative rules. Telling ChatGPT what to suppress (emoji, hedging, preamble) is often worth more than telling it what to add.
  • The personality preset is a coarse dial. Your written custom instructions and "about you" details do the precise work, so keep them consistent with each other.
  • Split global from project. Keep universal truths in custom instructions and put per-engagement rules in a Project so they do not contradict each other.
  • Treat your instruction set as a reusable asset. The same text becomes the instructions parameter in the Responses API and the system prompt of a Custom GPT.
  • Reach for structured outputs when you need shape, not just style, and combine them with instructions for production-grade consistency.

Frequently asked questions

Where do I set custom instructions in ChatGPT?

In ChatGPT, go to Settings → Personalization. You will find a personality preset (Default, Robot, Nerd, Cynic, Listener), a free-text field for how ChatGPT should respond, and an "About you" section with a nickname, your occupation and a "more about you" field. The text fields do the real work; the preset is only a coarse tone dial.

What is the difference between custom instructions and ChatGPT memory?

Custom instructions are explicit and stable: you write them, and they are injected into every new conversation. Memory is inferred: ChatGPT picks up facts about you across chats on its own and keeps evolving them. You control the first entirely, and you can review or switch off memory on the same Personalization settings page.

Why does "be concise" in my custom instructions not change anything?

Because it gives the model no number to act on. An instruction only matters when it resolves a choice ChatGPT would otherwise make for you: "default to under 150 words", "at most three bullets of explanation", "skip preamble like 'Great question'". Vague adjectives like concise, helpful or professional describe behaviour the model already attempts by default.

When should I use a Project instead of global custom instructions in ChatGPT?

Use a Project as soon as a rule is true for one body of work rather than for everything you do. Global custom instructions hold the universal items (your role, your language, no emoji, British spelling); a Project carries its own instructions, files and chat history and layers on top of them. Cramming client-email style and SQL debugging style into the same global field produces contradictions.

When is a Custom GPT worth building rather than just writing instructions?

Build a Custom GPT when you keep rebuilding the same context, files and tone for something other people will use. It packages instructions and knowledge files into a named, shareable assistant, can switch on capabilities like web search, code execution or image generation, and can call external APIs through Actions. Custom instructions stay personal and non-shareable; a Project covers one workspace.

How do custom instructions translate to the OpenAI API?

They become the `instructions` parameter of the Responses API, or a system message in Chat Completions. The same text you wrote in Settings → Personalization can be lifted into a reusable constant and passed on every call, including when you swap to a smaller model for high-volume jobs. If you need a fixed output shape rather than a tone, use structured outputs with a JSON schema alongside the instructions.

What to do, from this lesson

These actions are compiled in the role's Playbook.

  • Reserve global memory for durable personal defaults, not project specifics
See the full action playbook →

Related articles

Recent articles from the blog that build on this lesson.