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.

Understanding 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.

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.

Configuring 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 comprehensive 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:

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

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:

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?

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

Automating 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.

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.

When Custom GPTs Work Well

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

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.

Built by theluckystrike — More at zovo.one