---
title: "System Prompt vs User Prompt: What Goes Where and Why"
description: "A system prompt sets standing rules for a whole conversation; a user prompt is the task of the moment. Here's how to split them, with copy-ready examples."
url: https://www.promptpal.app/blog/system-prompt-vs-user-prompt
author: "PromptPal Team"
published: 2026-11-07T08:04:46.052Z
updated: 2026-11-08T00:14:04.833Z
category: "General"
tags: ["prompt engineering", "system prompt", "user prompt", "claude", "chatgpt"]
language: en
reading_time_minutes: 7
image: https://images.ctfassets.net/xzkuxcljsk12/6ZUgkXSVt0dUQfctZYt3qJ/a8cdedf4652dab6f439a59da083b6db6/System_Prompts_vs_User_Prompts__What_Goes_Where.png
publisher: PromptPal
---

# System Prompt vs User Prompt: What Goes Where and Why

A system prompt sets standing rules for a whole conversation; a user prompt is the task of the moment. Here's how to split them, with copy-ready examples.

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](https://promptpal.app/blog/what-is-a-system-prompt-how-to-write).

### 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](https://promptpal.app/blog/few-shot-prompting-examples-how-to): 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:

1. State rules as plain instructions with a reason where it matters ("Don't promise refunds, because only the billing team can approve them").
2. 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](https://promptpal.app/blog/prompting-2026-write-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?](https://promptpal.app/blog/agents-md-skills-or-mcp) covers where that context goes.

## How to split your own prompt in four steps

1. Write the prompt you'd normally write, in one message.
2. Highlight every sentence you'd copy unchanged into the next similar task. Those are system prompt candidates.
3. Move them into a separate block. Leave the input, the specifics and the request itself in the user prompt.
4. 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](https://promptpal.app/features/prompt-library), and use [prompt version control](https://promptpal.app/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](https://promptpal.app/prompts/public).

---

Originally published at https://www.promptpal.app/blog/system-prompt-vs-user-prompt
