A step-by-step framework for migrating your Anthropic Claude Projects to OpenAI ChatGPT Custom GPTs — without losing the "soul" of your assistant.
- Executive Summary
- Who This Is For
- Platform Comparison
- Terminology Mapping
- Migration Phases
- Common Pitfalls
- Templates
- Contributing
- License
Anthropic's Claude Projects and OpenAI's ChatGPT Custom GPTs serve similar purposes — persistent, specialized AI assistants with custom instructions and reference material — but they have fundamentally different architectures under the hood.
This guide provides a systematic, repeatable process for migrating any Claude Project into a ChatGPT Custom GPT. It covers:
- Extracting the behavioral logic, persona, and constraints from your Claude Project
- Converting Claude-specific syntax and patterns into ChatGPT-native equivalents
- Optimizing your knowledge files for ChatGPT's vector search (RAG) pipeline
- Validating that the migrated GPT behaves as expected
Note: This guide is platform-version-aware as of March 2026. Both Claude and ChatGPT evolve rapidly. Check the CHANGELOG.md for updates.
- Teams or individuals who built specialized assistants in Claude Projects and need to replicate them in ChatGPT
- Organizations standardizing on OpenAI's platform
- Developers maintaining multi-platform AI assistants
- Anyone evaluating the differences between the two platforms
Understanding the architectural differences is critical before migrating.
| Dimension | Claude Projects | ChatGPT Custom GPTs |
|---|---|---|
| Instruction Limit | ~12,000 tokens (Project Instructions) | 8,000 characters (~2,000 tokens) in "Instructions" field |
| Knowledge Upload | Up to 5 files, each up to 30 MB | Up to 20 files, each up to 512 MB |
| Knowledge Retrieval | Full-context window injection (for small files) or chunked retrieval | Vector search (RAG) — retrieves relevant chunks, not full files |
| Supported File Types | PDF, TXT, CSV, MD, code files | PDF, TXT, CSV, MD, DOCX, PPTX, JSON, code files, images |
| Conversation Memory | Per-project conversation history | Per-GPT conversation history |
| Tool Access | Artifacts, Analysis tool | Web Search, DALL-E, Code Interpreter, Actions (API calls) |
| Sharing Model | Team/Organization sharing | Public GPT Store, link sharing, or private |
| API/Actions | MCP Servers (Model Context Protocol) | OpenAPI-schema-based Actions |
| Prompt Style | Responds well to XML-structured prompts, constitutional framing | Responds well to direct instruction, markdown structure |
This is the single most important difference to understand:
- Claude Projects inject your uploaded files directly into the context window. The model "sees" the full content (up to context limits). This means Claude can reason over the entire document at once.
- ChatGPT Custom GPTs use vector search (RAG). Your files are chunked, embedded, and stored. At query time, only the most relevant chunks are retrieved. This means the model only sees fragments of your documents per query.
Migration implication: Files that relied on Claude reading everything at once must be restructured so that each section is self-contained and findable by keyword search.
Use this reference when translating between platforms.
| Claude Concept | ChatGPT Equivalent | Notes |
|---|---|---|
| Project | Custom GPT | Top-level container |
| Project Instructions | GPT Instructions (System Prompt) | Character limit is much smaller in ChatGPT |
| Project Knowledge (Files) | GPT Knowledge (Files) | Different retrieval mechanism (see above) |
| Artifacts | Code Interpreter output / Canvas | Not a 1:1 match; Canvas is closest for documents |
| Analysis Tool | Code Interpreter (Advanced Data Analysis) | Functionally similar |
| MCP Servers | Actions (OpenAPI) | Very different integration model |
| Conversation Styles | Custom Instructions (user-level) | ChatGPT has user-level defaults separate from GPT config |
XML tag prompting (<instructions>) |
Markdown headers / delimiters | ChatGPT doesn't benefit from XML structure |
| Constitutional AI constraints | System prompt "Rules" / "Constraints" section | Must be explicit in ChatGPT; not built into the model |
Human: / Assistant: turns |
user / assistant roles |
Only relevant if working via API |
Goal: Extract the complete "soul" of your Claude Project — every behavior, constraint, and personality trait — into a platform-neutral format.
- Open your Claude Project
- Navigate to Project Settings → Instructions
- Copy the full text of your Project Instructions into a local file:
source-instructions.md
Create a manifest of all uploaded files:
| # | Filename | Type | Size | Purpose | Priority |
|---|----------|------|------|---------|----------|
| 1 | company-policies.pdf | PDF | 2.1 MB | HR policy reference | High |
| 2 | product-catalog.csv | CSV | 450 KB | Product lookup | High |
| 3 | style-guide.md | MD | 12 KB | Writing tone rules | Medium |Template available:
templates/knowledge-inventory.md
Search your instructions for these Claude-specific patterns and flag them for conversion:
| Pattern | Example | Action Required |
|---|---|---|
| XML tag structure | <rules>, <persona>, <context> |
Replace with Markdown headers (## Rules, ## Persona) |
| Claude self-references | "As Claude, I should..." | Replace with "As this GPT, you should..." or remove |
| Anthropic references | "per Anthropic's guidelines" | Remove or replace with platform-neutral language |
| Constitutional framing | "I will be helpful, harmless, and honest" | Convert to explicit behavioral rules |
| Artifact requests | "Create an artifact with..." | Replace with "Use Code Interpreter to..." or "Generate..." |
| MCP tool references | "Use the [tool] MCP server" | Replace with Actions configuration or remove |
| Thinking tags | <thinking>, <reflection> |
Convert to "Before responding, reason through..." |
| Token/context awareness | "Given your context window..." | Remove — ChatGPT doesn't expose this to GPTs |
Document each of these dimensions from your Claude Project:
## Behavioral Blueprint
### Identity & Persona
- Name/Role: ___
- Tone: ___
- Expertise domain: ___
### Core Behaviors (What it MUST do)
1. ___
2. ___
### Constraints (What it must NOT do)
1. ___
2. ___
### Output Formatting Rules
- Default format: ___
- Special formats: ___
### Interaction Patterns
- How it handles ambiguity: ___
- How it handles out-of-scope questions: ___
- Escalation behavior: ___
### Static Variables
- Key dates: ___
- URLs: ___
- Names/Identifiers: ___Template available:
templates/behavioral-blueprint.md
Goal: Transform your knowledge files from "full-context readable" (Claude) to "chunk-searchable" (ChatGPT).
This is the most labor-intensive phase and the one most likely to cause quality loss if rushed.
Compare all uploaded files for redundant content:
- List every distinct "fact" or "rule" across all files
- Identify duplicates or contradictions
- Consolidate into the minimum number of files
Rule of thumb: Fewer, denser files outperform many scattered files in ChatGPT's RAG.
ChatGPT's RAG indexes text content. Markdown is the most "RAG-friendly" format because:
- Headers create natural chunk boundaries
- Structure is preserved in plain text
- No parsing artifacts (unlike PDF extraction)
Conversion priority:
| Source Format | Action |
|---|---|
| PDF (text-based) | Convert to .md — preserve all headings and structure |
| PDF (scanned/image) | OCR first, then convert to .md |
| Excel / CSV | Convert to .md tables or keep as .csv if purely tabular data |
| Word (.docx) | Convert to .md |
| Plain text (.txt) | Add Markdown headers for structure |
Already .md |
Review and optimize headers |
Apply these formatting rules to every knowledge file:
# TOPIC: [High-Level Subject]
## SECTION: [Specific Subtopic]
### Context
[Brief description of when this section is relevant]
### Content
[The actual information]
### Related Sections
- See also: [TOPIC: Other Subject] > [SECTION: Related Subtopic]Why this works: ChatGPT's RAG splits documents into chunks (typically ~800 tokens). By adding explicit # TOPIC: and ## SECTION: headers, you ensure:
- Each chunk has a clear, searchable label
- The retriever can match user queries to section headers
- Cross-references help the model find related information across chunks
For critical information that must be found, add redundant keyword anchors:
## SECTION: Return Policy (Refund Rules, Money Back, Exchange Policy)
Our return policy allows returns within 30 days of purchase...The parenthetical keywords increase the chance that queries like "can I get a refund?" will retrieve this section, even if the user doesn't say "return policy."
Create a single _INDEX.md file that serves as a table of contents across all knowledge files:
# Knowledge Base Index
## Files in This Knowledge Base
1. **company-policies.md** — HR policies, PTO rules, expense guidelines
2. **product-catalog.md** — Full product listing with SKUs, prices, descriptions
3. **style-guide.md** — Writing tone, formatting rules, brand voice
## Quick Reference
- For pricing questions → product-catalog.md > SECTION: Pricing
- For HR questions → company-policies.md > SECTION: [relevant topic]
- For writing help → style-guide.md > SECTION: Tone & VoiceThis index file helps ChatGPT's RAG understand the structure of your knowledge base and route queries more effectively.
Goal: Rewrite your Claude Project Instructions into ChatGPT's system prompt format, respecting the 8,000-character limit.
ChatGPT Custom GPTs respond best to this instruction format:
# Role
You are [name/role]. You specialize in [domain].
# Core Behavior
- Always [behavior 1]
- Always [behavior 2]
- Never [constraint 1]
- Never [constraint 2]
# Knowledge Base Usage
You have access to uploaded files containing [description].
When answering questions about [topic], ALWAYS search your knowledge files first.
If the answer is not in your files, say: "[exact fallback message]"
# Output Format
- Default response format: [format]
- For [specific query type], use: [specific format]
- Always include [required element] in responses
# Conversation Flow
1. When the user asks [type of question], respond by...
2. When uncertain, ask for clarification before answering
3. If asked about [out-of-scope topic], respond with: "[redirect message]"
# Rules
1. [Hard constraint 1]
2. [Hard constraint 2]
3. [Hard constraint 3]| Claude Pattern | ChatGPT Equivalent |
|---|---|
<instructions>...</instructions> |
# Instructions (markdown header) |
<rules>...</rules> |
# Rules (markdown header + numbered list) |
<persona>You are a...</persona> |
# Role\nYou are a... |
Think step by step inside <thinking> tags |
Before answering, reason through the problem internally |
Use artifacts for long content |
Use Code Interpreter for data analysis or just output directly |
If the human asks... |
If the user asks... |
As an AI assistant made by Anthropic... |
Remove entirely or replace with You are a specialized assistant... |
Be helpful, harmless, and honest |
Convert to specific rules: Never provide harmful content. Always cite sources. |
| Nested XML structures | Flatten into markdown headers with indented bullet lists |
Claude Project Instructions can be ~12,000 tokens. ChatGPT Instructions are limited to 8,000 characters (~2,000 tokens). If your instructions exceed this:
Strategy 1: Split into Instructions + Knowledge File
- Put behavioral rules and persona in the Instructions field
- Put reference data, examples, and detailed procedures in a Knowledge File called
system-context.md - Add to Instructions:
Refer to the file "system-context.md" for detailed procedures and examples.
Strategy 2: Compress and Prioritize
- Remove redundant phrasing
- Use terse, imperative statements instead of full sentences
- Prioritize constraints (what NOT to do) over positive instructions (models are better at following prohibitions)
- Remove instructions that describe default LLM behavior (e.g., "be helpful" — it already is)
Strategy 3: Use Cascading Context
- Put the most critical rules directly in Instructions
- Put supporting context in Conversation Starters (the model reads these as examples)
- Put reference material in Knowledge files
Goal: Fill out every field in the ChatGPT "Configure" tab with optimized content.
| Field | Content | Character/Item Limit | Tips |
|---|---|---|---|
| Name | [Your GPT Name] |
50 chars | Be specific, not generic. "Acme HR Policy Advisor" > "HR Helper" |
| Description | [What this GPT does and who it's for] |
300 chars | This is public-facing. Lead with the value proposition |
| Instructions | [Converted system prompt from Phase 3] |
8,000 chars | See Phase 3 for structure |
| Conversation Starters | 4 example prompts | 4 items | Pick queries that showcase different capabilities |
| Knowledge | [Optimized files from Phase 2] |
20 files, 512 MB each | Upload the master index file first |
| Capabilities | Toggle: Web Search, DALL-E, Code Interpreter | 3 toggles | Only enable what's needed — extra capabilities can cause confusion |
| Actions | [OpenAPI schemas for external APIs] |
No hard limit | Only if your Claude Project used MCP servers |
Good starters should:
- Demonstrate a core capability — show what the GPT is best at
- Be specific enough to trigger knowledge retrieval — generic prompts won't showcase RAG
- Cover different use cases — don't repeat the same type of query
- Be written from the user's perspective — natural language, not commands
Example:
Starter 1: "What is our return policy for items purchased more than 30 days ago?"
Starter 2: "Help me draft a professional email declining a vendor proposal"
Starter 3: "Compare the features of Product X vs Product Y"
Starter 4: "What are the PTO accrual rules for part-time employees?"
| Capability | Enable If... | Disable If... |
|---|---|---|
| Web Search | GPT needs current information (news, prices, live data) | All answers come from knowledge files; web results could contradict your data |
| DALL-E | GPT generates images as part of its workflow | No image generation needed; prevents accidental image generation |
| Code Interpreter | GPT analyzes data, generates charts, processes files | Purely conversational GPT; prevents unnecessary code execution |
Goal: Verify the migrated GPT behaves identically (or acceptably close) to the original Claude Project.
Run these test categories against your new GPT:
| Test Category | What to Verify | How to Test |
|---|---|---|
| Knowledge Retrieval | GPT finds and uses uploaded files | Ask a question only answerable from your knowledge files |
| Persona Consistency | GPT maintains correct tone and role | Have a multi-turn conversation; check for persona drift |
| Constraint Adherence | GPT follows "never do X" rules | Deliberately try to make it break a rule |
| Output Format | GPT uses correct formatting | Request outputs that should trigger specific formats |
| Edge Cases | GPT handles ambiguity correctly | Ask vague or multi-interpretation questions |
| Hallucination Resistance | GPT admits knowledge gaps | Ask about topics not in your files but plausibly in-scope |
| Multi-turn Memory | GPT maintains context across turns | Reference earlier parts of the conversation |
For each migrated GPT, create and run these three specific tests:
Test 1: Deep Retrieval
Ask a question that requires finding a specific detail buried deep in your knowledge files. If the GPT answers correctly, RAG is working. If it hallucinates, your file structure needs optimization (return to Phase 2).
Test 2: Constraint Boundary
Ask the GPT to do something your instructions explicitly prohibit. A properly configured GPT will refuse or redirect. If it complies, your constraints need strengthening.
Test 3: Graceful Ignorance
Ask about a topic that sounds like it could be in your knowledge base but isn't. A well-configured GPT will say "I don't have information about that" rather than guessing.
Run 10 identical prompts through both the original Claude Project and the new ChatGPT GPT. Score each response:
| Prompt | Claude Score (1-5) | ChatGPT Score (1-5) | Gap | Notes |
|---|---|---|---|---|
| [Prompt 1] | ||||
| [Prompt 2] | ||||
| ... |
Acceptable gap: Scores within 1 point are normal due to model differences. Gaps of 2+ indicate a migration issue that needs fixing.
Template available:
templates/qa-scorecard.md
Cause: ChatGPT's RAG didn't retrieve relevant chunks because the file lacked clear headers or keyword anchors.
Fix: Return to Phase 2. Add # TOPIC: and ## SECTION: headers. Add parenthetical keyword synonyms.
Cause: Claude and ChatGPT have different "default personalities." Claude is more cautious and formal; ChatGPT is more conversational and eager.
Fix: Add explicit tone instructions: "Maintain a professional, measured tone. Do not use exclamation marks. Do not volunteer information beyond what was asked."
Cause: The GPT's general knowledge is filling gaps instead of retrieving from files.
Fix: Add to Instructions: "For questions about [domain], ONLY use information from your uploaded knowledge files. If you cannot find the answer in your files, say 'I don't have that information in my reference materials.' NEVER guess or use general knowledge for [domain]-specific questions."
Cause: Claude supports much longer instructions than ChatGPT.
Fix: Use the Split Strategy from Phase 3 — put detailed rules in a system-context.md knowledge file and reference it from Instructions.
Cause: Claude's MCP protocol and ChatGPT's Actions use completely different integration models. Fix: You'll need to rewrite integrations as OpenAPI schemas. See OpenAI's Actions documentation.
Cause: Different context window management between Claude and ChatGPT.
Fix: Add to Instructions: "At the start of each response, briefly restate the user's core question or goal to maintain conversation coherence."
This repository includes ready-to-use templates in the templates/ directory:
| Template | Purpose |
|---|---|
knowledge-inventory.md |
Catalog your Claude Project's knowledge files |
behavioral-blueprint.md |
Extract the complete persona and behavior spec |
gpt-blueprint.md |
Fill-in-the-blank GPT configuration worksheet |
qa-scorecard.md |
Side-by-side quality comparison scorecard |
instruction-conversion-checklist.md |
Checklist for converting Claude instructions to ChatGPT |
knowledge-file-template.md |
Optimized structure for ChatGPT knowledge files |
Contributions are welcome. If you've migrated a Claude Project and discovered new patterns, pitfalls, or optimizations:
- Fork this repository
- Create a feature branch (
git checkout -b add-new-pattern) - Add your contribution
- Submit a Pull Request
Please follow the existing formatting conventions and include practical examples where possible.
This project is licensed under the MIT License — see the LICENSE file for details.
Built by AuthorityGate
Making AI platform migrations less painful, one guide at a time.