System Prompts: How to Configure AI Assistants and GPTs

Every AI assistant you have ever admired for staying "in character" is running on a set of instructions you never see. The customer-support bot that refuses to talk politics, the coding helper that always returns runnable snippets, the brand voice that sounds identical across a thousand chats: none of that consistency is luck. It is written down once, at the top, and applied to every message that follows. Learn to write that layer well and you stop begging a model to behave in each new chat. You configure it once and let it hold the line.

Where these instructions actually live

The same idea shows up under different names depending on the tool, but the mechanics are nearly identical. Knowing where the field is saves you from pasting setup text into every conversation.

• Custom GPTs (ChatGPT): the "Instructions" box in the GPT builder. Whatever you type there travels with the GPT for anyone who uses it.
• Claude Projects: the "custom instructions" attached to a project, applied to every chat inside it. If you work in Claude often, the Claude prompting guide covers how these interact with project knowledge.
• The API: a dedicated system role in the messages array, separate from user and assistant turns. This is the rawest form and the one you have most control over.
• Agent frameworks: LangChain, CrewAI, and similar tools expose it as a template string fed to the model before any task runs. Multi-agent setups often give each agent its own.

Wherever it lives, the instruction sits above the conversation and outlasts it. A user can nudge tone within a single chat, but they are steering inside the lane you painted.

Building it piece by piece

A strong configuration is not one long paragraph of wishes. It is a handful of distinct parts, and writing them in order keeps you from forgetting the ones people skip.

Start with the role. Give the assistant a name and a job, because a concrete identity constrains behavior better than an adjective. "You are Mara, an onboarding specialist for a payroll SaaS" does more work than "be helpful and friendly."

Next, spell out responsibilities and capabilities. What is this thing actually for? List the tasks it should take on and, just as usefully, name the tools or data it can reach. If it can query a knowledge base but cannot process refunds, say both.

Then set tone and style. Be specific about sentence length, formality, and formatting. "Warm but brief, no more than three sentences unless asked, never use exclamation marks" is testable. "Sound professional" is not.

The part most people underwrite is rules and boundaries. These are the non-negotiables: what to never do, what to always include, which topics are off-limits. Put the ones that matter most near the top, because instructions early in the block tend to survive long conversations better than ones buried at the bottom.

Finally, decide how the assistant handles ambiguity and out-of-scope requests. Models hate saying "I don't know," so they guess. Head that off:

• When a request is unclear, ask one clarifying question before answering.
• When something falls outside the defined scope, decline briefly and point to the right channel.
• When information is missing, say so rather than inventing it.

Three prompts you can adapt

Reading finished examples teaches faster than any checklist. Notice how each one names a role, fences off scope, and handles the awkward request before it happens.

A focused utility bot with hard limits:

A customer-facing support persona with a clear escalation path:

An internal tool that shapes the output format tightly:

Each of these is short. That is the point. You can generate scaffolding like this quickly with a system prompt generator and then tighten the wording by hand.

Dos and don'ts that save you rewrites

Most broken configurations fail for the same few reasons. Steer around them:

• Do keep it focused. One assistant, one clear job. A prompt that tries to be a lawyer, a comedian, and a database admin will be mediocre at all three.
• Don't stack contradictory rules. "Always be thorough" fighting "always keep replies under two sentences" forces the model to pick a winner, and you will not like which one. Reconcile conflicts before you ship.
• Do put critical rules first. The safety limit or the never-do line belongs near the top, not paragraph nine.
• Don't rely on politeness to enforce limits. "Please try not to" is weaker than "Never." Say what you mean plainly.
• Do use formatting the model can mirror. If you want tables, show a table. If you want short answers, keep your own instructions short.
• Don't overstuff. Ten sharp rules beat forty vague ones. Extra length dilutes the instructions that matter.

If you are wiring together several assistants that hand off to each other, the tradeoffs get subtler, and advanced prompt engineering goes deeper on structuring multi-step and role-based setups.

Test it before you trust it

A configuration you have not stress-tested is a guess. Treat the first draft as a hypothesis and try to break it.

• Feed it the messy inputs real users send: typos, half-questions, requests that skirt your boundaries.
• Deliberately ask for the thing you forbade. If LedgerBot hands out tax advice on the second try, your rule is not firm enough.
• Run a long conversation and check whether the tone holds at message thirty the way it did at message two.
• Change one instruction at a time so you can tell what caused a shift in behavior.

When something drifts, resist the urge to bolt on another sentence. Often the fix is deleting a rule that quietly contradicts another one. A prompt optimizer can help you spot that tension and trim the fat. For platform-specific quirks in how ChatGPT reads custom instructions, the ChatGPT prompts guide is a useful companion. Iterate, and the version you ship will feel less like a leash and more like a colleague who already knows the rules.

References

• Anthropic — Prompt engineering overview
• OpenAI — Prompt engineering guide