ChatGPT Custom Instructions: What to Actually Put There

TL;DR: ChatGPT's custom instructions field holds 1,500 characters on Free and Go, 5,000 on Plus, Pro, Enterprise, Business, and Education, per OpenAI's own help center. Write it around three things OpenAI itself asks for: traits, tone, rules, not a wish list. Below are seven copy-paste blocks, one per job, that fit the budget and actually say something.

What Do ChatGPT's Custom Instructions Fields Actually Look Like?

Before writing anything, it's worth being precise about what you're filling in, because this has changed more than once and most ranking content still describes an old version. A few current guides also state the character limit as roughly 1,500 characters per field, which isn't a figure OpenAI publishes anywhere; the real numbers, below, are per account and per plan, not per box, and they don't stack if your screen happens to show more than one input.

The classic write-up of custom instructions describes two open questions: what you'd like ChatGPT to know about you, and how you'd like it to respond. That was the original 2023 design. On January 17, 2025, OpenAI shipped a redesign, describing it this way in its own release notes: you can now tell ChatGPT "the traits you want it to have, how you want it to talk to you, and any rules you want it to follow" (help.openai.com, ChatGPT release notes, read September 4, 2026). Three themes, not two questions.

Here's the part most guides miss entirely. OpenAI's current Custom Instructions FAQ, last updated roughly three weeks before this was written and read again on September 4, 2026, doesn't name separate boxes at all. It says simply: "Enter your instructions in the Custom Instructions field" (help.openai.com/en/articles/8096356-custom-instructions-for-chatgpt). Singular. So don't assume a fixed number of boxes when you write your block. Write continuous text organized around the three themes, and let whatever your screen shows you handle the layout; that's also why every block further down this page is written as one piece of text rather than split into labeled sections.

What is verified and unchanged is the budget. Free and Go accounts get 1,500 characters; Plus, Pro, Enterprise, Business, and Education accounts get 5,000, up from an earlier 1,500 across the board (help.openai.com, both the FAQ and the release note announcing the increase, read September 4, 2026). Custom instructions are available on all plans, on web, desktop, iOS, and Android.

There's a second reason the layout is easy to misremember. Until September 15, 2025, personalization opened in its own modal, separate from the rest of settings. OpenAI's release notes describe the change plainly: "Personalization no longer opens in a separate modal. You can manage personalization, choose a ChatGPT personality, add custom instructions, and update Memory directly in Settings → Personalization" (help.openai.com, read September 4, 2026). Four things that used to live in different places now share one screen, which is also why it's so easy to write a rule meant for one of them into another.

Custom instructions aren't the only personalization control anymore, either. OpenAI has split personality and phrasing-level tuning into their own settings, and confusing the three wastes budget you don't have:

That matters practically: if you're spending characters telling custom instructions to "be warm and use fewer emojis," you're duplicating what the Characteristics sliders already do for free, and paying for it out of a 1,500-character budget you can't get back.

The preset list itself isn't fixed either, which is its own small lesson. OpenAI retired the Nerdy base style on March 17, 2026, folding those users back into Default (help.openai.com, ChatGPT release notes, read September 4, 2026); it doesn't appear in the current Personality article at all. If your own notes reference a specific preset by name, check it still exists before you rely on it.

What Should You Actually Write There?

Take OpenAI's own three themes seriously, because they map onto three different failure modes if you skip one.

Traits are who you want ChatGPT to be when it's working with you, not what you want it to say. Persona prompting works here the same way it works inside a single prompt: naming a stance ("willing to disagree with me," "treats a vague brief as a problem to flag, not fill in") changes what gets volunteered, not just how it's phrased. Skip the adjectives you'd use in a dating profile ("curious," "passionate") and reach for ones that predict a specific behavior instead.

Tone is the surface-level stuff: formal or casual, answer-first or explanation-first, which stock phrases to cut. This is the theme most people over-invest in, and it's also the one the Characteristics sliders now partially cover for free. If all you want is warmer or more concise, use the sliders and spend your custom-instructions budget elsewhere; write tone into this field only for things the sliders don't reach, like which stock phrases to avoid or whether you want the recommendation before or after the reasoning.

Rules are the ones that actually save you retyping the same correction. A rule should be something you could point at in a bad output and say "that's the one you broke." "Be concise" is not checkable. "Answer in one paragraph unless I ask for more" is. If you find yourself writing the same correction into a chat for the third time this month, that correction belongs here, not in your head.

A minimal skeleton that fits any job, well under the 1,500-character floor:

Traits: [2-3 adjectives, plus one thing you want it to push back on]

Tone: [answer-first or story-first; formal or casual; one phrase to avoid]

Rules:
- [one rule about output shape]
- [one rule about what to do with an assumption]
- [one rule about what "done" looks like]

Write it, use it for a week, then cut anything you haven't actually needed. Most first drafts are a wish list; the useful version is the two or three rules you'd otherwise retype constantly. If a rule you wrote isn't showing up in outputs, tightening the wording with a follow-up prompt before your next edit is often faster than guessing at a rewrite.

Copy-Paste Custom Instructions by Job

Each block below fits inside 1,500 characters, so it works on every plan. Replace the bracketed context line with your own, and delete any rule that doesn't apply to you. These are starting points, not finished products; the whole reason to keep the budget tight is so you'll actually revise them.

A generic "be helpful and professional" block does almost nothing, because ChatGPT already defaults to that. The value in a job-specific block is naming the failure mode that's specific to your work: a developer wants assumptions surfaced, a founder wants a default instead of a hedge, a support rep wants a real next step instead of a warm non-answer. Match yourself to the closest one below and edit from there rather than starting blank.

Software Developer

I'm a software engineer. Context: [your stack, e.g. TypeScript, Next.js, Postgres].

Traits: Precise, terse, willing to say "I don't know" or "this needs a source" instead of guessing.

Tone: Answer first, explanation second. Skip preamble like "Great question!" and skip a closing summary unless I ask for one.

Rules:
- Show runnable code, not pseudocode, unless I ask for pseudocode.
- Name any assumption you made about my codebase before giving the answer.
- If a fix touches more than the file I mentioned, say so before writing it.
- Prefer what I'm already using over a new dependency; if you suggest one anyway, say why.
- Describe what you changed and why, so I can check it myself.

If you review AI-suggested changes for a living, a prompt built specifically for that will get further than a global rule can.

Marketer

I work in marketing. Context: [your focus, e.g. B2B SaaS content and paid social].

Traits: Direct, comfortable calling an idea weak, allergic to generic phrasing.

Tone: Write like a person talking to one reader, not a brand addressing a market. Cut "unlock," "elevate," "seamless," "game-changer."

Rules:
- Name the trade-off behind every headline or hook option (reach vs. specificity, safe vs. bold).
- Ask who the audience is and what they already believe before writing copy, if I haven't said.
- When I ask for options, make each one genuinely different, not three rewordings of one idea.
- Call out any cliché or stock phrase in a draft rather than quietly avoiding it.

For campaign-length work rather than single pieces, a dedicated prompt set will cover more ground than a standing preference can.

Founder / Executive

I run a small company. Context: [your stage, e.g. 2-person team, pre-revenue, B2B].

Traits: Blunt, comfortable telling me an idea is bad, thinks in trade-offs and runway rather than features.

Tone: Recommendation first, reasoning second. Short paragraphs. If you say "it depends," give me a default anyway.

Rules:
- When I ask for a decision, give me one, not an unranked list of options.
- Flag anything that assumes a resource I don't have (a legal team, a large budget, a full-time hire).
- For investor- or customer-facing writing, say if a claim needs a source before I send it.
- Tell me plainly if I'm overcomplicating something.

Founders default to hedging in writing they don't even believe. The "give me a default anyway" rule exists specifically to interrupt that reflex before it reaches a document.

Product Manager

I'm a product manager. Context: [your product, e.g. B2B dashboard, engineering team of 6].

Traits: Structured, asks the question nobody asked yet, treats "nice to have" and "must have" as genuinely different categories.

Tone: Lead with the user problem, not the feature. Plain language over product jargon.

Rules:
- Turn pasted notes into a structured spec (problem, users affected, proposed solution, open questions), not a summary.
- Flag anything I'm treating as settled that's actually still an assumption.
- Give every user story an explicit "done means" line.
- If a request has no clear success metric, ask for one before drafting anything.

The "done means" rule is the one line most PM-focused prompts skip, and it's the one that actually heads off a scope argument two weeks later.

Customer Support

I work in customer support. Context: [your product, e.g. B2B SaaS, mostly billing and bug reports].

Traits: Calm, precise, treats an angry message as a signal to investigate, not a tone to match.

Tone: Warm without false cheer. Skip "I completely understand your frustration" as an opener; say what's actually happening and what happens next.

Rules:
- Every reply states one clear next step, even if it's "escalating this, updating you by [time]."
- Never promise a timeline you weren't given.
- If the issue could be a bug rather than user error, say so rather than assuming user error.
- Keep replies phone-readable unless the situation genuinely needs more detail.

Support inboxes are where an over-cheerful default tone reads as most obviously fake, which is exactly why the "skip the stock opener" rule earns its place here more than almost anywhere else on this page.

Freelancer / Consultant

I'm a freelancer. Context: [your work, e.g. brand and web design for small businesses].

Traits: Confident about pricing, doesn't apologize for charging for expertise, names scope creep instead of quietly absorbing it.

Tone: Professional, plain. Cut "synergy," "leverage," "circle back."

Rules:
- In proposals, state price and what's included before the pitch.
- Flag anything in a client request that looks like scope creep before drafting a reply to it.
- Keep follow-up or reminder emails to one clear ask.
- If I didn't say a price is negotiable, don't soften it into sounding like it is.

Reusing the same proposal or outreach shape across clients gets old fast; a library built for that covers the per-client variables custom instructions can't.

Content Creator

I create content. Context: [your format, e.g. YouTube scripts and a newsletter for a productivity audience].

Traits: Has opinions, willing to call a script idea weak, thinks about the hook before the middle.

Tone: Write the way I'd actually talk, not the way a script "should" sound. Cut any line that could open any video on any channel.

Rules:
- Lead every script or post idea with the hook, written as the literal first line, not described.
- Flag anything that's already overdone in this space, and say what's overdone about it.
- For titles, give me options that make different promises, not variations on one phrase.
- State the true length instead of padding to hit a word count; let me decide whether to expand it.

Notice this block never names a niche or platform beyond the context line. A hook-first rule reads the same whether you're scripting Shorts or writing a newsletter subject line, which is exactly the kind of rule that belongs in a global field instead of a per-video prompt.

Is This the Same as Project Instructions or Memory?

No, and mixing them up is exactly how you end up with three sources quietly disagreeing.

Custom instructions are account-wide: every chat sees them. Project instructions are scoped tighter, and OpenAI does publish which one wins. Its Projects help article states it plainly: "Project instructions only apply inside the respective project and will override your global custom instructions" (help.openai.com/en/articles/10169521-projects-in-chatgpt, read September 4, 2026). So inside a project, the project's instructions take precedence over your global block; outside it, your global block is what applies. If you need genuinely different rules for different clients or codebases, that's what a Project is for, not a second custom-instructions block, because there isn't one.

The same page also describes what else lives inside a project alongside those instructions: a running list of its chats, and a separate area for whatever files or connected sources you've given it access to. That's the practical reason to move job-specific detail into a Project instead of stuffing it into custom instructions: the project keeps the files and the rules together, so a rule that references "the attached brief" or "this codebase" actually has something to point at.

Memory is different again: it's not something you wrote, it's a rolling summary of things you've said that OpenAI's own Memory documentation describes as incomplete by design, not a verbatim log. If an old preference is quietly steering answers and you can't figure out why, that's a memory question, not a custom-instructions one, and the full diagnosis for exactly that is worth reading before you touch this field again.

What Should You Leave Out of Custom Instructions?

The failure mode here isn't writing the wrong thing; it's writing too much of the right-adjacent thing until nothing gets read carefully.

Leave out anything specific to one task. A rule about a single client's brand voice or a single project's file structure will sit there for every unrelated chat afterward, quietly narrowing answers that have nothing to do with it. That belongs in a Project.

Leave out anything the Personality or Characteristics settings already handle. If you want warmer, more enthusiastic, more bulleted responses, that's four sliders away, not a paragraph of custom instructions competing for the same 1,500 characters.

Leave out anything you wouldn't want summarized back to you casually months from now. Custom instructions persist by design, and that's the whole point, but it also means anything sensitive you type in stays there until you delete it.

And leave out anything you can't turn into a checkable rule. "Be helpful" and "understand my situation" describe a mood, not a behavior; they'll get interpreted as generously as anything else you didn't specify, which is to say, not the way you meant.

The pattern to watch for is a block that grows every time something annoys you, until it reads like a list of grievances instead of a small set of standing rules. If yours is approaching the character limit and you can't remember why half of it is there, that's not a sign you need the 5,000-character tier; it's a sign the block needs cutting, not expanding.

The Short Version, If You Only Do One Thing

Open Settings, go to Personalization, find the Custom Instructions field, and write three or four sentences organized around traits, tone, and rules, not a list of preferences you'd like honored. Keep it under 1,500 characters even if your plan allows 5,000. Put anything job-specific in a Project instead. Reread it in a month and cut whatever you haven't actually needed.

None of this is a guarantee; nothing typed into a settings field is. It just means the rules you'd otherwise retype into every third chat are sitting somewhere ChatGPT reads by default, instead of living in your head where you're the only one enforcing them. And because OpenAI has changed this field's layout at least twice already, expect to revisit this page again; whatever's true about the exact boxes on your screen today is the part most likely to be out of date by the time someone links you back here.

One honest note on our own product. Prompt Architects doesn't touch your ChatGPT custom instructions field and can't set it for you; that field is OpenAI's, not ours. What it does is give you somewhere to draft, save, and reuse blocks like the ones above without losing the version you actually liked, and sync them across ChatGPT, Claude, and Gemini instead of retyping context into each one separately. The free plan includes 5 prompt enhancements per day, forever, per our FAQ page; saved prompts and a synced library are part of the paid plans.