On this page
A system prompt holds the instructions that should apply to every turn of a conversation: role, tone, format, boundaries. A user prompt is the specific request you make right now. Put what stays the same in the system prompt, and what changes in the user prompt.
That's the whole rule. The rest of this post is about applying it, because most people either stuff everything into one message or write a system prompt that's really a task.
The difference in one example
Imagine you use an AI model to answer customer emails. Some things never change: you write in British English, you sign off with the same line, you never promise refunds. Other things change every time: the actual email you're replying to.
The first group is the system prompt. The second is the user prompt.
System prompt
You are a customer support writer for [company name], a [one-line description of company]. Write replies that are warm, brief and specific. Use British English. Keep replies under 120 words unless the customer asks for detail. Rules: - Never promise a refund, discount or delivery date. Say you'll pass the request to the team that can approve it. - If the customer is angry, acknowledge the problem in the first sentence before explaining anything. - If you don't have enough information to answer, ask one clear question instead of guessing. - Sign off with: "Best wishes, [agent name], [company name] Support"
User prompt
Reply to this customer email. The order was placed on [order date] and the tracking page says [tracking status]. Email: [paste customer email]
Notice the user prompt is short. It carries only the facts for this one job. You can send it fifty times with different emails and the replies stay consistent, because the system prompt does the repeating for you.
What each one is actually for
The system prompt: standing instructions
The system prompt is set by whoever configures the model: you, a developer, or the product you're using. It tells the model who it is working as and how to behave before the user says anything. In a chat product, the equivalent is usually a feature like custom instructions, a project's instructions, or a saved persona. In an API call, it's a separate field.
Good system prompt content:
A role and the audience it writes for
Tone and length defaults
Output format (headings, JSON, bullet points)
Hard rules and things to refuse or escalate
Reference material that applies every time, such as a style guide or product facts
For a fuller guide to writing one, see System Prompt: What It Is and How to Write a Good One.
The user prompt: the task now
The user prompt is the message a person sends during the conversation. It contains the request, the input to work on, and any details that only matter for this job: the email to answer, the code to review, the transcript to summarise.
If you'd have to edit it before reusing it on a different task, it belongs in the user prompt.
The assistant message: the model's own turns
You'll also see "system vs user vs assistant" in the same breath. The assistant role is the model's replies. You rarely write these by hand in a chat window, but in API work you can pre-fill assistant messages to show the model what a good answer looks like. That's the mechanism behind few-shot prompting: a few example user and assistant pairs, then the real request.
So the three roles are roughly: system says how to behave, user says what to do, assistant is what the model has said so far.
Does the model treat them differently?
Yes, but less dramatically than people assume. Models are trained to give system instructions more weight, and to keep following them across a long conversation. That's the reason to put durable rules there instead of repeating them each time.
But the system prompt is not a lock. A user message can still pull a model off course, and a vague system prompt gets ignored in practice just like a vague user prompt does. How strictly any model follows system instructions varies between ChatGPT, Claude and Gemini, and between versions, so test with the model you actually use rather than trusting a rule of thumb.
Two habits help regardless of model:
State rules as plain instructions with a reason where it matters ("Don't promise refunds, because only the billing team can approve them").
Test with an adversarial user prompt. Ask something that tempts the model to break a rule and see whether it holds.
A worked example: moving a messy prompt into two parts
Here's a single-message prompt that many people write:
You are a senior product manager. Write in a direct, no-fluff style with short sentences. Summarise this meeting transcript into decisions, action items with owners, and open questions. Don't invent owners. Here's the transcript: [transcript]It works once. The trouble starts when you want the same behaviour for the next meeting and have to dig up the wording, or when a teammate needs the same format and writes their own version.
Split it.
System prompt:
You are a senior product manager who writes meeting notes. Style: direct, short sentences, no filler. Always output exactly three sections in this order: 1. Decisions 2. Action items (format: owner - task - due date if stated) 3. Open questions Rules: - Only assign an owner if the transcript names one. Otherwise write "Owner: unassigned". - Don't add decisions that weren't made. If something was discussed but not decided, put it under Open questions. - If the transcript is too short or unclear to summarise, say so in one sentence.
User prompt:
Summarise this meeting. Meeting title: [title]. Attendees: [names]. Transcript: [transcript]
What changed in the output: the three sections stop drifting, and the "don't invent owners" rule survives. With the one-message version, models often get lazy on that rule when the transcript is long, because it sits in the middle of the request. As a standing rule, it's one of the first things the model reads each time.
Common mistakes
Putting the task in the system prompt
If your system prompt says "Summarise the following article", you've turned the setup into a one-job tool. That's fine if the tool really does one job. Otherwise keep the system prompt about behaviour and let the user prompt carry the task.
Writing a system prompt that's a wall of rules
Long rule lists get patchy compliance and are hard to maintain. Describe the goal and the audience first, then add only the rules you've seen the model break. Our post on writing goals, not rulebooks goes into why.
Repeating system content in every user message
If you paste "respond in British English, keep it under 120 words" into each message, that's a sign it should live in the system prompt. The reverse is also true: if the system prompt includes details that only apply to one task, they'll leak into unrelated answers.
Assuming every tool exposes a system prompt
In the API you set it directly. In consumer chat apps you usually get an approximation: custom instructions, project instructions or a style setting. Some tools, such as coding assistants, ship with their own built-in system prompt that you can't see or replace, and your project files or instruction files act as extra context on top. If you work with coding agents, AGENTS.md, Skills or MCP? covers where that context goes.
How to split your own prompt in four steps
Write the prompt you'd normally write, in one message.
Highlight every sentence you'd copy unchanged into the next similar task. Those are system prompt candidates.
Move them into a separate block. Leave the input, the specifics and the request itself in the user prompt.
Run the pair on three different inputs. If an answer ignores a rule, make that rule clearer or move it higher in the system prompt. If a rule never matters, delete it.
A useful test for the user prompt: could a colleague read only that message, plus the system prompt, and know exactly what to produce? If not, add the missing detail.
Keeping both parts organised
Once you have a system prompt that works, it becomes an asset, and it's easy to lose. People end up with five slightly different versions in different chats. Treat the system prompt and the user prompt template as two saved items, and change them one at a time so you can tell which edit improved the output.
In PromptPal you can save the system prompt and the user template in your prompt library, and use prompt version control to keep earlier versions when you tweak a rule. That matters most on a team, where one person's quiet edit to a system prompt can change every answer downstream.
Next step
Take one prompt you reuse weekly, split it using the four steps above, and save both halves. If you want ready-made starting points by role and task, browse the public prompt library.
Stay Updated
Get the latest blog posts and AI prompt engineering tips delivered to your inbox.




