By promptcraftasia.com Team

System Prompts: The Advanced Guide to AI Customisation

14 min read

Quick Answer

A system prompt is the standing instruction that shapes every reply an AI gives you, before you type anything. Advanced AI customisation means writing that instruction in layers: identity, task, style, boundaries and output format. Done well, it replaces the same corrections you retype in every conversation.

A system prompt is the instruction an AI reads before it ever sees your message, and advanced AI customisation is the practice of writing that instruction properly instead of leaving it blank. Every conversation inherits it. So the difference between an assistant that needs three rounds of correction and one that gets it right first time is usually not the model you picked. It's the two hundred words sitting above the conversation that nobody bothered to write.

This guide covers the layered structure, working templates, the failure modes that show up in real deployments, and how to test a prompt rather than hoping. If you want the deeper technical treatment of caching, injection defence and versioning, our 2026 system prompt guide goes into that separately.

What is a system prompt actually doing?

It sets the model's starting conditions. Its stance, not its knowledge: who it thinks it is, what the job is, how much to say, and what to refuse. The model treats it as a higher-priority instruction than anything the user types afterward, which is why it holds across a long conversation while a one-off request drifts.

Anna Neumann, Yulu Pi and Jatinder Singh built a taxonomy from 1,309 system prompts drawn from vendor releases and community repositories in Who Controls the Conversation?, accepted to CHI 2026. The same jobs recur across deployments: role, tone, refusal boundaries, formatting and injected context.

Why does customisation beat switching models?

Because most disappointing AI output is a configuration problem wearing a capability costume. People get a bad result on one model, switch, get a different bad result, and blame the technology. The prompt never changed. Models do differ, and the ChatGPT vs Claude comparison on WhichAIBest sets out where each pulls ahead, but fix the prompt first or you are comparing two badly briefed assistants.

Stanford HAI's 2026 AI Index found 88 percent of surveyed organisations using AI, yet AI agent deployment in the single digits across nearly all business functions: plenty of adoption, little configured well enough to run unattended.

Which five layers belong in an advanced system prompt?

Write them in this order. Each answers a question the model would otherwise answer for itself, badly.

1. Identity. Who is this assistant? Be specific enough to change vocabulary. "A senior B2B copywriter who has worked on SaaS launches in Singapore and Malaysia" primes different word choices than "a helpful writing assistant."

2. Task. What kinds of request will arrive, and what counts as success? The model falls back on this layer when a request is vague.

3. Style. Register, length, formatting, person. "Conversational but not chatty, second person, no bullet lists unless comparing options, under 200 words" gets followed. "Be friendly and professional" does not, because it describes nothing the model can act on.

4. Boundaries. What to refuse, escalate or never claim. "If asked about refunds beyond 30 days, say you'll pass it to a human and ask for the order number" is enforceable. "Be careful with refunds" is not.

5. Output contract. The exact shape of a reply: sections, ordering, what appears when the model doesn't know.

Put identity first and the output contract last, and don't bury a hard constraint in the middle of a long block.

What does an advanced system prompt look like in practice?

Here's the five-layer structure applied to a support assistant. Everything in brackets is yours to fill.

You are a customer support specialist for [company], a [what you sell] business serving customers in [markets]. Your job is to resolve billing and account questions in one reply where possible. Requests will arrive as short, often frustrated messages with missing details. Success means the customer knows exactly what happens next. Write in plain English, second person, under 150 words. No bullet points unless you are listing steps the customer must take. Never open with an apology paragraph. Boundaries: refunds inside [30] days you can confirm directly. Anything older, anything involving a chargeback, or any request to change account ownership goes to a human, and you say so plainly and ask for the order number. Never guess at a policy you have not been given. If you do not know, say you do not know and route it. Every reply ends with one line stating the next action and who owns it.

It doesn't say "be helpful and empathetic," because that's the model's default. Every line either narrows a choice or names a case the model would otherwise get wrong. Our prompt builder tool walks through the same components interactively.

Where should an advanced system prompt live in your business?

Somewhere versioned and reused: a Project or Custom GPT for most small teams, the API system parameter when it feeds a product and should go through code review. And a tool-and-permission layer is where the consequential parts belong once an assistant can act. If it can issue refunds, the cap belongs in the code the tool calls, not in a sentence. Instructions are guidance; permissions are enforcement.

There's also a ceiling on how many rules one prompt can carry. Netanel Eliav's Prompt Design at Scale (2026) ran 960 calls per model across five models, growing the rule count from 10 to 160 across four formats and both system-prompt and user-turn placement. The perfect-response rate collapsed to zero by 80 rules for every model, format and placement. So keep the system prompt to about a page, treat it as orientation, and put detail in reference files or in tools that enforce the rule.

Do you need one system prompt or one per task?

One good one, mostly. Lechen Zhang and colleagues built SPRIG, accepted at ICLR 2026, which assembles system prompts from components and keeps the best scorers, and evaluated it across 47 task types. "A single optimized system prompt performs on par with task prompts optimized for each individual task." Combining system and task optimisation did better still, and the optimised prompts generalised "across model families, parameter sizes, and languages."

Which customisation mistakes quietly ruin output?

Stacking negatives. Twelve "never" rules leave the model no picture of a good reply. Pair each prohibition with the replacement behaviour; our guide to negative prompting covers when "don't" helps and when it backfires.

Merging three assistants into one. Support, sales and technical documentation in one prompt makes the style and boundary layers contradict each other. Split it.

Writing rules with no failure case. "Be accurate" does nothing. "If the spec doesn't say, write UNKNOWN rather than guessing" tells the model what to output at the moment it would otherwise invent something.

Assuming the prompt is private. It isn't. See the FAQ below.

How should a system prompt handle Southeast Asian languages?

Explicitly, and with lower expectations than for English. Holy Lovenia and more than seventy collaborators built SEACrowd, a benchmark covering 38 indigenous SEA languages across 13 tasks, and measured whether generated text read as natural or as translationese:

LanguageOutput rated natural
Indonesian41.58%
Vietnamese37.31%
Thai34.21%
Khmer29.21%
Lao28.42%
Malay22.24%
Burmese19.47%
Filipino12.22%
English, as spoken in SEA8.95%

Regional English came out hardest of all, so "write in English" is not a neutral default for a regional audience. SEA-LION led the models at 58.57 percent natural output and GPT-4 managed 16.67 percent; those were 2024 models, so trust the gap more than the figures. The paper also found about 70 percent of SEA datasets lack cultural relevance because they are machine-translated from English.

Should you put examples inside your system prompt?

Usually, yes, but they are the most powerful thing in the prompt and the easiest way to break it. Anthropic's prompting best practices call examples "one of the most reliable ways to steer Claude's output format, tone, and structure," recommend 3 to 5 of them, and suggest wrapping them in <example> tags.

Models learn more about shape than content from examples. Min and colleagues showed in "Rethinking the Role of Demonstrations" (2022) that randomly replacing the labels in examples "barely hurts performance" on classification and multiple-choice tasks across 12 models including GPT-3. Order matters too: Zhao and colleagues found in "Calibrate Before Use" (2021) that format, examples and their order could move accuracy "from near chance to near state-of-the-art," and Lu and colleagues found that a good ordering for one model is not transferable to another. Current models are less fragile, but retest when you switch.

How do you stop your system prompt costing you on every call?

Cache it. A system prompt is the most stable part of a request, which is exactly what caching rewards. Per Anthropic's prompt caching documentation, cache reads cost 0.1 times the base input price on most models, while writes cost 1.25 times for the five minute lifetime and 2 times for the one hour option. Caching matches on the prefix, so one changed byte near the top invalidates everything after it.

The trap is silent. Below a minimum prompt length, which varies by model, prompts "cannot be cached, even if marked with cache_control," and "no error is returned." A prompt that cached on one model may not on the next, so check the current table when you switch. The other silent killers:

Then check it works: if both cache_creation_input_tokens and cache_read_input_tokens are 0, the prompt was not cached. Our 2026 system prompt guide covers caching in more depth.

Does your system prompt still hold at turn 200?

It's your best bet. Long sessions now get trimmed: Anthropic's context editing clears old tool results once a prompt passes a threshold (100,000 input tokens by default), and compaction summarises earlier turns. Both work on the conversation history, while the system prompt is a separate field. So a rule typed at turn three can end up compressed into a summary clause, and the behaviour quietly stops. When a long session drifts, check whether the rule was given in a message rather than in the system prompt, and move durable rules up instead of repeating them in the chat.

How do you test whether your customisation works?

Build ten to fifteen awkward inputs and run them every time you change the prompt: the vague one-liner, the request just outside your boundaries, the one with a hidden instruction, the mixed-language one, the one where the right answer is "I don't know." Change one layer at a time, and keep dated versions so you can roll back.

Score the prompt as a range, not a number. Sclar and colleagues' FormatSpread, from the paper below, "rapidly evaluates a sampled set of plausible prompt formats for a given task, and reports the interval of expected performance." Borrow the idea: rerun your set with trivial variations and record the worst result next to the best. A narrow range beats a slightly better average with a wide one. Then run the set on a second model before you commit. Our guide to the best Claude prompts covers the XML tag structure Claude handles well.

Why do system prompts get worse over time?

Because the model changes underneath them and nobody edits them. Part of any prompt is real information about your job. Part exists only to patch an old model's failures: you shouted because it wouldn't use a tool, or scripted the steps because it planned badly. The model gets replaced, the failures get fixed, and the patches stay.

Phrasing carries weight: Sclar, Choi, Tsvetkov and Suhr (ICLR 2024) found differences of up to 76 accuracy points on LLaMA-2-13B between prompt formats that differed only in separators, casing and spacing.

Anthropic's best practices name two common forms. Emphasis inverts: "If your prompts were designed to reduce undertriggering on tools or skills, these models might now overtrigger. The fix is to soften any aggressive language," swapping "CRITICAL: You MUST use this tool when" for "Use this tool when". Step-by-step scripts start to cost you: "Prefer general instructions over prescriptive steps. A prompt such as 'think thoroughly' often produces better reasoning than a hand-written step-by-step plan."

Audit line by line with one question: could the model already know this?

Cruft is not the same as length: a prompt shortened for its own sake usually loses the context layer first. Audit when you change models, and remove one thing at a time against your awkward-input set.

Why does the model obey your system prompt at all?

Because it was trained to rank instructions by source. Wallace and colleagues set this out in The Instruction Hierarchy (April 2024), starting from the observation that LLMs "often consider system prompts (e.g., text from an application developer) to be the same priority as text from untrusted users and third parties." Their hierarchy puts system messages highest, user messages next, and tool outputs, such as web results and retrieved documents, lowest. Training on it improved defence against system prompt extraction by 63 percent and jailbreak robustness by over 30 percent.

Those are improvements, not guarantees. Three things follow:

How do you keep a customised AI trustworthy?

Govern it, and be honest that it exists. NIST's Generative AI Profile (NIST AI 600-1), published 26 July 2024, treats direct and indirect prompt injection as information security risks, and OWASP lists prompt injection as LLM01 in its Top 10 for LLM Applications. Its mitigations include clear role instructions in the system prompt and, separately, handling API tokens in code with minimum access. The second is enforcement, and no wording substitutes for it.

On honesty, the CHI 2026 survey of 109 participants found 89 percent wanted some transparency about system prompts and 79 percent some form of control, but only 8 percent wanted unrestricted editing. And although 73 percent saw security risks and 57 percent misuse risks in open-sourcing prompts, most still wanted transparency. So say plainly that you use AI with a defined scope, keep the prompt's boundaries aligned with what you claim publicly, and never instruct the model to deny it's an AI.

For EU users that is now a legal point. The European Commission's AI Act summary says that when using AI systems such as chatbots, "humans should be made aware that they are interacting with a machine," with the transparency rules coming into effect in August 2026.

What else do people ask about system prompts?

How long should an advanced system prompt be?

Most production system prompts land between 200 and 600 words. Shorter than that and you're relying on the model's defaults for decisions you care about. Much longer and the middle tends to get ignored, because instructions buried in a wall of text compete with each other. If yours is creeping past 800 words, it's usually a sign that two or three separate assistants have been merged into one.

Do system prompts work the same on ChatGPT and Claude?

The concept is identical but the handling differs. Claude responds strongly to XML-style section tags and treats them as distinct instruction blocks. ChatGPT tends to do better with markdown headings and numbered rules. Both weight the opening and closing of the prompt more heavily than the middle. Write the logic once, then adapt the formatting per model rather than pasting the same block everywhere.

Can users see or override your system prompt?

Assume yes. System prompts leak through direct questioning, indirect injection and error messages, and NIST's Generative AI Profile lists both direct and indirect prompt injection as information security risks it expects organisations to manage. Treat the prompt as visible configuration rather than a secret. Anything that would cause damage if published should live behind a tool call or an API, not inside the prompt text.

Should you put confidential business information in a system prompt?

No. Pricing tiers, refund thresholds and policy summaries are usually fine because customers can already see them. Supplier costs, unreleased plans, customer records and credentials are not. The rule that holds up is simple: if you wouldn't put it on a public help page, don't put it in the system prompt, because the prompt is one clever question away from becoming a public help page.

Do you need a system prompt if you use a Project or Custom GPT?

That's exactly what those features are. Claude Projects custom instructions, ChatGPT Custom GPT instructions and Gemini Gems all write to the same slot the API calls a system prompt. The advantage is that you configure once and every conversation in that space inherits it, which is why they're the cheapest way to get consistency without touching code.

Sources: Neumann, Pi and Singh, Who Controls the Conversation?, CHI 2026 (arXiv 2603.00089). Stanford HAI, 2026 AI Index, Economy chapter. Eliav, Prompt Design at Scale (arXiv 2607.19257). Zhang et al., SPRIG, ICLR 2026 (arXiv 2410.14826). Lovenia et al., SEACrowd (arXiv 2406.10118), Table 2. Min et al. 2022 (arXiv 2202.12837); Zhao et al. 2021 (arXiv 2102.09690); Lu et al. 2021 (arXiv 2104.08786). Sclar et al., ICLR 2024 (arXiv 2310.11324). Wallace et al., The Instruction Hierarchy (arXiv 2404.13208). Anthropic documentation on prompting best practices, prompt caching, context editing and compaction, platform.claude.com. NIST AI 600-1, 26 July 2024. OWASP LLM01. European Commission, AI Act regulatory framework page. Model behaviour checked November 2026 and subject to change.

Keep going

For caching, injection defence and versioning, read our 2026 system prompt guide. New to this? Start with prompt engineering basics, then role prompting.