System Prompt vs User Prompt: Why the Difference Matters

You typed a careful instruction into ChatGPT, and three turns later it forgot you ever said it. Or you set custom instructions once, and the model still writes like it has never met you. The reason is almost always the same: you put a standing rule in the wrong slot. There are two kinds of input going into every AI request, the system prompt and the user prompt, and they behave nothing alike. Get the split wrong and the model treats your standing rules as throwaway chat.

This article explains what a system prompt is, how it differs from a user prompt, when to use each, and why even a perfect system prompt goes stale the moment your facts change.

Key takeaways

• A system prompt is standing context and rules that apply to the whole conversation. A user prompt is the specific task you are asking for right now.
• The system prompt sets the model's role, tone, constraints, and background facts. The user prompt gives it the request to act on.
• Instructions that need to hold across every turn belong in the system prompt, not buried in a chat message that scrolls out of the model's attention.
• Custom instructions and project instructions in ChatGPT and Claude are just system-prompt slots with a character limit.
• A system prompt is only as good as the facts inside it, and hand-written facts go stale the day your pricing, role, or opinion changes.
• The durable fix is a live source of context the model reads at request time, not a static block you edit by hand.

What is a system prompt

A system prompt is the instruction the model reads before it reads your actual request. It sets the frame for the entire conversation: who the assistant is supposed to be, what tone to use, what rules it must follow, and what background facts it should treat as true.

Think of it as the briefing you would give a new contractor before handing them the first task. You do not repeat "we are a B2B company, keep it formal, never invent numbers" on every single email. You say it once, up front, and expect it to hold. The system prompt is that up-front briefing.

In the raw API, the standing instructions travel separately from the conversation. Anthropic's Messages API takes them in a top-level system parameter. OpenAI's Responses API takes them in an instructions parameter or a message with the developer role, which replaced the old system role starting with OpenAI's o1 models. Whatever the field is called, the content looks like this:

System: You are a technical writer for a developer tools company. Write in plain, direct English. Never use marketing filler. When you are unsure of a fact, say so instead of guessing.

That block is not a question. It is a set of rules the model applies to everything that follows in the conversation.

What is a user prompt

A user prompt is the specific thing you want done, right now. It carries the role "user" and it is the message the model treats as the current request.

Using the same setup, the user prompt is:

User: Draft a 200-word changelog entry for our new webhook retry feature.

The model reads the system prompt to learn how to behave, then reads the user prompt to learn what to do. The system prompt is the standing brief. The user prompt is the ticket.

The important part: in most chat products, every message you type is a user prompt. When you tell ChatGPT mid-conversation "always answer in bullet points," you are putting a standing rule into a user message. It works for a few turns because the model can still see it. As the conversation grows, that message competes with everything typed after it, and once the chat outgrows the context window, the app trims or summarizes older turns and the rule quietly dies. Anthropic's Claude Code memory docs say it plainly: an instruction given only in conversation can disappear after /compact, while a project CLAUDE.md is re-read from disk. That is the single most common reason AI "forgets" your instructions.

System prompt vs user prompt at a glance

The rule of thumb is simple. If the instruction should apply to the next hundred requests, it belongs in the system prompt. If it applies to this one request only, it belongs in the user prompt.

Where the system prompt actually lives in ChatGPT and Claude

Most people never touch the raw API, so the word "system prompt" feels abstract. It is not. Every consumer AI product gives you a system-prompt slot, just under a friendlier name.

• ChatGPT: the "Custom instructions" panel and per-project instructions. Whatever you type there is prepended to your conversations as system-level context. Note that custom instructions have a character limit, so you cannot dump everything about your work into them.
• Claude: project instructions and the personal preferences in your profile settings play the same role. In Claude Code, a CLAUDE.md file holds your standing rules, but Anthropic's docs note it arrives as a user message right after the system prompt, not inside it. For true system-level instructions, Claude Code has a --append-system-prompt flag you pass at launch.
• API: a top-level system parameter in Anthropic's Messages API; an instructions parameter or a developer message in OpenAI's Responses API, where developer messages are prioritized ahead of user messages.

Both chat apps also have a memory feature that carries facts between chats, which helps, though you do not control exactly what it keeps.

Here is the same split in a raw request to Anthropic's API. The standing rules go in system, and the task goes in a user message:

{
  "model": "claude-sonnet-5-5",
  "max_tokens": 1024,
  "system": "You are a technical writer for a developer tools company. Write in plain, direct English. Never use marketing filler.",
  "messages": [
    {"role": "user", "content": "Draft a 200-word changelog entry for our new webhook retry feature."}
  ]
}

And the OpenAI Responses API version, with the rules in instructions:

{
  "model": "your-model-id",
  "instructions": "You are a technical writer for a developer tools company. Write in plain, direct English. Never use marketing filler.",
  "input": "Draft a 200-word changelog entry for our new webhook retry feature."
}

One catch with OpenAI's instructions: it applies only to the request it is sent with, so if you chain responses together you send it again each time.

When you write a good custom-instruction block, you are writing a small system prompt. Here is a real one you can copy and adapt:

You are helping Junaid Khalid, founder of a developer tools startup. Default to plain, direct English, no marketing filler, no hedging. When you write copy, match a builder-to-builder voice. Never invent statistics or cite numbers you cannot verify. If a request is ambiguous, ask one clarifying question before answering. Prefer short answers unless I ask for depth.

Paste that into the custom-instructions box and it governs every new chat. That is the correct place for standing rules. The chat box is not.

Why "put it in the system prompt" is only half the fix

Here is the trap. You move your standing rules into the system prompt, and for a week the output is noticeably better. Then reality moves and your system prompt does not.

You raised your price. Your job title changed. You shipped a feature that made half of last month's talking points wrong. You changed your mind about a positioning decision. None of that reaches the model, because the system prompt is a static block of text you wrote once. Garbage in, generic out: a model working from last quarter's facts produces confidently wrong output, and it sounds just as fluent doing it.

The failure mode is quieter than a forgotten instruction, which is what makes it worse. A dropped rule is obvious. A stale fact is not. The model cheerfully repeats your old pricing, your old role, your old opinion, and you do not catch it until a customer does.

Character limits make this worse. ChatGPT custom instructions cap out, so you are forced to choose which facts about your work are worth the space. You end up with a thin, generic brief because the rich, specific context does not fit, and the specific context is exactly what makes output sound like you.

So the real question is not "system prompt or user prompt." It is: how does current, specific context about you and your work get in front of the model at request time, without you hand-editing a text block every time something changes?

The durable fix: standing context that maintains itself

The clean answer is to stop treating your context as a block of text you paste, and start treating it as a live source the model reads when it needs it.

That is what Locul does. It is a local-first desktop app that builds a searchable second brain from what you already produce, then serves that context to your AI tools over MCP. Instead of you retyping "here is who I am and what is true this week" into a custom-instructions box, your AI queries your actual brain at request time and pulls the current facts.

Two things make this different from a hand-written system prompt.

First, it stays current on its own. When a fact changes, the old version is marked superseded and the new one takes its place, with history preserved. Your standing context updates when your reality updates, so the model is never quoting last quarter's price or your old job title. That is the part a static system prompt structurally cannot do.

Second, there is no character limit and no capture chore. Locul reads from what you already have: local markdown files with #tags and [[wikilinks]], PDFs converted to notes, dictation through Contextli and other voice tools, your Notion cache, and your LinkedIn profile. A background agent distills that into memories tagged as facts, preferences, decisions, and more, each with a confidence score. You did not tag anything or run a weekly review. The context is just there when your AI asks for it.

You still write good user prompts for each task. That never goes away. What changes is that the standing context feeding those prompts is deep, specific, and current, instead of a thin static block you keep forgetting to update. If you want the mechanics of how that memory layer holds up over time, how to give your AI a memory that actually lasts covers it, and what a Memory Pack is shows how you can bundle a domain's facts and inject them into your brain.

A quick decision guide

Use this to decide where any instruction goes.

The line is persistence. Standing things go up top and should stay current on their own. One-off things go in the chat box.

Frequently asked questions

What is the difference between a system prompt and a user prompt?

A system prompt is the standing instruction that frames the whole conversation: role, tone, rules, and background facts. A user prompt is the specific request you are making right now. The model reads the system prompt to learn how to behave, then reads the user prompt to learn what to do. Standing rules that must hold across every turn belong in the system prompt, not in a chat message.

Where do I set a system prompt in ChatGPT?

In ChatGPT, the system-prompt slot is the "Custom instructions" panel, plus per-project instructions for project-scoped context. Whatever you write there is applied as system-level context to your conversations. Keep in mind custom instructions have a character limit, so you cannot fit your entire working context into them.

Why does the AI ignore my instructions after a few messages?

Because you most likely put a standing rule into a user message instead of the system prompt. A typed chat message is a user prompt, and once the conversation gets long, older messages carry less weight and are eventually trimmed or summarized to fit the context window, and the rule stops applying. Move rules you need to persist into custom instructions or a system prompt. For context that needs to survive long term, see how to give your AI a memory that actually lasts.

Can a good system prompt fix generic AI output on its own?

Partly. A good system prompt fixes tone and rules, but output stays generic if the facts inside it are thin or out of date. Character limits force a shallow brief, and static text goes stale the moment your pricing, role, or opinion changes. The fuller fix is current, specific context the model reads at request time rather than a block you hand-edit.

Is a custom instruction the same thing as a system prompt?

Effectively, yes. Custom instructions in ChatGPT and project instructions in Claude are consumer-facing system-prompt slots. Under the hood they are prepended to your request as system-level context. The main practical difference from a raw API system prompt is the character limit these panels impose.

How do I keep my system prompt from going out of date?

Stop maintaining it by hand. Point your AI at a live source of context that updates when your facts change, so old facts are superseded automatically instead of sitting in a stale text block. Locul builds that source from what you already produce and serves it to your AI over MCP, and a Memory Pack lets you bundle and inject a whole domain's facts at once.

If your AI keeps forgetting who you are or working from facts that expired weeks ago, the problem is not the model and it is not your prompting. It is that your standing context is a static block you have to babysit. Locul builds a second brain from what you already do and keeps it current, so your AI always works from your real, up-to-date context. Try Locul.