Custom Instructions vs. System Prompts: What Changes

Custom instructions and system prompts both reach the AI before your first message, but they work at different levels. A system prompt is set once per session, usually by a developer or an app, and it governs how the assistant behaves for that conversation. Custom instructions are a user-level feature in specific apps like ChatGPT: you write them once and the app injects them automatically for every new chat. Tools like fenbs let you keep approved rules and reusable prompts in a shared library that any connected AI reads, so the same instructions are available even when you change apps.

The confusion between the two is understandable. Both appear in the system position of a conversation, and both influence tone, format and behavior. The difference is scope, authority and who controls them.

What a system prompt is

When an AI app sends a request to a language model, it can include a system message before anything the user typed. That system message tells the model its role, the rules it should follow, what format to use, and anything else the app's designer decided to include. It is invisible to the user in most interfaces.

A system prompt applies to one session. When the chat ends, it is gone. The next session starts fresh, and the same or a different system prompt is injected again. This makes system prompts useful for session-specific instructions: a particular task, a specific format, or a constrained role for a single conversation.

In some apps you can write your own. Claude lets you add a project system prompt in the Projects feature. Cursor lets you write .cursorrules or use its settings panel. Developers building with the API control the system message directly. In all these cases, the prompt lives close to the session it governs.

What custom instructions are

Custom instructions are a stored user preference. In ChatGPT, you write them in Settings under Personalization. From that point on, every new conversation starts with those instructions already included. You do not have to paste them again. For guidance on getting the most from ChatGPT's version, see ChatGPT custom instructions.

Custom instructions are designed for preferences that hold across many conversations: your preferred response style, your role, the context you always want the model to have. They are not suited for session-specific rules that apply only to one task.

Not all AI apps use this term or feature. Claude calls the equivalent "memory" or project instructions depending on how you store them. Gemini has its own approach. The mechanism varies, but the idea is the same: instructions that persist beyond a single chat.

How they compare

One question that often comes up is authority: which wins when both are present? The answer depends on the app and the model. In most setups, a system prompt carries more authority than a user-level instruction, because it is set at the operator level. If a system prompt says to respond only in English, custom instructions written in French do not override that. For Claude's specific approach, see Claude custom instructions.

Where one-off prompts fit in

System prompts and custom instructions both aim to be reusable across sessions or conversations. One-off prompts are the opposite: a specific request you type for one task, with the context it needs included right there.

A good one-off prompt includes the goal, the necessary background, any constraints, and the format you want. You do not need to save it unless you find yourself writing the same one repeatedly. When you do, that is a signal to turn it into a custom instruction or a stored skill.

The prompt engineering guide covers how to structure any kind of prompt well. The distinction here is simply that one-off prompts are not meant to persist.

Which to use when

Use a system prompt when you are configuring a session for a specific task, building a tool that uses the API, or setting a role that applies only to that conversation. Use custom instructions for stable preferences: how you want responses formatted, your background, your standing rules.

• System prompt: you are building a code review tool and want the assistant to respond only with inline comments.
• System prompt: you are running a customer-facing assistant and want it to stay on one topic.
• Custom instructions: you always want responses in plain paragraphs without bullet lists.
• Custom instructions: you want the assistant to know you are a lawyer and to flag legal assumptions.
• One-off prompt: you need a single email drafted in a specific format for one recipient.

The harder case is team-wide rules. Neither system prompts nor custom instructions travel across people. One person's ChatGPT custom instructions are not visible to a colleague using Claude Code. That gap matters when a rule applies to the whole project.

Keeping rules consistent across assistants

Teams often discover that custom instructions are a per-person, per-app solution. One developer uses Claude Code with one set of project rules. A designer uses ChatGPT with different instructions. Neither knows what the other's assistant has been told.

The problem compounds when a rule changes. Updating every person's custom instructions in every app is manual work that often does not happen. The result is that assistants on the same project follow different rules.

Decisions and rules in fenbs solve a related problem: a person records a rule once, it lives with the project, and every connected assistant reads it at the start of each session. This is not a replacement for custom instructions in individual apps. It is a layer for the rules that apply to the work itself, not just to a person's preferences.

For the Claude system prompt and Copilot instructions in specific apps, the respective guides cover the right format and placement.

How to do this with fenbs

1. Create a free account. A personal kanban board is enough to start.
2. Add your reusable prompts to Skills and prompts. Give each one a clear name and the full text. Include notes on when and how to use it.
3. Write standing rules as Decisions and rules on your project. Name the person who decided each rule and include the reason.
4. Connect your AI apps over MCP from Integrations. Once connected, ask the assistant to list your prompts before a session and read the relevant rules first.
5. When a rule changes, update it in fenbs. The next connected session reads the new version automatically.