Home › Prompt Library › Prompt for Custom GPT & Assistant Instructions

Prompt for Custom GPT & Assistant Instructions

Generate clear system instructions for a Custom GPT, Claude Project or Gemini Gem — role, rules, tone and format.

Prompting · Works great in Any AI

Copy-ready prompt

You are an expert at writing system instructions for custom AI assistants.
Write a complete instruction block for the assistant I describe below.
Purpose: [what this assistant is for and what problem it solves].
Platform: [Custom GPT / Claude Project / Gemini Gem / other].
Audience: [who will use it — customers, my team, me].
Persona: [the character or expertise it should embody].
Tone: [friendly / professional / concise / playful — pick what fits].
Rules and boundaries: [what it must always do, and what it must never do].
Output format: [how answers should be structured — length, headings, lists, examples].
Produce the instructions as a structured block with these sections:
- Role — who the assistant is and its expertise.
- Behavior — how it approaches the user and their requests.
- Rules & boundaries — explicit always/never statements.
- Process — the steps it follows to handle a request.
- Output format — exactly how it should present answers.
Write it in the second person, addressed to the assistant ("You are..."), and make it copy-paste ready.

Want a version tailored to you?

Answer a few quick questions and the Custom GPT Instructions Generator builds a custom prompt from your exact details.

⚙️ Open the Custom GPT Instructions Generator

Why a vague setup produces inconsistent answers

When people build a Custom GPT or a Claude Project, they often type a single sentence into the instructions box — "You are a helpful marketing assistant" — and then wonder why the results swing wildly from one conversation to the next. The problem is that a one-liner leaves almost every decision to the model. With nothing to anchor it, the assistant guesses at tone, invents its own format, and applies whatever default behaviour the underlying model happens to have that day. So the same assistant writes a punchy answer in the morning and a rambling one in the afternoon, uses bullet points once and dense paragraphs the next time, and occasionally strays into territory you never intended. Consistency is not something the model gives you for free; it comes from instructions specific enough to remove the guesswork. This prompt exists to force that specificity — purpose, audience, persona, tone, rules, and format all stated explicitly, so the assistant has a fixed reference point instead of improvising a personality each session.

The anatomy of good instructions: role, rules, process, format

Strong system instructions are not a paragraph of good intentions; they have parts, each doing a distinct job. The Role establishes who the assistant is and what expertise it brings, which shapes the vocabulary and confidence of every answer. Behavior describes how it engages — whether it asks clarifying questions, how proactive it is, how it treats a confused user. Rules and boundaries lay down the explicit lines it must not cross and the things it must always do. Process gives it a repeatable method for handling a request, so complex tasks are approached the same careful way every time rather than however the model feels like starting. Output format specifies exactly how answers are presented — length, headings, lists, whether to include examples. This prompt asks for all five as labelled sections precisely because a wall of prose blurs them together and lets the model skim past whichever part is inconvenient. Structured sections make each instruction visible and hard to ignore, and they make the instructions far easier for you to edit later.

Rules and boundaries are what keep it on-brand

The section that does the most to make an assistant feel reliable is rules and boundaries, expressed as concrete always and never statements. General guidance like "be helpful" is unfalsifiable and changes nothing, but "always cite the source document before answering" or "never recommend a competitor's product" or "never give medical or legal advice — redirect to a professional" are rules the model can actually follow and you can actually check. These statements are where your brand, your compliance requirements, and your judgement get encoded. They also handle the awkward edge cases in advance: what should the assistant do when it does not know, when a user asks for something off-topic, when a request is inappropriate? Deciding that once, in writing, is far better than hoping the model improvises well. The prompt deliberately asks for explicit always/never phrasing because vague boundaries are the first thing to erode under an insistent user, whereas a clear "never" gives the assistant a firm line to hold.

It works across platforms — and you should iterate

The nice thing about instructions written this way is that they are portable. A Custom GPT, a Claude Project, and a Gemini Gem all work from a block of system-level instructions, and the same structured brief — role, behaviour, rules, process, format — drops into any of them with only light tweaking. Writing in the second person, addressing the assistant directly as "You are...", is the convention all three understand, which is why the prompt specifies it. That said, no instruction block is perfect on the first try. The right way to use this is to generate a solid draft, deploy it, then watch how the assistant actually behaves and tighten the instructions where it drifts. If it keeps answering too long, sharpen the output-format section. If it wanders off-topic, add a boundary. If it forgets to ask for context it needs, add a step to the process. Treat the instructions as a living document you refine against real conversations, and the assistant gets steadily more consistent and more yours over time.

Why this prompt works

Vague setup instructions are why a custom assistant feels inconsistent — great one turn, off-brand the next. This prompt turns a short brief into a structured instruction block with clear role, rules, process and format, written in the second person so you can paste it straight into a Custom GPT, Claude Project or Gemini Gem.

How to customize it

Use labelled sections — role, rules, process, format — so nothing gets skimmed.
Write concrete always/never rules, not vague good intentions.
Deploy, watch for drift, then tighten the section that fails.

Example output

Sample only

Brief: "A Custom GPT that helps my small team write LinkedIn posts in our brand voice — practical, warm, no hype. Should ask what the post is about, then draft three options."

Generated instruction block:

Role: You are a social media copywriter for our brand. You specialise in short, engaging LinkedIn posts and you know our voice: practical, warm, and free of hype or buzzwords.

Behavior: You are collaborative and efficient. If a request is thin on detail, you ask one or two focused questions before drafting rather than guessing.

Rules & boundaries: Always write in first person, as the team member posting. Always keep posts under 150 words. Never use hashtag stuffing, clickbait, or phrases like "game-changer" or "unlock." Never invent statistics or client names.

Process: 1) Confirm the topic and the goal of the post. 2) Ask for any specifics — a result, a lesson, a link. 3) Draft three distinct options with different angles.

Output format: Present exactly three numbered post options. After each, add a one-line note on the angle it takes. No preamble.

Prompt variations to try

Instructions for a support assistant

You are an expert at writing system instructions for custom AI assistants. Write a complete instruction block for a customer support assistant.
Product / company: [what it supports].
Platform: [Custom GPT / Claude Project / Gemini Gem].
Knowledge sources: [help docs, FAQ, policies it should rely on].
Escalation rule: [when and how it should hand off to a human].
Tone: [empathetic and professional].
Requirements:
- Structure it as Role, Behavior, Rules & boundaries, Process, Output format, in the second person.
- Always ground answers in the provided sources; never invent policy or make promises about refunds, timelines, or exceptions.
- Include a clear step for when it doesn't know or the issue needs a human.
- Keep answers concise and end by checking whether the user's problem is resolved.
Make it copy-paste ready.

Instructions for a writing/editor assistant

You are an expert at writing system instructions for custom AI assistants. Write a complete instruction block for a writing and editing assistant.
Purpose: [proofread / rewrite / match a style].
Style guide or voice: [describe it, or note the guide to follow].
Audience the writing is for: [who reads the output].
Tone: [what the assistant itself should sound like].
Requirements:
- Structure it as Role, Behavior, Rules & boundaries, Process, Output format, in the second person.
- Always preserve the author's meaning and voice; never change facts or add claims.
- Specify whether it should show tracked changes, explain edits, or return clean copy.
- Include a step to ask about the goal (clarity, brevity, tone) before editing.
Make it copy-paste ready.

Add guardrails to an existing GPT

You are an expert at writing system instructions for custom AI assistants. Here are the current instructions for my assistant:
[paste existing instructions]
It sometimes goes wrong in these ways:
[describe the drift — too long, off-topic, off-brand, gives advice it shouldn't].
Requirements:
- Rewrite the instructions to add clear guardrails that fix each problem, keeping what already works.
- Add explicit always/never rules and a defined behaviour for out-of-scope or inappropriate requests.
- Preserve the assistant's role, tone, and format unless a change is needed to fix the issue.
- List the specific guardrails you added and why.
Return the full updated instruction block, copy-paste ready.

Common mistakes to avoid

Writing a one-line setup. "You are a helpful assistant" leaves every decision to the model, so behaviour drifts between conversations. Specify role, tone, rules, and format explicitly.
Skipping rules and boundaries. Without concrete always/never statements, the assistant improvises on edge cases and strays off-brand. Spell out what it must always do and must never do.
Being vague about output format. If you don't say how answers should look, you get inconsistent structure. State length, headings, lists, and whether to include examples.
Not defining a process. Complex requests need a repeatable method, or the assistant starts differently each time. Give it clear steps to follow for handling a request.
Treating the first draft as final. Instructions need tuning against real conversations. Deploy, watch where the assistant drifts, and tighten the relevant section rather than leaving it as-is.

Frequently asked questions

Do these instructions work for Claude Projects and Gemini Gems, not just Custom GPTs?

Yes. All three run from a block of system-level instructions, and the structured brief — role, behaviour, rules, process, format — drops into any of them with only light tweaking. Writing in the second person ("You are...") is the convention each platform understands, so the output is portable across them.

How detailed should the instructions be?

Detailed enough to remove guesswork, but not bloated. Cover the five sections clearly, use concrete always/never rules, and specify the output format precisely. If the assistant behaves consistently, you have enough; if it drifts, add a targeted rule rather than padding every section. Aim for specific over long.

Why write the instructions in the second person?

Addressing the assistant directly as "You are..." is how all the major platforms expect system instructions to be phrased, and it keeps the model in character. It reads as a set of standing directives to the assistant rather than a description of it, which produces more consistent, in-persona behaviour.

My assistant keeps going off-topic — how do I fix it?

Use the "add guardrails" variation. Paste your current instructions, describe the drift, and ask for explicit boundaries plus a defined behaviour for out-of-scope requests. A firm "never" rule and a stated fallback ("if asked about X, redirect to Y") give the model a clear line to hold that vague guidance never does.

Tip: replace the parts in [square brackets] with your own details before you send. The more specific you are — audience, tone, goal, constraints — the better the AI output.