القائمة
Migrate from ChatGPT to Claude. Trigger on: ChatGPT export/history/migration, switching from ChatGPT, or folders with conversations-*.json or chat.html files.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
استنادا إلى تصنيف SOC المهني
| name | chatgpt-migrator |
| description | Migrate from ChatGPT to Claude. Trigger on: ChatGPT export/history/migration, switching from ChatGPT, or folders with conversations-*.json or chat.html files. |
| license | Apache-2.0 |
| compatibility | Requires Python 3.8+. Works with Claude Code, Cowork, or any Claude environment with file system access and subagent support. |
| metadata | {"author":"jddmcaulay","version":"1.0.0"} |
You are running a migration pipeline that turns a user's ChatGPT conversation history into useful Claude artefacts. The export can be enormous (hundreds of megabytes, thousands of conversations), so the process is designed to work within context window limits through a multi-stage pipeline.
This skill is fully self-contained. It walks the user through every step from start to finish, including verifying the output with them and showing them exactly how to import everything into Claude.
Users may arrive via two different routes:
Path 1 (Quick Start): They pasted a prompt into ChatGPT to extract its stored memories, then imported those into Claude via claude.com/import-memory or by manually adding them. This is fast but only captures what ChatGPT explicitly memorised, which is typically a small, biased subset.
Path 2 (Deep Migration): They exported their full ChatGPT data and want you to process it. This is what the rest of this skill handles.
Many users will do Path 1 first and then come to Path 2 later when their data export arrives (it can take up to 24 hours). In this case, they already have Claude memories from Path 1. The interview stage (Question 5) will detect this and the synthesis stage will cross-reference the Path 1 memories with the deep analysis results, enriching rather than duplicating.
Read the reference files in this skill's directory to understand the batch analysis prompts and output formats:
references/batch-analysis-prompt.md - The prompt used to analyse each batchreferences/synthesis-prompt.md - The prompt used for final synthesisscripts/preprocessor.py - The Python preprocessor that compresses the raw exportProcessing time depends on the size of the export. Share these estimates with the user early and give regular updates throughout:
| Export size | Batches | Estimated time |
|---|---|---|
| Small (under 200 conversations) | 3-5 batches | 10-15 minutes |
| Medium (200-800 conversations) | 8-15 batches | 20-30 minutes |
| Large (800-1500 conversations) | 15-25 batches | 30-45 minutes |
| Very large (1500+ conversations) | 25-40 batches | 45-60 minutes |
These estimates assume batch analysis is the bottleneck (it is). Preprocessing takes under a minute regardless of size. Synthesis takes 2-5 minutes. The fact-checking interview and import walkthrough add another 5-10 minutes at the end.
After preprocessing, you'll know the exact batch count. Recalculate and share a more precise estimate at that point: roughly 1.5-2 minutes per batch when processing in waves of 3-5.
Large exports can take a long time to process, and sessions may hit context limits mid-run. To handle this, the pipeline maintains a progress.json file in the migration-workspace that tracks exactly where things stand. This is the first file you should check when starting work.
At the very start of every session, look for <export-folder-path>/migration-workspace/progress.json. If it exists, read it and resume from wherever the pipeline left off. If it doesn't exist, start from Stage 0.
The progress file has this structure:
{
"current_stage": 3,
"stage_name": "batch_analysis",
"export_path": "/path/to/export",
"skill_path": "/path/to/skill",
"interview": {
"scope": "everything",
"priority": "understand_me",
"target": "all_platforms",
"claude_experience": "few_months",
"claude_memories_provided": true
},
"preprocessing": {
"completed": true,
"total_batches": 22,
"batch_files": ["batch-001-deep.json", "batch-002-deep.json", "..."]
},
"batch_analysis": {
"completed_batches": ["batch-001-deep.json", "batch-002-deep.json"],
"pending_batches": ["batch-003-deep.json", "batch-004-medium.json", "..."],
"failed_batches": []
},
"synthesis": {
"completed": false,
"files_produced": []
},
"fact_check": {
"completed": false,
"facts_presented": [],
"facts_kept": [],
"facts_discarded": [],
"corrections": []
},
"last_updated": "2026-03-06T14:30:00Z"
}
Update this file after every meaningful step: after the interview, after preprocessing, after each wave of batch analysis completes, after synthesis, after the fact-check interview. Write it with json.dumps(..., indent=2) so it's human-readable.
When resuming:
analysis-NNN.json files already exist in the migration-workspace. Any batch with a corresponding analysis file is done. Process only the remaining batches.This means the user can hit compaction, start a new session, say "continue the migration", and the skill will pick up right where it left off without re-processing anything or re-asking interview questions.
First, check if migration-workspace/progress.json exists in the workspace. If it does, read it and skip to whatever stage is indicated. If the user says something like "continue", "keep going", or "pick up where we left off", this is your cue to look for the progress file.
If no progress file exists, look in the user's workspace folder for signs of a ChatGPT export. The telltale files are:
conversations-000.json, conversations-001.json, etc. (the actual conversation data)chat.html (an HTML rendering of all conversations, not needed for processing)user.json (basic account info)user_settings.json (settings and preferences)export_manifest.json (file listing)If you find these files, confirm with the user that this is their ChatGPT export and move to Stage 1.
The user might not have their export yet, or they might have selected the wrong folder. Handle this warmly and practically. Use AskUserQuestion to ask:
"I can't see a ChatGPT export in this folder. Where are you in the process?"
If they haven't exported yet, walk them through it step by step:
Then offer Path 1 as something they can do right now while they wait: "While you're waiting for the export, you can do the quick migration. This takes 5 minutes and gets your core ChatGPT context into Claude immediately." Explain Path 1 (the ChatGPT memory extraction prompt from the Two Migration Paths section above) and walk them through it.
If they've exported but it's in a different folder, ask them to select the correct folder or tell you the path. If the tool supports directory selection (e.g., Cowork's request_cowork_directory), use that.
If they're waiting for the email, offer Path 1 as above. Also let them know they can come back to this conversation (or start a new one) once the export arrives.
If they just want the quick migration, walk them through Path 1 entirely:
The key principle: never leave the user stuck. Every path should lead somewhere useful, even if they don't have their export data yet.
Before processing anything, have a brief conversation with the user to understand what they want. Use the AskUserQuestion tool for this. Ask about:
Question 1: Scope - "What would you like to extract from your ChatGPT history?"
Question 2: Priority - "What matters most to you in the migration?"
Question 3: Target - "Where will you primarily use Claude?"
Question 4: Claude experience - "What's your Claude experience so far?"
This shapes the tone and depth of the import walkthrough. New users need more guidance on Claude's features, memory, and projects. Experienced users mainly need their ChatGPT context ported over efficiently.
Question 5: Existing Claude memories - "Do you have memories saved in Claude that we should cross-reference with your ChatGPT history?"
If they have existing Claude memories, save them to the migration-workspace as existing-claude-memories.txt. These will be cross-referenced during synthesis to identify confirmed facts, outdated information, and new discoveries.
After the interview, write (or update) progress.json in the migration-workspace with the interview answers and set current_stage to 2. This way, if the session is interrupted, the next session won't re-ask all the questions.
Run the preprocessor script to compress the raw export into manageable batches:
python3 <skill-path>/scripts/preprocessor.py "<export-folder-path>" "<export-folder-path>/migration-workspace"
The preprocessor applies recency weighting automatically:
This produces:
00-overview.json - High-level stats with recency breakdown and separate recent vs all-time keyword analysis01-title-index.json - Every conversation title with date, word count, recency era, and tier02-user-profile.json - Account info from user.jsonbatch-NNN-{deep|medium|light}.json - Conversation content in context-window-sized batches, sorted recent-firstRead 00-overview.json first and share the key stats with the user. This helps them understand the scope and sets expectations.
After sharing the stats, give the user a time estimate. Now that you know the exact batch count, calculate: roughly 1.5-2 minutes per batch in waves of 3-5, plus 2-5 minutes for synthesis, plus 5-10 minutes for fact-checking and import walkthrough. Tell the user something like: "You've got 22 batches, so the analysis phase will take roughly 35-45 minutes. I'll give you updates as each wave finishes."
After preprocessing completes, update progress.json: set current_stage to 3, preprocessing.completed to true, and list all batch files. This is critical because preprocessing is deterministic and never needs to be re-run.
This is the core processing stage and the longest part of the pipeline. For each batch file, you need to extract structured insights. The batches come in three tiers:
Deep batches (conversations with 200+ user words): Full message content included. These are the richest source of personal context, preferences, and patterns. Process these carefully.
Medium batches (50-200 user words): User messages only. Good for identifying topics, recurring needs, and professional context.
Light batches (under 50 words): Metadata only (title, date, model). Useful for understanding breadth of usage and topic distribution, but not much else.
Use subagents (the Task tool) to process batches in parallel, but limit each wave to 3-5 subagents at a time. This keeps wait times manageable (each wave takes roughly 1.5-2 minutes) and gives the user regular progress updates rather than one long silence.
For each batch, spawn a subagent with the batch analysis prompt from references/batch-analysis-prompt.md, adapted for the batch tier.
The subagent should read the batch file and produce a structured analysis saved to the migration-workspace. Name the output files analysis-NNN.json to match their batch numbers.
Process deep batches first (they take longest and contain the most value), then medium, then light.
Important: Don't try to read the batch files directly into your own context. They're 150-240KB each. Use subagents so each batch gets a fresh context window.
progress.json with the newly completed batchesThe progress update after each wave is important. Keep it brief but informative: mention a finding or two so the user knows the analysis is substantive, and always include the updated time estimate.
After each wave of subagents completes, update progress.json: move those batches from pending_batches to completed_batches and update last_updated. This way, if the session hits compaction mid-way through batch analysis, the next session can see exactly which batches are done (it can also verify by checking which analysis-NNN.json files exist on disk).
When resuming mid-batch-analysis: list the analysis-*.json files in the migration-workspace, compare against the full batch list from preprocessing, and only process the missing ones.
Once all batch analyses are complete, update progress.json with current_stage set to 4.
Tell the user: "All batches analysed. Now synthesising everything into your migration files. This takes 2-5 minutes."
Read all the analysis-NNN.json files. These are much smaller than the raw batches (typically 2-5KB each). Combine the insights with the user's interview answers (from progress.json if resuming) to produce the final outputs.
Use the synthesis prompt from references/synthesis-prompt.md as your guide. The outputs are:
claude-profile.md)A comprehensive "about me" context document. This covers: who they are, what they do professionally, their interests and hobbies, their communication style, their values and priorities, key life context (location, relationships, etc. - only what they've naturally shared in conversations, never inferred or assumed).
This should read like a friend describing them to someone who's about to help them, not like a clinical dossier.
claude-memories.md)Discrete facts and preferences extracted from conversations, formatted as a list. These are things Claude should remember across conversations. Examples: "Prefers British English", "Works at [company] as [role]", "Training for a marathon", "Allergic to [thing]", "Prefers concise responses".
Aim for 30-100 memories depending on how much is in the history. Quality over quantity. Each memory should be a single, specific, useful fact.
claude-system-prompt.md)A ready-to-use system prompt for claude.ai, Cowork, Claude Code, or the API, tailored to this specific user. It should encode their communication preferences, key context, and any specific instructions that would make Claude more useful to them from the first message.
claude-skills.md)Based on patterns in how they used ChatGPT, suggest 3-5 Cowork skills that would be valuable. For each: a name, what it would do, why it would help them specifically, and a rough outline of what the SKILL.md would contain. Don't build the full skills, just give enough detail that the user (or Claude) could build them later.
claude-integrations.md)Based on the tools, services, and APIs that appear in their ChatGPT history (weighted towards recent usage), recommend MCP servers, Claude connectors, and integrations they should set up. For each recommendation:
Common mappings to look for:
Only recommend integrations where there's clear evidence in their history. Don't pad with generic suggestions. If they only used ChatGPT for conversation and writing, it's fine to have a short list or even say "No specific integrations recommended based on your usage patterns."
Important: Only recommend official MCP servers and integrations. Only suggest MCP servers published by the service provider themselves (e.g., the official GitHub MCP server by GitHub, the official Slack MCP server by Slack) or first-party Claude connectors available in Claude's settings. Never recommend unofficial or community-built MCP servers. If no official integration exists for a service the user relies on, note it as a gap rather than pointing to a third-party alternative.
topic-index.md)A curated index of their conversation history organised by theme/topic. For each topic: a brief description, how many conversations touched on it, the date range, and the 3-5 most notable conversation titles. This serves as a reference so they know what's in their archive.
migration-summary.md)A brief, readable summary of the whole migration: what was processed, what was found, what was produced, and suggestions for next steps. This is the document they'll read first.
memory-crossref.md, only if user provided Claude memories)If the user already has Claude memories, produce a cross-reference showing:
This stage is critical. Before delivering anything, present the user with up to 10 key facts from the synthesis and ask them to confirm, correct, or discard each one.
The analysis is working from conversation fragments spanning years. It's easy to get things wrong: outdated job titles, misunderstood relationships, incorrect locations, confused project details. The user is the only person who can verify whether the synthesis got things right.
Select up to 10 facts to verify. Choose the ones that are:
Present them using AskUserQuestion, grouping into 2-3 rounds of questions. For each fact, give the user the option to:
Example: "The analysis found you're currently the founder of Jack & Jill AI, an AI-powered recruitment platform. Is this correct?"
Apply the corrections. After the fact-check interview, update all affected output files (profile, memories, system prompt) to reflect what the user confirmed, corrected, or discarded. This may mean rewriting sections of the profile or removing memories.
Update progress.json with the fact-check results: which facts were presented, which were kept, discarded, or corrected.
Prioritise these categories:
If the synthesis only found a handful of substantive facts (small export, narrow scope), you can do fewer than 10. The point is verification, not bureaucracy.
Save all output files to the migration-workspace folder and present them to the user with links.
Present each file with a one-line description of what it is. Don't give lengthy explanations; the user can read the files themselves.
This is the most important part. Walk the user through exactly how to get their migration data into Claude, step by step. Tailor the walkthrough to whatever they said in the interview (Question 3) about where they use Claude.
For Claude.ai users:
System prompt / custom instructions:
claude-system-prompt.mdMemories:
claude-memories.md. Claude will add them to its memory over the course of the conversation.Profile as a Project:
claude-profile.md as a file in the projectFor Cowork users:
System prompt:
claude-system-prompt.md can be added to your Cowork preferencesProfile:
claude-profile.md in a folder that Cowork has access toSkills:
claude-skills.md for suggested skills to buildFor Claude Code users:
System prompt as CLAUDE.md:
claude-system-prompt.md as CLAUDE.md in your home directory or project rootMemories:
CLAUDE.md fileclaude-profile.md somewhere accessible and reference it when neededSkills:
claude-skills.md can be built as Claude Code slash commands or skillsFor all users:
claude-integrations.md lists MCP servers and Claude connectors to install based on the tools and services in your history. Review the list and install any that look useful.topic-index.md is for your reference. Keep it somewhere handy if you want to look back at what you discussed with ChatGPT.migration-summary.md is a one-time read. It summarises what was processed and found.memory-crossref.md was produced, review the "potentially outdated" section and update or remove those Claude memories.After walking through the import steps, ask the user if they'd like to:
After delivery, update progress.json with current_stage set to 6 and synthesis.completed set to true, with the list of files produced. This marks the migration as complete.