Claude to ChatGPT Skill Translator

Tessl allows only Claude eval runs when publishing. Given this is specifically an OpenAI/Codex skill, I would consider these eval results to be more accurate: https://tessl.io/eval-runs/019e1d88-f959-7338-a749-573b9ed90809

A note about best practices: Tessl's optimization suggestion would have resulted in a loss of functionality, so it was ignored.

Translate skills by preserving purpose, not by mechanically copying files.

A successful translation produces a ChatGPT/Codex skill that keeps the source skill's useful behavior while making host-specific assumptions explicit. Never hide incompatibilities. Never broaden the skill's purpose to compensate for missing capabilities.

Required Workflow

1. Inspect the source skill before editing.
2. Identify the source skill's purpose, target users, expected inputs, expected outputs, bundled resources, scripts, external tools, connectors, credentials, and execution assumptions.
3. Identify the translation target:
   • chatgpt: ChatGPT skill packaging and ChatGPT interaction assumptions.
   • codex: coding-agent usage, repository context, shell/script expectations, and minimal host assumptions.
   • both: portable core that should work in ChatGPT and Codex, with target-specific notes when needed.
4. Ask for the translated skill name before writing files unless the user already supplied one. Use this exact decision prompt when needed: What should the translated skill be called? If you do not provide a name, I will use the source skill name normalized to kebab-case.
5. Build a capability matrix with one row for every meaningful source capability.
6. Classify each capability:
   • portable: can be carried over directly.
   • adaptable: can be realized with changed metadata, paths, tool names, packaging, or wording.
   • host-dependent: depends on Claude-specific, desktop-specific, MCP-specific, filesystem, shell, browser, connector, credential, or permission behavior.
   • unrealizable: cannot be safely or truthfully realized in the target host without an external tool, connector, credential, asset, or human step.
7. Assign a translation risk score:
   • low: direct translation; no material behavior loss.
   • medium: translation requires metadata/runtime wording changes, but behavior is substantially preserved.
   • high: important behavior depends on target setup, external tools, connectors, scripts, or credentials.
   • blocked: one or more essential capabilities cannot be realized faithfully.
8. Distinguish the mode:
   • translation: preserves the source behavior and purpose with equivalent target packaging.
   • adaptation: changes behavior or constraints to fit ChatGPT/Codex.
   • minimum viable translation: preserves only the portable core after the user approves reduced behavior.
9. If any capability is host-dependent or unrealizable, stop before packaging and ask whether to proceed with an adapted or minimum viable translation.
10. If the user approves, produce the ChatGPT/Codex skill with required OpenAI structure and clear limitations.
11. Validate and package the translated skill as skill.zip.

Inspection Requirements

When a source archive or folder is available, inspect at minimum:

• SKILL.md frontmatter and body.
• all reference files directly linked or obviously relevant.
• scripts and their runtime dependencies.
• asset names and sizes.
• any Claude-specific names, paths, MCP assumptions, desktop assumptions, project paths, shell commands, credentials, or connector references.

Use scripts/inspect_skill.py when a source folder or zip is available. Treat its report as a starting point; still apply judgment.

Compatibility Report

Before translating, return this report:

Source skill:
Target host: chatgpt | codex | both
Requested translated skill name:
Normalized translated skill name:
Name source: user-provided | source-skill-default
Purpose:
Expected input:
Expected output:
Resources found:
Scripts/tools found:
Connector or credential assumptions:
Host-specific assumptions:
Translation mode: translation | adaptation | minimum viable translation
Translation risk score: low | medium | high | blocked

Capability matrix:
| Capability | Claude/source assumption | ChatGPT/Codex equivalent | Status | Notes |
|---|---|---|---|---|
| ... | ... | ... | portable/adaptable/host-dependent/unrealizable | ... |

Required changes:
Capabilities preserved:
Capabilities adapted:
Capabilities reduced or omitted:
Risks / reduced behavior:
Recommendation:
Proceed? yes/no

Do not package a translated skill until the user approves when risk is high or blocked, or when any capability is host-dependent or unrealizable.

Use direct approval wording:

I can translate this skill, but these capabilities will not be equivalent in ChatGPT/Codex:
- ...

Proceed with the adapted or minimum viable version?

Translation Rules

Preserve purpose

Keep the source skill's intended job. Do not broaden it to cover adjacent tasks.

If the source capability cannot be preserved, state the limitation. Do not silently replace it with a broader instruction such as "use whatever tools are available."

Determine the translated skill name

Before creating or editing the translated skill package, identify the desired translated skill name. If the user has not already provided a name, ask:

What should the translated skill be called? If you do not provide a name, I will use the source skill name normalized to kebab-case.

Normalize the final skill package name to kebab-case:

• The Cat Burglar -> cat-burglar
• Client Portal QA -> client-portal-qa
• claude_to_chatgpt -> claude-to-chatgpt

Use the normalized name for the translated skill directory, SKILL.md frontmatter name, and package contents. Keep the display name in agents/openai.yaml human-readable.

If the user declines to name the skill or gives no name after the prompt, derive the name from the source skill's frontmatter name; if that is missing, derive it from the source folder name.

Rewrite the trigger description

For ChatGPT/Codex, the frontmatter description must include both:

• what the skill does
• specific trigger conditions for when to use it

Keep it clear, concrete, and lower-case.

Add OpenAI metadata

Create agents/openai.yaml with a readable display name, short description, icon, and accent color.

Keep progressive loading

Keep SKILL.md compact. Move long details into one-level references/ files. Remove unused examples and placeholder files.

Convert host language

Replace host-specific references such as Claude, Claude Code, Claude Desktop, or Anthropic only when they describe the runtime user. Preserve them when they are the subject being analyzed.

Prefer neutral terms such as:

• assistant
• agent
• ChatGPT/Codex
• source skill
• translated skill

Handle scripts conservatively

If scripts are portable, keep them and document how they are used.

If scripts require unavailable binaries, operating systems, credentials, network access, or connectors, classify the capability as host-dependent or unrealizable and ask before proceeding.

Handle connectors and tools truthfully

Never imply that ChatGPT/Codex can access a connector, account, repository, file, browser session, local app, or MCP server unless that access is actually available in the target environment.

If a source skill depends on a connector, include an explicit limitation or required setup step.

Preserve safety boundaries

If the source skill includes refusals, access checks, approval gates, no-op rules, validation steps, or capability checks, preserve them unless they conflict with the target platform's rules.

Add target notes when needed

If target=codex, include repository, shell, script, and file-edit assumptions only when the translated skill truly needs them.

If target=chatgpt, avoid implying persistent repo state, local shell access, or background work unless the actual target environment provides it.

If target=both, prefer the portable behavioral core and put host-specific execution details in a short "Target notes" section.

Minimum Viable Translation Mode

Use this when the source skill is useful but some host-specific machinery cannot be ported.

Rules:

1. Preserve only capabilities classified as portable or safely adaptable.
2. Omit or downgrade host-dependent capabilities after user approval.
3. Add a limitation section naming what was not preserved.
4. Do not introduce new capabilities to fill the gap.
5. Make the translated skill honest even if it is smaller.

Output Contract After Approved Translation

When done, provide:

Translated skill:
Normalized skill name:
Name source: user-provided | source-skill-default
Target host:
Translation mode:
Risk score:
What changed:
Capabilities preserved:
Capabilities adapted:
Capabilities omitted or reduced:
Validation result:
Install/test checklist:
- upload skill.zip
- verify the trigger with a representative prompt
- run one simple source-equivalent task
- compare output against the original Claude skill expectation
- confirm any host-dependent setup or limitation
Round-trip review:
- What did the original skill do better?
- What became weaker?
- What assumptions remain?
Packaged file:

Failure Conditions

Stop and explain when:

• no SKILL.md entrypoint exists.
• multiple skills are found and the user did not ask for a multi-skill batch plan.
• required source files are missing.
• a required binary or connector cannot be represented in ChatGPT/Codex and the user has not approved a reduced version.
• the translated package would exceed upload limits.

References

Use these references only when needed:

• references/compatibility-checklist.md for detailed audit criteria.
• references/translation-examples.md for clean-port and reduced-port examples.