Most people who use ChatGPT daily have never seen a system prompt — but it's shaping every answer they get. Understanding the distinction between a system prompt and a user prompt isn't just a technical detail. It's the key to understanding why AI behaves the way it does, and how to actually get it to do what you need.
What Is a System Prompt?
A system prompt is a set of instructions given to a model before the conversation starts. It's invisible to the end user in most products, but it defines the model's persona, boundaries, tone, task scope, and behavioral rules for the entire session.
Think of it as the job description handed to an employee before their first shift. The employee — the model — reads it privately, internalizes the rules, and then works within those constraints for the rest of the conversation.
In most chat completion APIs, the system prompt is passed as a message with a dedicated system role. In practice, it looks something like this:
role: system
content: "You are a concise legal research assistant. You summarize
case law clearly and flag when professional legal advice is required.
Never speculate about legal outcomes. Keep responses under 300 words
unless asked to expand."
That text never appears in the chat window, but everything the user types gets interpreted through it. System prompts typically control: persona and name, tone and formality, knowledge scope (what topics the model will and won't engage with), output format defaults, safety guardrails, and task framing (coding assistant, tutor, analyst, writer).
What Is a User Prompt?
A user prompt is what you actually type into the chat box — the message you send each turn. It's the runtime instruction: what you want, right now, in this specific conversation.
User prompts are temporary. Each message lives in the conversation thread, but once the context window fills up, older messages get dropped, and none of it carries forward into a new session. Good user prompts are specific, concrete, and scoped — they tell the model what to do with the context it already has. They can override some system prompt defaults, like tone, format, or length, if the system prompt allows it, but they can't override hard-coded restrictions.
The Core Difference, Side by Side
| Dimension | System Prompt | User Prompt |
|---|---|---|
| Who writes it | Developer / product builder | End user |
| When it's set | Before the conversation starts | Each turn, at runtime |
| Visibility | Hidden in most products | Visible in the chat thread |
| Scope | Entire session | Single turn |
| Defines | Persona, rules, defaults | Current task and specifics |
| Can the user change it? | No, in finished products | Yes, every message is a new one |
| Priority | Weighed first by the model | Interpreted through system context |
Custom Instructions and Custom GPTs
ChatGPT's Custom Instructions feature lets you fill in a system-prompt-like field that gets prepended to every conversation. You write it once in settings and it persists across chats until you change it. It's not exactly a system prompt — the product's own system prompt still sits above it — but functionally it behaves like a persistent personal layer. It's your chance to tell the model your profession, your preferred output format, what you already know, and how you want to be spoken to:
"I'm a product manager at a SaaS company. Don't explain basic
business concepts. Always answer in bullet points for complex
topics. When I ask for feedback, be direct — don't soften criticism."
A Custom GPT goes further: it's a packaged product combining a system prompt written in a builder interface, uploaded knowledge files retrieved as context, configured tools (web search, code execution, image generation), and a defined audience. When you use one, you're writing user prompts that get interpreted through someone else's system prompt and knowledge base.
Why This Actually Matters for How You Prompt
If you're a regular user rather than someone building products, understanding this distinction changes how you work with AI in three concrete ways.
First, it explains weird behavior. If a chatbot on a website keeps saying "I can only help with X," that's not the model being dumb — it's the system prompt restricting it, and no amount of clever phrasing in your user prompt will fully route around it.
Second, it tells you what you actually control. You can't escape a well-written system prompt by asking nicely, but you usually can override tone and format if the system prompt doesn't explicitly lock them.
Third, it changes how much work your own prompts need to do. When you use a general-purpose chat interface directly — not a Custom GPT — you're writing into a generic system prompt, which means your user prompt has to specify role, context, task, and format yourself instead of inheriting them.
Same Question, With and Without a System Prompt
Without a system prompt, a generic assistant answering "How do I get a refund?" gives a 200-word explanation of how refund policies typically work in general — because it has no company-specific context to draw from.
With a system prompt in place:
role: system
content: "You are the support agent for StyleBox, a subscription
clothing service. Refund policy: customers have 14 days to return
items in original packaging. Direct refund requests to
support@stylebox.example or the order page at stylebox.example/orders. Do
not speculate about orders you don't have data on. Be warm but concise."
The same user question — "How do I get a refund?" — now gets: "For a refund on your StyleBox order, visit stylebox.example/orders or email support@stylebox.example. Returns are accepted within 14 days in original packaging. Anything else I can help with?" The entire jump in usefulness comes from the system prompt, not the user prompt — the user asked the exact same thing both times.
If you're the one writing that system prompt, the role prompting breakdown is worth pairing with this — it covers how to write the persona line so it actually shifts the model's output instead of adding noise.
Key Takeaways
System prompts are persistent, session-wide, and usually invisible; user prompts are per-turn and visible. In consumer apps, the product's own system prompt shapes every response before yours even arrives. Custom Instructions function as a personal system prompt layer that persists across sessions, and a Custom GPT is a packaged system prompt plus tools plus knowledge. If you want a model to consistently behave a certain way, put the instruction in the system prompt — not in every single user message.
FAQ
Can a user prompt override a system prompt?
Only within the boundaries it allows. Tone, format, and length are commonly overridable. Hard-coded restrictions are not.
Are Custom Instructions the same as a system prompt?
Functionally similar but not identical — Custom Instructions sit in front of the product's own underlying system prompt as a personal layer.
Why does a website chatbot refuse to answer basic questions?
Almost always a narrow system prompt, not a model limitation. It's been scoped to a specific task by whoever built it.
Do I need to write system prompts as a regular user?
Not directly, unless you're building a product. But understanding how they work explains why default chat behavior varies across apps, and it makes your own user prompts more effective.
Originally published at my-blog.org.
Top comments (0)