Your ChatGPT custom instructions — the “who you are” and “how you should respond” settings — are among your most valuable AI assets. They encode your professional voice, domain expertise, ethical guardrails, formatting preferences, and even stylistic quirks. Yet OpenAI offers no native export button, no sync across devices, and zero interoperability with other AI tools. When you switch from ChatGPT’s web interface to its iOS app — or migrate prompts to Claude, Perplexity, or a local LLM — those carefully crafted instructions vanish unless you proactively preserve and adapt them. This isn’t just about convenience. It’s about continuity of identity, consistency in output quality, and control over how your knowledge is represented across ecosystems.
Why custom instructions matter — and why they’re fragile
Custom instructions differ fundamentally from regular prompts. While a prompt is situational (“Write a summary of this article”), custom instructions are persistent, system-level directives: “You are a senior clinical pharmacologist advising physicians. Always cite peer-reviewed sources published within the last five years. Never speculate about off-label drug use. Use plain language for patient-facing summaries.” These shape every interaction — even when you forget to restate them. That’s powerful. But it’s also precarious. A browser cache wipe, an app reinstall, or switching accounts resets them silently. Worse, OpenAI doesn’t log changes, version them, or provide audit trails. You could lose weeks of refinement in one accidental click.
“Custom instructions are the closest thing we have to a personal AI constitution — yet they’re stored like sticky notes on a browser tab.” — Dr. Lena Torres, Human-AI Interaction Researcher at MIT Media Lab
This fragility becomes acute when professionals rely on ChatGPT across contexts: a journalist drafting headlines on desktop, fact-checking on mobile, then feeding refined outputs into Notion AI or Obsidian plugins. Without portable instructions, tone drifts, sourcing standards weaken, and critical constraints (e.g., “never generate code without explaining security implications”) get dropped mid-workflow.
Step-by-step: Exporting your custom instructions manually (with verification)
OpenAI doesn’t offer export — but the data is fully accessible via your browser. Here’s how to extract it reliably, safely, and completely:
- Log in to chat.openai.com using the account containing your custom instructions.
- Navigate to Settings → Personalization → Custom Instructions.
- Click inside each text field (‘How would you like ChatGPT to respond to you?’ and ‘What would you like ChatGPT to know about you?’) — do not select all text yet.
- Press
Ctrl+A(Windows/Linux) orCmd+A(Mac) to select the full content. Avoid mouse-drag selection — it often misses trailing spaces or line breaks. - Copy with
Ctrl+C/Cmd+C. Paste into a plain-text editor (e.g., VS Code, TextEdit in plain mode, or Notepad) — never Word or Google Docs initially, as they inject hidden formatting. - Verify integrity: Compare character count in the original field (visible in browser DevTools: right-click → Inspect → Elements → find
textarea→ checkvalue.length) against your pasted copy. Mismatches indicate invisible truncation. - Add metadata: Above each section, label it clearly:
--- CUSTOM INSTRUCTIONS EXPORT --- Generated: 2024-06-15 Account: alex@techpolicy.org Version: v2.3 (Updated after Q3 compliance review) --- [How would you like ChatGPT to respond to you?] You are a senior policy analyst specializing in AI governance... [full text] --- [What would you like ChatGPT to know about you?] I work for a nonpartisan think tank focused on algorithmic accountability... [full text]
https://chat.openai.com/settings/personalization) — it’s faster than navigating menus and avoids accidental edits during export.
Reusing instructions across platforms: A compatibility matrix
Not all platforms accept custom instructions identically. Some require JSON payloads; others only support system prompts in specific formats. Below is a verified compatibility reference for common tools as of mid-2024:
| Platform | Supported Format | Key Limitations | Adaptation Required? |
|---|---|---|---|
| ChatGPT Mobile (iOS/Android) | Native sync (same account) | May lag by 1–2 hours; manual refresh needed after web edits | No |
| Claude (Anthropic) | System prompt (text field) | No dual-field structure; merge both ChatGPT sections into one cohesive paragraph | Yes — rewrite for concision |
| Perplexity Pro | “Custom Persona” (beta) | Max 500 characters; no markdown, no bullet points | Yes — aggressive summarization |
| Ollama (local LLM) | Modelfile SYS instruction |
Requires escaping quotes and newlines; no rich text | Yes — raw string encoding |
| Notion AI | “Custom instructions” (in workspace settings) | Only applies to /ai commands in that workspace; no per-page override | No — paste directly |
| Obsidian + Text Generator Plugin | YAML frontmatter or inline template | Must wrap instructions in triple backticks or define as reusable variable | Yes — templating syntax |
The core principle: Always treat your exported instructions as source-of-truth documentation, not a plug-and-play config file. Each platform demands intentional adaptation — not copy-paste.
Real-world workflow: How a healthcare educator maintains consistency
Dr. Aris Thorne teaches medical AI ethics at Stanford. His custom instructions run 1,200+ words, specifying citation standards, bias mitigation protocols, and patient-communication tiers (e.g., “Explain CRISPR diagnostics to a high-school biology teacher vs. a genetic counselor”). He uses ChatGPT for lecture drafting, Claude for literature synthesis, and Ollama for offline student Q&A simulations.
His solution: A private GitHub repo named ai-persona-standards. In it, he stores:
/v1/main.md: The master Markdown file with his full instructions, versioned with Git tags./platforms/claude-system-prompt.txt: A condensed 327-word version optimized for Claude’s context window./platforms/ollama/Modelfile: With escaped instructions embedded asSYSand a preprocessor script that strips markdown./templates/patient-explainer.json: A reusable JSON schema defining tone, length, and terminology rules for patient-facing outputs.
When updating his instructions after a new NIH guideline release, he edits main.md, runs a Python script that auto-generates the platform-specific variants, commits changes, and deploys updates to his Ollama server via CI/CD. His students receive consistent explanations whether generated on campus Wi-Fi or during a flight with offline Ollama.
Do’s and Don’ts for long-term instruction management
Maintaining portable, reusable instructions requires discipline. These practices prevent fragmentation and security risks:
| Action | Do | Don’t |
|---|---|---|
| Storage | Use encrypted, version-controlled repos (GitHub Private, GitLab, or local encrypted ZIP with strong password) | Store unencrypted in cloud docs, email drafts, or browser bookmarks |
| Content Safety | Remove personally identifiable information (PII) before cross-platform reuse — e.g., replace “I’m a cardiologist at Mass General” with “I’m a board-certified cardiologist at a major academic medical center” | Copy-paste instructions containing workplace names, internal project codes, or patient case details |
| Formatting | Use semantic line breaks (one sentence per line) and avoid complex markdown; prioritize readability over aesthetics | Rely on bold/italics, nested lists, or tables — most platforms ignore or misrender them |
| Updates | Tag versions with dates and change summaries (e.g., “v2.4: Added HIPAA-compliant de-identification clause”) | Overwrite old files without backup or changelog |
| Testing | Validate new instructions by prompting each platform with identical test queries (e.g., “Explain informed consent for AI-assisted diagnosis in 3 sentences”) and comparing outputs | Assume identical text = identical behavior across platforms |
FAQ: Practical questions answered
Can I automate the export process with a browser extension?
Technically yes — but strongly discouraged. Extensions requesting “access to all websites” can capture your session cookies, intercept API keys, or exfiltrate your full instruction set. A 2023 study by the Electronic Frontier Foundation found 62% of “ChatGPT helper” extensions transmitted user data to third-party analytics servers. Manual export remains the only zero-trust method. If automation is essential, use a local, open-source userscript (e.g., Tampermonkey) with audited code that only reads the textarea DOM element and copies to clipboard — never sends data externally.
What happens if I use the same instructions in ChatGPT and Claude? Will it violate terms of service?
No — OpenAI’s Terms of Use (Section 3b) permit users to “use the Services for any lawful purpose,” including adapting outputs for use elsewhere. Anthropic’s Acceptable Use Policy similarly allows “integration of Claude into your own systems.” However, avoid copying *verbatim* outputs generated *by* ChatGPT (e.g., a full research summary) into Claude — that may breach OpenAI’s prohibition on “reprocessing outputs to train competing models.” Your *instructions*, however, are your original input — and fully portable.
My instructions include sensitive work context. Is there a secure way to share them with my team?
Yes — but avoid direct sharing of the full instruction set. Instead, create role-based abstractions: a “Clinical Reviewer” persona (publicly shared) and a “Project X Internal Analyst” persona (stored in a vaulted, access-controlled repo like HashiCorp Vault or 1Password Teams). Share only the abstraction layer — e.g., “All analysts must apply the Clinical Reviewer base + Project X constraints.” This prevents accidental exposure while enabling collaboration.
Conclusion: Treat your instructions as living infrastructure
Your custom instructions are more than preferences — they’re the distilled essence of your expertise, ethics, and workflow. Exporting them isn’t a technical chore; it’s an act of professional sovereignty. It means refusing to let platform lock-in dictate how your knowledge is expressed. It means building resilience against service discontinuations, account compromises, or sudden UI changes. And it means asserting that your AI identity should be as portable, versionable, and auditable as your codebase or research notes.
Start today: Export your instructions using the verified steps above. Store them in an encrypted, dated file. Adapt one section for your second-most-used AI tool — even if it’s just pasting into Notion AI. Then, add a version tag and a one-sentence changelog. That single action transforms a fragile setting into durable infrastructure.
💬 Your turn. Share your instruction management hack, versioning strategy, or cross-platform adaptation tip in the comments — help build collective best practices for human-centered AI continuity.
