System prompts and custom instructions: setting your defaults

System Prompts and Custom Instructions: Setting Your Defaults

Every AI assistant you use starts with a blank slate — unless you tell it otherwise. System prompts and custom instructions are how you pre-load context, tone, and behavior before a single conversation begins. Instead of re-explaining who you are and what you need every session, you encode it once. ChatGPT, Claude, and Gemini all support this. The difference between a generic AI response and one that feels tailored to your work? Usually, it's a well-crafted system prompt sitting behind the scenes.

7 Things You Need to Know Before We Start

1. A system prompt is a persistent instruction block that shapes every response in a session — it runs before your first message.
2. Custom Instructions in ChatGPT (available to all users since August 2023) are the consumer-friendly version of system prompts.
3. Claude accepts system prompts via its API and through Claude.ai's Projects feature, which launched in 2024.
4. System prompts are invisible to end users in deployed apps — when you use a company's AI chatbot, there's almost certainly a system prompt shaping its behavior.
5. You can't fully override a model's safety guardrails with a system prompt, but you can dramatically change tone, format, verbosity, and expertise level.
6. Token length matters: system prompts consume context window space. A 500-word system prompt in GPT-4o leaves less room for your conversation.
7. Bad system prompts create worse outputs than no system prompt — vague instructions produce vague behavior.

What a System Prompt Actually Does

When you send a message to ChatGPT or Claude, the model doesn't just see your words. It sees a structured input that typically has three layers: the system prompt, the conversation history, and your current message. The system prompt sits at the top of that stack and carries the highest interpretive weight. Think of it as the briefing you give a new hire before their first client call — it sets expectations, defines the role, and establishes what 'good' looks like before any specific task arrives.

Practically, this means a system prompt can tell GPT-4o to always respond in bullet points, to assume you're a senior financial analyst, to never use hedging language, or to default to British English. These aren't just stylistic tweaks — they change the model's reasoning path. A prompt that says 'you are a skeptical editor' produces fundamentally different feedback on a draft than one that says 'you are an encouraging writing coach.' Same model, same draft, radically different output.

• Sets the AI's persona and expertise level for the entire session
• Controls default output format (prose, bullets, tables, code blocks)
• Defines what the model should assume about your background and goals
• Establishes constraints — what to avoid, what to flag, what to escalate
• Can specify response length preferences (concise vs. comprehensive)
• Locks in language, tone, and formality level without repeating it each time

System Prompt Anatomy: A Field Reference

ChatGPT Custom Instructions vs. Claude Projects

ChatGPT's Custom Instructions live in your account settings and apply globally across new conversations. You fill in two fields: what ChatGPT should know about you, and how you want it to respond. These persist until you change them. The practical ceiling is around 1,500 characters per field — enough for a solid persona and format brief, but not a full operational manual. ChatGPT Plus subscribers also get the ability to create GPTs, which have their own dedicated system prompts and can be shared with others.

Claude handles this differently. Claude.ai's Projects feature (launched mid-2024, available on Pro plans at $20/month) lets you create persistent workspaces with a custom system prompt and uploaded reference documents. A Project for client work might include your system prompt, a style guide PDF, and a company fact sheet — all of which Claude references automatically. This makes Claude Projects closer to a configured AI workspace than a simple chat interface. For API users of either model, system prompts are passed programmatically with each request.

1. Open ChatGPT → click your profile icon → 'Customize ChatGPT' to access Custom Instructions
2. Field 1 ('About you'): enter your role, industry, expertise level, and key context
3. Field 2 ('Response preferences'): specify format, tone, length, and any recurring constraints
4. For Claude Projects: go to claude.ai → 'Projects' → 'New Project' → paste your system prompt in the Project Instructions field
5. Test immediately: send a standard work request and check whether the defaults changed
6. Iterate: if the output still feels generic, add more specificity to the role definition

A System Prompt in the Wild

Writing Effective Instructions: The Specificity Principle

The single biggest mistake professionals make with custom instructions is staying abstract. 'Be helpful and professional' tells the model almost nothing it doesn't already default to. Every instruction you write should be testable — you should be able to look at an AI response and confirm whether the instruction was followed. 'Use bullet points for any list of three or more items' is testable. 'Be clear and organized' is not. Specificity also helps the model handle edge cases: when it knows your exact defaults, ambiguous situations resolve closer to your preference.

A useful drafting technique: write your system prompt by imagining the most annoying AI behaviors you want to eliminate. If ChatGPT always writes five-paragraph essays when you want a quick answer, add 'Default to concise responses under 200 words unless I ask for more.' If it over-hedges with phrases like 'it's important to consider,' ban them explicitly. Negative instructions ('do not,' 'avoid,' 'never') work just as well as positive ones and are often easier to write from lived frustration with the tool.

Quick Reference: System Prompt Essentials

• System prompts run before your first message and shape every response in the session
• ChatGPT Custom Instructions: ~1,500 chars per field, account-level, free to use
• Claude Projects: ~2,000 chars + document uploads, Pro plan required ($20/month)
• Always start with a specific role definition — 'You are a [role] with expertise in [domain]'
• Make every instruction testable: you should be able to verify compliance in the output
• Negative instructions work well — ban specific phrases or behaviors you dislike
• System prompts consume context window tokens — keep them tight and purposeful
• Never store sensitive data (credentials, confidential info) in a system prompt
• GPT-4o system prompts support up to ~8,000 tokens in the GPT builder interface
• Gemini uses 'Gems' for saved personas; Copilot uses admin-configured instructions at enterprise tier

Key Takeaways from This Section

1. System prompts are persistent instruction layers — they define the AI's defaults before any task arrives.
2. Custom Instructions (ChatGPT) and Projects (Claude) are the practical interfaces for non-developers to set these defaults.
3. Specificity is the core skill: vague instructions produce vague behavior, testable instructions produce consistent results.
4. The anatomy of a strong system prompt includes: role definition, audience context, format defaults, tone rules, and constraints.
5. Different tools handle system prompts differently — knowing the character limits and scope of each platform helps you work within them.
6. Weak instructions fail because they're untestable; rewrite them with measurable criteria or explicit examples.
7. Treat system prompts as semi-public configuration — never embed sensitive information in them.

What Goes Inside a System Prompt

Part 1 established what system prompts are and why they exist. Now you need to know what to actually put in them. The best system prompts are built from five distinct layers: identity, context, constraints, format rules, and behavioral nudges. Most beginners write one or two of these and wonder why results are inconsistent. Professionals stack all five. Each layer handles a different failure mode — identity stops role confusion, constraints stop scope creep, format rules stop wall-of-text responses that waste your time.

The Five Layers of an Effective System Prompt

1. Identity — Who the AI is playing: role, expertise level, name if needed ('You are a senior financial analyst with 15 years in equity research')
2. Context — What world it operates in: your industry, your company, your audience ('Our customers are mid-market SaaS companies with 50–500 employees')
3. Constraints — What it must never do: topics to avoid, formats to reject, claims it cannot make ('Never recommend specific stocks or give legal advice')
4. Format rules — How output should look: length, structure, use of headers, bullet density, response style ('Always respond in under 200 words unless asked for a full report')
5. Behavioral nudges — Tone and reasoning style: direct vs. diplomatic, ask clarifying questions vs. attempt and note assumptions ('When the request is ambiguous, state your assumption and proceed')

System Prompt Component Reference

Platform Differences That Change Everything

System prompts don't behave identically across platforms. ChatGPT's Custom Instructions live in two fields: 'What would you like ChatGPT to know about you?' and 'How would you like ChatGPT to respond?' — effectively splitting context from format rules. Claude's system prompt is a single free-form field with a higher character limit and stronger instruction-following on constraints. Gemini Advanced's system prompt support (called 'Gems') is the newest of the three and currently the least flexible for complex behavioral rules. Knowing which platform you're on determines how you structure your input.

The practical implication: a system prompt that works perfectly in Claude may need restructuring for ChatGPT. Claude handles long, nuanced constraint lists well — it genuinely reads and applies them. ChatGPT benefits from shorter, more directive phrasing in each field. If you use both tools (many professionals do), maintain two versions of your core system prompt. It takes 20 minutes once and saves hours of prompt-repair later. Notion AI and Perplexity don't expose true system prompts to end users, so on those platforms your technique shifts to persistent context blocks at the top of every session.

• ChatGPT Custom Instructions: two fields, ~1,500 characters each, applies to all GPT-4o conversations by default
• Claude Projects: single system prompt field, higher limit (~2,000+ tokens), strongest constraint adherence of the three
• Gemini Gems: template-based system prompts, good for role-playing personas, weaker on complex multi-rule sets
• GitHub Copilot: system behavior set by your IDE and workspace settings, not a text field — configured via .github/copilot-instructions.md
• Notion AI: no exposed system prompt — use a pinned 'context block' at the top of your workspace as a workaround
• Perplexity: no persistent system prompt for standard users — Pro users can set default focus modes but not full behavioral instructions

A Real System Prompt in the Wild

Where System Prompts Break Down

System prompts are not foolproof. Three failure modes appear repeatedly. First, instruction overload: cramming 20 rules into one prompt causes the model to honor the first five and quietly ignore the rest. Models have finite attention, and a 1,200-word system prompt competes with your actual query for that attention. Keep system prompts under 400 words for ChatGPT and under 600 for Claude. If you have more rules than that, they belong in a reference document, not the system prompt itself.

Second failure mode: contradictory instructions. 'Be concise' and 'always provide full context with examples' cannot coexist without a priority rule. The model will pick one interpretation and apply it inconsistently. Third failure mode: prompt drift over long conversations. After 15–20 exchanges, even a strong system prompt loses influence as the conversation history grows. The model starts weighting recent messages more heavily than the original instructions. For long working sessions, paste a one-line reminder of your key constraint — 'reminder: keep all responses under 150 words' — every 10 or so exchanges.

• Keep system prompts under 400 words (ChatGPT) or 600 words (Claude) to avoid instruction dropout
• Resolve contradictions explicitly: 'Be concise — but if asked for a full report, length is no longer constrained'
• Use priority language: 'Above all else...', 'Unless explicitly told otherwise...'
• For sessions longer than 20 exchanges, paste a short constraint reminder mid-conversation
• Test your system prompt with 5 diverse queries before relying on it in real work — edge cases surface fast
• Version-control your system prompts in a simple doc with dates — models update, and a prompt that worked in March may drift by June

Quick Build: Your First Professional System Prompt

System Prompt Cheat Sheet

• Five layers: Identity → Context → Constraints → Format rules → Behavioral nudges
• ChatGPT: two fields, ~1,500 chars each | Claude Projects: single field, 2,000+ tokens | Gemini Gems: ~500 words
• Under 400 words for ChatGPT, under 600 for Claude — beyond that, rules get dropped
• Contradictory instructions cause inconsistency — always specify which rule wins
• Long sessions cause prompt drift — paste a constraint reminder every ~10 exchanges
• Claude Projects: attach reference docs alongside system prompts for zero-setup context
• GitHub Copilot: use .github/copilot-instructions.md for persistent code standards
• Never embed confidential data in system prompts — treat them as semi-public
• Version-control your prompts with dates — model updates can shift behavior
• Test with 5 diverse queries before relying on any new system prompt in real work

You have a working mental model of system prompts and custom instructions. Now the goal is precision — knowing exactly which levers to pull for different work contexts, avoiding the mistakes that silently degrade your outputs, and building a personal defaults library you actually reuse. The professionals who get the most from ChatGPT, Claude, and Gemini are not the ones who write the cleverest one-off prompts. They are the ones who invest 20 minutes once and benefit every session after that.

Tuning for Context: Role-Specific Default Strategies

Different professional roles demand radically different AI defaults. A marketing director wants punchy, persuasive copy at a tenth-grade reading level. A strategy consultant wants structured analysis with explicit assumptions and caveats. A data analyst wants code-first responses with inline comments. Your custom instructions should encode your role's specific communication contract — the unspoken rules your colleagues already follow when they brief you. Generic defaults produce generic outputs. Role-tuned defaults make the AI feel like it was hired specifically for your job.

What to Include — and What to Leave Out

Overstuffed custom instructions backfire. When you load 800 words of preferences into a system prompt, the model starts dropping instructions — particularly the ones near the end. ChatGPT's custom instructions field has a 1,500-character limit precisely because brevity forces prioritization. Claude's system prompts can be longer, but longer does not mean better. Treat your defaults like a job brief: include the non-negotiables, skip the nice-to-haves. If a preference only applies once a month, handle it in that specific prompt instead.

• Include: your role, your audience, preferred output format, tone, any hard constraints (no legal claims, no speculation presented as fact)
• Include: response length preference (concise vs. comprehensive) and whether you want the model to ask clarifying questions
• Include: any domain-specific vocabulary or frameworks you use regularly (OKRs, MECE, RACI, Jobs-to-be-Done)
• Exclude: preferences that vary by task — handle those inline
• Exclude: redundant instructions ('always be helpful') that the model already defaults to
• Exclude: contradictory instructions ('be brief' + 'always give full examples') — pick one or scope them separately

Common Failures and How to Fix Them

Even well-intentioned custom instructions fail in predictable ways. The most common: instructions that conflict with the task at hand. If your default says 'be concise' but you ask for a 2,000-word report, the model will be confused about which instruction to honor — and it will usually follow the in-conversation request, quietly dropping your default. The fix is to write defaults that apply to mode, not length, and override length explicitly in each prompt.

Quick-Reference Cheat Sheet

• Custom instructions in ChatGPT: Settings → Personalization → Custom Instructions (1,500-char limit)
• Claude system prompts: set per-project via Projects, or per-conversation in the API
• Gemini custom personas: create via 'Gems' in the Gemini interface
• Always include: role + audience + format preference + tone + hard constraints
• Always exclude: generic quality requests, task-specific one-offs, contradictory instructions
• Keep custom instructions under 300 words for reliable instruction-following
• Defaults set the baseline — override inline for task-specific needs
• Test your defaults with three real work tasks before treating them as final
• Revisit and update your defaults every 4–6 weeks as your work evolves

Key Takeaways

1. Role-specific defaults outperform generic ones — encode your professional context explicitly
2. Brevity in custom instructions is a feature, not a limitation — prioritize ruthlessly
3. Know where your defaults live in each tool; they do not transfer between platforms automatically
4. Conflicting instructions cause silent failures — write defaults that complement, not compete with, your task prompts
5. Your defaults are a living document — test, observe, and iterate every few weeks
6. The investment is front-loaded: 20 minutes of setup pays back across hundreds of future sessions