What Sensitive Information Should You Leave Out of Custom Instructions?
Summary
- Custom Instructions are a high-risk place to store sensitive data because they can be reused across many chats and copied into prompts without you noticing.
- Leave out secrets (passwords, API keys, private keys, one-time codes), regulated identifiers (SSNs, passport numbers), and any client or employer confidential information.
- Also avoid “soft sensitive” details (internal URLs, customer lists, deal terms, incident details, unreleased plans) that can still cause harm if exposed or reused in the wrong context.
- Use safer patterns: placeholders, redaction, minimal context, and “retrieve on demand” workflows instead of permanent instructions.
- Keep reusable context in a separate, searchable store and paste it only when needed; treat your clipboard history and prompt libraries as sensitive too.
Custom Instructions (and similar “always-on” personalization fields in AI tools) are convenient because they apply repeatedly. That convenience is exactly why they are risky: anything you put there can be pulled into many future conversations, copied into prompts, or shared in screenshots and exports. If you use AI for consulting, marketing, research, development, or content operations, the safest approach is to keep Custom Instructions “evergreen and non-sensitive,” and bring sensitive context in only when you intentionally need it.
This guide lists what to leave out, why it matters, and what to do instead so you can keep your workflows repeatable without leaking secrets or confidential information.
Why Custom Instructions are a sensitive place
Custom Instructions are designed to influence responses across sessions. That means:
- They can be reused broadly across different projects and clients, including when you forget they are enabled.
- They can be copied forward into prompts you share with teammates, contractors, or the public.
- They can show up in logs, screenshots, or screen shares during demos, recordings, or support calls.
- They can create “silent context bleed” where a detail intended for one client or project influences another.
Even if you trust the AI provider, the practical risk is often human: accidental paste, accidental share, wrong window during a call, or reusing a prompt template that still contains sensitive details.
What sensitive information to leave out (with examples)
Use the categories below as a checklist. If a detail would be harmful if it appeared in the wrong chat, a shared prompt, a screenshot, or a copied snippet, it does not belong in Custom Instructions.
1) Secrets and credentials (never include)
- Passwords (personal or work)
- API keys (OpenAI keys, cloud provider keys, analytics keys, email service keys, etc.)
- Private keys (SSH keys, signing keys, encryption keys, wallet seed phrases)
- Authentication codes (one-time passwords/2FA codes, recovery codes)
- Session tokens or bearer tokens
Safer alternative: Use placeholders like [API_KEY] and fetch the real value from a password manager or secrets manager only when needed. If you are writing code, pass secrets via environment variables and keep them out of prompts entirely.
2) Financial and payment data
- Credit/debit card numbers, bank account numbers, routing numbers
- Invoices containing sensitive billing identifiers
- Payment processor dashboards links that expose account identifiers
Safer alternative: Summarize at a higher level (e.g., “Use USD, show totals, include tax line items”) without including account numbers or payment identifiers.
3) Government IDs and regulated identifiers
- Social Security numbers (or local equivalents), passport numbers, driver’s license numbers
- Tax IDs, national IDs, immigration case numbers
Safer alternative: Use synthetic examples (fake but realistic formats) when you need formatting help.
4) Personal data about real people (especially clients, leads, employees)
- Home addresses, personal phone numbers, personal emails
- Dates of birth, full legal names paired with other identifiers
- Customer support transcripts that include identifying details
- Any sensitive HR details (performance issues, compensation, disputes)
Safer alternative: Replace with roles and placeholders: “Customer A,” “Prospect B,” “Employee X,” and keep only the minimum attributes needed for the task.
5) Health, legal, and other highly sensitive case details
- Medical information, diagnoses, prescriptions, insurance IDs
- Legal case facts, privileged communications, settlement details
- Incident response details that could increase risk if exposed
Safer alternative: Ask for general frameworks, checklists, or template language using hypothetical scenarios, then adapt privately.
6) Company confidential information and client confidentiality
- Unreleased product plans, internal roadmaps, M&A discussions
- Internal metrics, revenue, churn, pipeline, pricing exceptions
- Customer lists, lead lists, partner terms, contract clauses unique to a deal
- Internal documentation links, private repo URLs, internal hostnames
Safer alternative: Convert specifics into constraints: “Assume a B2B SaaS with annual contracts; write a renewal email that is firm but polite.” Keep client names and deal terms out of the always-on field.
7) “Soft sensitive” details that still cause damage
These are easy to rationalize (“it’s not a password”), but they can still leak strategy or create cross-client contamination:
- Internal naming conventions that reveal clients or projects
- Unique brand voice docs that are proprietary
- Embargoed announcements, launch dates, influencer lists
- Security architecture descriptions, vendor lists tied to vulnerabilities
Safer alternative: Keep Custom Instructions focused on general preferences (tone, formatting, how you like outputs structured) rather than proprietary content.
A practical “keep vs. leave out” table
| Instruction type | Put in Custom Instructions? | Example (safe) | Example (leave out) | Better approach |
|---|---|---|---|---|
| Output formatting preferences | Yes | “Use bullet points first, then a short recommendation.” | “Use our internal template from the Q3 client deck.” | Keep it generic; paste templates only when needed. |
| Writing style | Yes | “Write in clear international English; avoid hype.” | “Match Client X’s proprietary brand voice guide verbatim.” | Summarize style traits; store the full guide elsewhere. |
| Role and context | Partial | “Assume I’m a consultant writing for B2B teams.” | “I’m advising Company Y on a confidential acquisition.” | Use role-level context; add project specifics per chat. |
| Personal data | No | “Use placeholders for names and addresses.” | “My home address is… / My client’s phone number is…” | Redact and use role labels (Customer A, Employee X). |
| Credentials and secrets | No | “Never ask me to paste secrets; use env vars in examples.” | “My API key is… / Here is my private key…” | Use a password/secrets manager; keep secrets out of prompts. |
| Internal links and identifiers | No | “If you reference tools, describe steps without internal URLs.” | “Use https://intranet… and repo ssh://…” | Use public docs links or generic descriptions. |
| Reusable prompt patterns | Partial | “When I ask for an email, include subject + 2 follow-ups.” | “Always include our confidential pricing table.” | Store sensitive snippets separately; paste intentionally. |
Safer Custom Instructions: a template you can copy
If you want something practical that stays useful without being risky, start with a “preferences-only” instruction set like this and adjust:
- Role: “I use AI for consulting, marketing, research, and software work.”
- Output: “Start with a short answer, then steps, then a checklist. Use headings.”
- Assumptions: “Ask clarifying questions when requirements are ambiguous.”
- Safety: “Do not request or store passwords, API keys, private keys, or one-time codes. Use placeholders like [SECRET].”
- Quality: “If you’re unsure, say what’s unknown and propose options.”
This keeps your “always-on” context focused on how you want work done, not on what must remain confidential.
How to handle sensitive context without losing repeatability
Many teams put sensitive details into Custom Instructions because they want consistency. You can keep consistency without permanent exposure by switching to an “on-demand context” workflow:
- Step 1: Store reusable, non-sensitive building blocks (tone rules, formatting rules, checklists, prompt skeletons with placeholders).
- Step 2: Store sensitive details separately (in systems designed for them, or in documents with appropriate access controls).
- Step 3: Paste sensitive context only when needed into a specific chat or draft, and only the minimum required.
- Step 4: Redact before sharing prompts externally or reusing them for another client.
Don’t forget the clipboard: it can leak the same way
Even if you keep Custom Instructions clean, sensitive data can still slip through your workflow via copy/paste. Clipboard history, snippet tools, and prompt libraries can accidentally retain:
- Passwords copied during login
- API keys copied from dashboards
- Customer emails copied from CRM exports
- Internal links copied from private docs
Practical habit: before you paste into any AI chat (ChatGPT, Gemini, or another tool), do a quick scan of what you are about to send. If it contains secrets or identifiers, stop and replace with placeholders.
Using AI platform features without oversharing
AI platforms offer multiple places to “save context” (for example, Custom Instructions, memory-like personalization, project/workspace context, or pinned resources). Names and behavior can change over time, so treat any “persistent” feature as higher risk than a one-off message.
- Use persistent fields for preferences, not data: tone, formatting, how to ask questions, how to cite sources, etc.
- Use per-project context for project constraints: goals, audience, deliverables, but avoid client-identifying details unless you truly need them.
- Use per-chat messages for sensitive specifics: paste only what is necessary for that task, then remove it from any reusable template.
A concrete save-find-reuse workflow (without putting secrets in Custom Instructions)
If you do a lot of repeated AI work, the real win is having reusable prompt skeletons and context blocks that are safe to reuse. A practical workflow looks like this:
- Save: Keep a small set of reusable prompt skeletons (e.g., “Write a client update,” “Summarize research,” “Generate test cases”) with placeholders like [CLIENT], [PRODUCT], [CONSTRAINTS], [SENSITIVE_DETAIL].
- Find: When you start a new task, search your saved skeletons by a memorable phrase (e.g., “client update bullets” or “test cases edge conditions”).
- Reuse: Paste the skeleton into the chat, then fill placeholders from the minimum necessary source material. Keep the sensitive parts out of the reusable version.
This approach keeps your “always-on” instructions clean while still giving you speed and consistency.
CTA: If you want a Windows workflow for saving copied text locally, searching past clips, favoriting important clips, and separately saving reusable prompts (so you can paste only what you intend), you can try CopyCharm at https://copycharm.ai. If you later enable AI Access sync and authorize the ChatGPT connector, ChatGPT can search and retrieve only supported synced data (not your unsynced local data); for Gemini and other apps, the workflow remains manual copy/paste.
Frequently Asked Questions
FAQ 1: What is the single most important thing to leave out of Custom Instructions?
Answer: Secrets: passwords, API keys, private keys, session tokens, and one-time authentication codes. These can be copied, reused, or exposed far beyond the moment you intended.
Takeaway: If it can unlock an account or system, it does not belong in Custom Instructions.
FAQ 2: Are client names and project names considered sensitive?
Answer: They can be. Even without credentials, a client name plus a project description can reveal confidential relationships, strategies, or timelines. If you work across multiple clients, names in always-on instructions also increase the risk of cross-client mix-ups.
Takeaway: Use placeholders (Client A, Project Blue) in persistent fields and add real names only inside the specific chat where needed.
FAQ 3: Is it safe to put internal URLs, repo links, or dashboard links in Custom Instructions?
Answer: It is safer to avoid them. Internal links can expose tool choices, internal hostnames, account identifiers, or private documentation paths. Even if the link itself is access-controlled, the metadata can still be sensitive.
Takeaway: Keep Custom Instructions link-free; paste internal links only when you intentionally need them for a specific task.
FAQ 4: Can I store a “standard client brief” in Custom Instructions if I reuse it every day?
Answer: Only if it is truly non-sensitive and non-identifying. Many “standard briefs” quietly include confidential details (customer segments, pricing, internal metrics, partner names). A safer pattern is to store a brief skeleton with placeholders and paste the filled-in version per project or per chat.
Takeaway: Reuse structure in Custom Instructions; bring real client specifics in on demand.
FAQ 5: What should developers avoid putting in Custom Instructions?
Answer: Avoid secrets (API keys, private keys, tokens), proprietary source code you are not allowed to share, internal architecture details tied to security, private repo URLs, and any customer data from production logs. If you need consistent coding help, store preferences like language, style, and testing expectations instead.
Takeaway: Put coding preferences in Custom Instructions, not credentials, proprietary code, or production data.
FAQ 6: What should marketers and content teams avoid putting in Custom Instructions?
Answer: Avoid embargoed launch details, unreleased messaging, influencer/press lists, customer lists, deal terms, and any internal performance metrics that are not meant to be shared. Keep persistent instructions focused on tone, structure, compliance constraints, and review checklists.
Takeaway: Store your “how we write” rules persistently; keep “what we know internally” out of always-on fields.
FAQ 7: If I already pasted sensitive info into Custom Instructions, what should I do now?
Answer: Remove it immediately, then rotate anything that could be used for access (passwords, API keys, tokens). After that, review any prompts or templates you shared that might include the same data, and replace them with redacted versions using placeholders.
Takeaway: Delete first, rotate access second, then clean up any reused templates.
FAQ 8: How can CopyCharm help me reuse prompts without putting sensitive info in Custom Instructions?
Answer: You can keep reusable prompt skeletons and safe context blocks as saved prompts, then search and copy/paste them only when needed. If you choose to enable AI Access sync and authorize the ChatGPT connector, ChatGPT can search and retrieve supported synced data after authorization and sync; it cannot access unsynced local data. For Gemini and other apps, you would still manually copy/paste from your saved content.
Takeaway: Reuse safe templates on demand, and keep sensitive specifics out of persistent instruction fields.