ChatGPT Custom Instructions That Actually Work

The ChatGPT custom instructions that work are short, specific and checkable: five to ten rules about how you want answers, each one something you could hold a reply against and say whether it was followed. “Be concise” fails that test; “answer in under 150 words unless I ask for more” passes it. Put them in Settings, Personalization, where they apply across your chats. Keep facts that change, one-off task details and anything a whole team must follow somewhere else: the prompt, a project’s instructions, or a shared document. Memory is not a substitute, because it is recall you cannot fully see, and instructions are rules you wrote.

The general craft of writing rules for any assistant is in AI agent instructions, and the Claude side in Claude prompting best practices. This post is about ChatGPT’s own settings, as OpenAI documents them at the end of September 2026.

Where custom instructions live today

OpenAI’s personalisation guide↗ (opens in a new tab) says custom instructions are for preferences you want ChatGPT to follow across chats, set under Settings, Personalization on the web and desktop, and that the controls available vary between the two. Several layers now sit near each other, and it helps to know which is which:

• Personality: Friendly, Pragmatic or None, chosen in the same settings. OpenAI says a personality changes how ChatGPT communicates, not what the model can do.
• Custom instructions: your standing rules for every chat. At the time of writing, OpenAI’s help centre gives the limit as 1,500 characters on Free and Go and 5,000 on paid plans.
• Project instructions: rules for the chats in one project. OpenAI’s help centre says they apply only inside that project and override your custom instructions there.
• The desktop app and Codex: custom instructions are stored as your personal AGENTS.md, and repositories can add their own.
• Memory: context ChatGPT carries forward from earlier chats. It is not an instruction, and it is covered below.

The desktop app’s settings reference↗ (opens in a new tab) is explicit that editing custom instructions there updates your personal instructions in AGENTS.md. For Codex that file is ~/.codex/AGENTS.md, read before every task, with each repository’s AGENTS.md layered on top. If you write code with ChatGPT, that is where your coding rules end up, so write them as rules a tool can follow.

Rules that work: short and checkable

• One rule per line. A paragraph of preferences blurs; a list can be checked item by item.
• State the behaviour, not the wish. “Use British spelling” is a rule; “write naturally” is not.
• Give defaults with their exception. “Answer in prose; use a table only when comparing three or more things.”
• Say what to do when unsure. “If a fact might be out of date, say so and give the date of your source.”
• Cut anything that is true of every good answer. “Be accurate” adds nothing.
• Remove contradictions when you add a rule. A new line that disagrees with an old one leaves ChatGPT to choose.
• Test by asking. Start a new chat and ask ChatGPT to list the rules it is following, then give it a task that should trigger each one.

OpenAI’s prompting guide↗ (opens in a new tab) draws the same line from the other side: put preferences that should apply across chats in custom instructions, and keep details that matter only to the current chat in the prompt. Its advice on boundaries also transfers well. Name the one or two things that must not happen, such as changing approved figures or sending a message without review, rather than trying to control every step.

Before and after

Most weak instructions are wishes. Rewriting each one as something you could check an answer against is most of the work:

• “Be concise” becomes “under 150 words unless I ask for more”.
• “Be professional” becomes “no exclamation marks, no emoji, no jokes in work drafts”.
• “Don’t make things up” becomes “if you are not sure of a figure, say so and leave a placeholder”.
• “Know that I am a developer” becomes “assume I know Git and the command line; explain anything specific to a framework”.
• “Help me write better” becomes “when editing, keep my structure and list your changes after the text”.
• “Use good formatting” becomes “headings only in answers over 300 words; otherwise plain paragraphs”.

Review the list every month or so. If you have corrected ChatGPT the same way twice, that correction belongs in the instructions. If a rule has not mattered in weeks, delete it: every line competes for attention with the ones that do.

Example: general work

I work in operations at a UK logistics company. Readers are managers who skim.

- Lead with the answer or recommendation, then the reasons.
- Under 200 words unless I ask for more.
- British spelling, dates as 28 September 2026, currency in GBP.
- Use bullet points for steps and options; prose for explanations.
- If you are unsure of a fact, say so. Never invent a figure or a source.
- For emails and messages, draft only. I send them myself.
- End with one question if something I asked is ambiguous.

Example: coding

The best ChatGPT instructions for coding say what stack you use, what “done” means and what not to touch. Keep repository-specific commands in the repository’s own AGENTS.md, where Codex reads them for that project, and keep personal habits in custom instructions.

I write TypeScript (Next.js, Node 22) and use pnpm.

- Show the smallest change that solves the problem, as a diff or a full function.
- Do not add dependencies without saying why and asking first.
- Match the existing style of the code I paste; do not reformat untouched lines.
- Include the command to run the relevant tests after a change.
- If the fix needs a decision from me (API shape, data migration), stop and ask.
- Never put secrets, tokens or connection strings in examples; use placeholders.
- When you are guessing about a library version, say which version you assumed.

Example: writing

I write articles and newsletters for small-business owners.

- Plain English. Short sentences. Second person.
- No hype words: revolutionary, game-changing, cutting-edge.
- No emoji, no exclamation marks.
- When editing my draft, keep my structure and voice; list your changes after the text.
- Suggest a headline under 60 characters when I ask for one.
- Flag any claim that needs a source instead of adding one yourself.

How instructions interact with memory

Memory and instructions do different jobs, and OpenAI says so. Its page on memories↗ (opens in a new tab) describes them as a way to carry useful context from earlier work into future work, and tells you to treat them as a helpful recall layer, not the only source for rules that must always apply. Instructions you wrote are the source for those rules.

• Put rules in instructions, context in memory. “Use metric units” is a rule. “I am renovating a kitchen” is context.
• Review saved memories when behaviour drifts. A memory saved from one odd conversation can pull answers away from what your instructions say; delete it rather than adding a rule to fight it.
• Projects change what applies. A project on project-only memory does not use your saved memories, so anything it needs belongs in its project instructions. How the settings differ is in ChatGPT project memory.
• Local memory is separate. OpenAI notes that ChatGPT on the web uses ChatGPT memory, while local Codex clients use a separate local memory store with their own controls.

What custom instructions cannot do

• Grant access. An instruction cannot connect ChatGPT to a service or give it permission to act there. That is what plugins and their apps do, within what your account and admin allow.
• Guarantee compliance. They steer answers; they do not enforce them. Anything that must never happen needs a control outside the model, such as an approval step or read-only access.
• Keep facts current. A price, a policy or a deadline written into instructions goes stale silently. Link to the source document instead.
• Reach other assistants. Your ChatGPT instructions do nothing for Claude, Cursor or a colleague’s account.
• Replace a team’s rules. They are personal. Rules a team shares need to live somewhere every person and every assistant reads.

When the rules belong to a team

The last two limits are where personal instructions stop and shared ones begin. On fenbs, a small task board that assistants reach over MCP, standing rules live as AI context: short notes that ChatGPT, Claude and any other connected assistant read when they call fenbs_get_context at the start of their work. You write a rule once, it is signed with who wrote it, and it applies to every assistant on the board, whatever each person has in their own settings. Decisions the owner made, and why, sit on the board’s Decisions page beside the tasks they affect.