Last updated: March 16, 2026

Export your Claude Project’s instructions and uploaded files, then restructure them as a Custom GPT system prompt and knowledge documents. Copy project instructions directly into the GPT’s “Instructions” field, convert uploaded reference files into the GPT’s knowledge base, and remap conversation starters to match ChatGPT’s format. This guide covers the full export-to-import workflow with code examples for automating the conversion.

Prerequisites

Before you begin, make sure you have the following ready:

• A computer running macOS, Linux, or Windows
• Terminal or command-line access
• Administrator or sudo privileges (for system-level changes)
• A stable internet connection for downloading tools

Step 1: Understand the Platform Differences

Claude Projects store knowledge as files, instructions, and context that the AI can reference during conversations. You typically populate these with project documentation, coding standards, API references, and custom instructions that shape how Claude responds to your queries.

ChatGPT Custom GPTs work differently. You configure them through a combination of instructions (the system prompt), uploaded knowledge files, and conversation starters. The knowledge becomes part of the GPT’s context window and retrieval system, but the structure differs from Claude’s file-based approach.

The key challenge involves converting your Claude Project’s accumulated knowledge into a format that works effectively in the Custom GPT environment.

Step 2: Exporting Your Claude Project Knowledge

Before you can transfer knowledge, you need to export it from Claude Projects. The process involves several components:

Retrieving Project Instructions

Your Claude Project likely contains custom instructions that define how the AI behaves. Find these in your project configuration:

# claude_project_instructions.md
You are a Python expert specializing in FastAPI development.
Always use type hints, write docstrings, and follow PEP 8.
When writing async code, prefer asyncio over threading.

Copy these instructions into a text file you can later paste into your Custom GPT’s instructions field.

Exporting Knowledge Files

Claude Projects typically store knowledge in markdown files, text files, or JSON. Identify your key knowledge files:

# Common locations in a Claude Project
project/
├── docs/
│   ├── api-reference.md
│   ├── coding-standards.md
│   └── architecture.md
├── prompts/
│   ├── review-instructions.txt
│   └── test-generation.txt
└── context/
    ├── project-background.md
    └── team-context.md

Gather all these files. You will upload them to your Custom GPT’s knowledge base.

Step 3: Configure Your Custom GPT

Now that you have exported your knowledge, set up the Custom GPT to use it effectively.

Setting Instructions

Paste your Claude Project instructions into the Instructions field of your Custom GPT. Format them clearly:

You are an expert software developer specializing in Python and FastAPI.

Your expertise includes:
- Writing type-annotated Python code with full type hints
- Creating FastAPI endpoints following REST best practices
- Writing detailed docstrings using Google style
- Implementing proper error handling and logging
- Writing pytest tests with fixtures and mocks

When answering questions:
1. Provide working code examples
2. Include type annotations
3. Add docstrings to all functions and classes
4. Suggest test cases for critical functions

Uploading Knowledge Files

Upload your exported knowledge files to the Knowledge section. ChatGPT supports markdown, PDF, text, and other document formats. Prioritize files that contain:

• Project-specific documentation

• Coding standards and conventions

• API documentation

• Architecture decisions

• Team processes and workflows

For the best results, organize your files logically. A folder structure like this works well:

knowledge/
├── 01-project-overview/
│   └── background.md
├── 02-coding-standards/
│   ├── python-style.md
│   ├── testing-standards.md
│   └── code-review-guidelines.md
└── 03-api-reference/
    └── endpoints.md

Step 4: Preserving Context Through Conversation Design

Custom GPTs do not maintain persistent context between sessions like Claude Projects do. You compensate for this through careful conversation design.

Creating Effective Conversation Starters

Conversation starters help users tap into your knowledge immediately:

• “Help me write a FastAPI endpoint for user authentication”

• “Review my Python code for type safety”

• “Create pytest fixtures for testing database operations”

• “Explain our API error handling approach”

Each starter should trigger a specific area of your transferred knowledge.

Building Reference Prompts

Include reference prompts in your instructions that users can invoke:

You have access to the following knowledge bases:
- Coding standards in the uploaded files under coding-standards/
- API documentation in endpoints.md
- Project background in background.md

When users ask about code style, refer to coding-standards/
When users ask about APIs, refer to endpoints.md

Migrating Code Analysis Patterns

If your Claude Project includes code analysis patterns, convert them to Custom GPT instructions:

Claude Project pattern:

When reviewing code, check for:
1. Type hint usage
2. Error handling completeness
3. Resource cleanup (try/finally or context managers)
4. Logging implementation
5. Security considerations

Custom GPT instruction:

When reviewing code, always check these five areas and provide specific feedback:
1. Type Hints: Are all function parameters and return types annotated?
2. Error Handling: Are exceptions caught and handled appropriately?
3. Resources: Are files, connections, and handles properly cleaned up?
4. Logging: Is there appropriate logging for debugging and monitoring?
5. Security: Are inputs validated, credentials handled securely, and SQL queries parameterized?

Step 5: Transferring Prompt Engineering Knowledge

If you have refined prompts in Claude Projects, adapt them for the Custom GPT format:

# Claude Project prompt file: generate_tests.py
"""
Generate pytest tests for the given Python code.

Requirements:
- Use pytest fixtures for setup
- Mock external dependencies
- Test both success and error cases
- Include descriptive test names following pytest conventions
"""

In your Custom GPT instructions, convert this to:

When generating tests:
- Create pytest tests using fixtures for setup
- Mock external API calls and database connections
- Cover both successful and error scenarios
- Use descriptive test names that explain what is being tested
- Include docstrings explaining each test's purpose

Step 6: Automate the Transfer Process

For ongoing synchronization between Claude Projects and Custom GPTs, consider a simple script:

#!/usr/bin/env python3
# sync_to_gpt.py
import os
import shutil
from datetime import datetime

def export_claude_project(source_dir, output_dir):
    """Export Claude Project files for Custom GPT upload."""

    os.makedirs(output_dir, exist_ok=True)

    # Copy knowledge files
    for root, dirs, files in os.walk(source_dir):
        for file in files:
            if file.endswith(('.md', '.txt', '.json', '.py')):
                src = os.path.join(root, file)
                rel_path = os.path.relpath(src, source_dir)
                dst = os.path.join(output_dir, rel_path)

                os.makedirs(os.path.dirname(dst), exist_ok=True)
                shutil.copy2(src, dst)
                print(f"Copied: {rel_path}")

    # Generate sync metadata
    with open(os.path.join(output_dir, 'sync_info.txt'), 'w') as f:
        f.write(f"Last synced: {datetime.now().isoformat()}\n")
        f.write(f"Source: {source_dir}\n")

if __name__ == "__main__":
    export_claude_project('./my-claude-project', './gpt-knowledge')

Run this script periodically to keep your Custom GPT knowledge current with your Claude Project.

Step 7: Validating Your Transfer

After configuring your Custom GPT, test it thoroughly:

1. Ask questions that would trigger specific knowledge areas in Claude

2. Verify responses reference the correct files and conventions

3. Check tone and style matches your original Claude Project instructions

4. Test edge cases where knowledge areas might overlap

Iterate on your instructions based on test results. Custom GPTs often need instruction refinement to match Claude’s behavior precisely.

Step 8: When Custom GPTs Work Well

Custom GPTs excel at providing consistent responses based on uploaded documentation. They work particularly well for:

• Team knowledge bases that rarely change

• Coding standards and style guides

• API documentation and usage examples

• Onboarding materials for new team members

However, Custom GPTs lack Claude Projects’ ability to execute code, run tests, or interact with files directly. For tasks requiring execution, you may need to keep using Claude alongside your Custom GPT.

Troubleshooting

Configuration changes not taking effect

Restart the relevant service or application after making changes. Some settings require a full system reboot. Verify the configuration file path is correct and the syntax is valid.

Permission denied errors

Run the command with sudo for system-level operations, or check that your user account has the necessary permissions. On macOS, you may need to grant terminal access in System Settings > Privacy & Security.

Connection or network-related failures

Check your internet connection and firewall settings. If using a VPN, try disconnecting temporarily to isolate the issue. Verify that the target server or service is accessible from your network.

Frequently Asked Questions

How long does it take to transfer claude project knowledge to chatgpt custom?

For a straightforward setup, expect 30 minutes to 2 hours depending on your familiarity with the tools involved. Complex configurations with custom requirements may take longer. Having your credentials and environment ready before starting saves significant time.

What are the most common mistakes to avoid?

The most frequent issues are skipping prerequisite steps, using outdated package versions, and not reading error messages carefully. Follow the steps in order, verify each one works before moving on, and check the official documentation if something behaves unexpectedly.

Do I need prior experience to follow this guide?

Basic familiarity with the relevant tools and command line is helpful but not strictly required. Each step is explained with context. If you get stuck, the official documentation for each tool covers fundamentals that may fill in knowledge gaps.

Can I adapt this for a different tech stack?

Yes, the underlying concepts transfer to other stacks, though the specific implementation details will differ. Look for equivalent libraries and patterns in your target stack. The architecture and workflow design remain similar even when the syntax changes.

Where can I get help if I run into issues?

Start with the official documentation for each tool mentioned. Stack Overflow and GitHub Issues are good next steps for specific error messages. Community forums and Discord servers for the relevant tools often have active members who can help with setup problems.

Related Articles

• How to Transfer Claude Project Knowledge to ChatGPT Custom (2)
• Transfer ChatGPT Custom GPTs to Claude Projects Step by Step
• Claude vs ChatGPT for Building Custom ESLint Rules for React
• Switching from Windsurf to Cursor How to Transfer Project
• How to Transfer Notion AI Workflows to Claude Projects 2026

Built by theluckystrike — More at zovo.one