Skill to Prompt Converter

Converts a Claude skill (SKILL.md + references/) into ChatGPT Project format: one prompt instruction document (.docx, under 8,000 characters) and one knowledge file document (.docx).

What This Produces

For each conversion:

Prompt Instructions (.docx) — The text that gets pasted into ChatGPT's "Instructions" field. Under 8,000 characters. Structured using the 9-component prompt formula.
Knowledge File (1 .docx file) — Uploaded to the ChatGPT Project as reference material. Contains all detailed workflows, templates, frameworks, examples, and reference content consolidated into a single document.

All .docx files follow standard formatting: Arial font, 10pt normal text, H1=20pt, H2=16pt, H3=14pt, H4=12pt, 1.15 line spacing.

Conversion Workflow

Step 1: Locate and Read Source Skill

If user provides a skill name (e.g., "copywriting"):

Look in ~/.claude/skills/[skill-name]/SKILL.md

If user provides a path, use it directly.

Read everything:

SKILL.md (full content)
All files in references/ folder
Note any scripts/ or assets/ folders (these need special handling)

Step 2: Analyze Skill Complexity

Count total source content to understand how much compression is needed for the single knowledge file:

Complexity	Criteria	Compression Needed
Simple	<300 lines in SKILL.md, no reference files	Minimal — content fits easily in one knowledge file
Medium	300-500 lines or 1-2 reference files	Moderate — condense verbose sections, keep all frameworks and examples
Complex	500+ lines or 3+ reference files	Heavy — prioritize frameworks, worked examples, and actionable content. Summarize repetitive sections

Regardless of complexity, always produce exactly 1 knowledge file.

Step 3: Map Content to the 9-Component Prompt Formula

Read references/prompt-structure-guide.md for the full mapping guide.

Extract from the Claude skill and map to ChatGPT instruction components:

Claude Skill Section	ChatGPT Prompt Component
Frontmatter `description`	Role + Task summary
"When to Use" / trigger conditions	Task context
"Before Starting" / gather context steps	Inputs/Variables
Core workflow sections (numbered steps)	Task (condensed steps)
"Output Format" section	Formatting Instructions
"Examples" section	Example Output (1-2 max in instructions)
"Constraints" / "Rules" / "Never" statements	Constraints
Target audience mentions	Audience
Voice/tone guidance	Style/Tone
Purpose / outcome descriptions	Goal

Step 4: Split Content Between Instructions and Knowledge Files

Apply the priority system to stay under 8,000 characters:

P1 — Always in the prompt instructions:

Role statement (who the AI is, what it specializes in)
Task overview (primary task + condensed workflow steps)
Goal (desired outcome)
Critical constraints (never/always rules)
Knowledge file references (what each file contains, when to consult it)

P2 — Include in instructions if character budget allows:

1-2 key examples (keep short, move full examples to knowledge files)
Input variables (what the user must provide before starting)
Output formatting specs
Style/tone guidance

P3 — Always in knowledge files:

Full detailed workflow with multi-paragraph explanations
Complete example library
Templates and frameworks (from SKILL.md body and references/)
All reference material (from references/ folder)
Edge cases and advanced scenarios
Decision trees and detailed tables
Script code (from scripts/ folder, documented as reference)

Character budget: Target 7,500 characters for the instruction text (500-char safety buffer).

Step 5: Write Prompt Instructions

Draft the instruction text following this structure:

Every prompt instruction document must include all 9 headings below, in this exact order. No headings may be omitted or renamed.

## Role

You are [expertise extracted from skill description and intro].
You specialize in [specific domain/capabilities].

## Task

Your primary task is to [main objective from the skill].

Follow this workflow:
1. [Condensed step from skill workflow]
2. [Condensed step]
3. [Condensed step]
...

## Goal

[Desired outcome extracted from the skill's purpose/output sections]

## Audience

[Target audience. If the skill does not specify an audience, write: "General users seeking [skill domain] assistance. Adjust complexity based on the user's apparent experience level."]

## Style/Tone

[Voice/tone rules extracted from the skill. If the skill does not specify tone, write: "Professional and clear. Match the register of the target audience. Avoid jargon unless the audience expects it."]

Always include these writing rules regardless of skill-specific tone:
- Avoid dashes unless absolutely necessary. Prefer commas, periods, or conjunctions to keep the tone natural.
- Use en dashes (with spaces, e.g. word – word) or em dashes (without spaces, e.g. word—word) only when unavoidable, ideally no more than once per complete piece of output.

## Constraints

- [Never/always rule]
- [Character/word limits]
- [Format restrictions]
- [Quality standards]

## Inputs/Placeholders

Before starting, ask the user for:
1. [Required input from the skill's context-gathering steps]
2. [Required input]

## Example Output

[1-2 short examples showing expected output structure. Keep brief.]

## Formatting Instructions

[Output structure and formatting rules from the skill]

After the 9 required sections, always append a Knowledge Files section:

## Knowledge Files

This project includes 1 knowledge file. Consult it as needed:

1. **[SkillName]_Reference_Guide.docx** — [What it contains and when to reference it]

After drafting, count characters. If over 7,500:

Cut examples to bare minimum (but keep the Example Output heading with at least a brief example)
Compress workflow steps further
Shorten Audience and Style/Tone content (but never remove the headings)

If over 8,000 after compression: shorten section content further, but all 9 headings must remain. Move detailed explanations to the knowledge file and replace with concise summaries under each heading.

Step 6: Organize Knowledge File Content

Always produce exactly 1 knowledge file named [SkillName]_Reference_Guide.docx.

Consolidate all P3 content into this single document, organized with clear heading hierarchy:

[SkillName]_Reference_Guide.docx containing:

Full detailed workflow with complete explanations
All examples and worked examples
Templates and frameworks (from SKILL.md body and references/ folder)
All reference material (from references/ folder)
Guidelines, best practices, and edge cases
Decision trees and detailed tables
Script documentation (from scripts/ folder, noted as non-executable reference)

Organization within the single file:

Use H1 for major sections (Workflows, Templates, Examples, Reference Material)
Use H2-H3 for subsections within each major section
Use page breaks between major sections for readability
For complex skills with heavy reference content, prioritize frameworks, worked examples, and actionable content over verbose explanations

Step 7: Generate JSON Data

Structure all content as a JSON object matching the docx-generator input format.

The JSON structure:

{
  "skillName": "Skill Display Name",
  "originalSkillName": "skill-name",
  "version": "1.0.0",
  "outputDir": "~/Downloads/",
  "instructionDoc": {
    "filename": "SkillName_Prompt_Instructions.docx",
    "title": "Skill Name — ChatGPT Project Instructions",
    "characterCount": 7234,
    "sections": [
      { "type": "heading", "level": 1, "text": "Section Title" },
      { "type": "paragraph", "text": "Regular paragraph text." },
      { "type": "bold-paragraph", "label": "Label:", "text": "Text after label" },
      { "type": "bullet", "text": "Bullet point", "level": 0 },
      { "type": "numbered", "text": "Numbered item", "number": 1 },
      { "type": "table", "headers": ["H1","H2"], "rows": [["a","b"]], "columnPcts": [30,70] },
      { "type": "divider" },
      { "type": "spacer", "size": 200 },
      { "type": "meta", "text": "Metadata or footnote text" }
    ]
  },
  "knowledgeFiles": [
    {
      "filename": "SkillName_Reference_Guide.docx",
      "title": "Skill Name Reference Guide",
      "sections": [...]
    }
  ]
}

Write this JSON to a temporary file in the current directory: [skill-name]-conversion.json

Step 8: Generate .docx Files

Run the generator:

NODE_PATH=~/Documents/node_modules node ~/.claude/skills/skill-to-prompt/references/docx-generator.js [skill-name]-conversion.json

This produces all .docx files in the ~/Downloads/ folder.

If the docx package is not available, install it first:

cd ~/Documents && npm install docx && cd -

Fallback: If .docx generation fails entirely, output the content as formatted markdown that the user can paste into Google Docs or Word. Apply the same heading hierarchy and section structure.

Step 9: Validate and Present Results

Check and report:

Instruction character count (must be under 8,000)
All .docx files generated successfully
Knowledge files contain complete referenced content
Cross-references between instructions and knowledge files are clear

Present to the user:

Conversion complete: [skill-name] → ChatGPT Project

Output saved to ~/Downloads/

Prompt Instructions:
  [SkillName]_Prompt_Instructions.docx (X,XXX characters)

Knowledge File:
  [SkillName]_Reference_Guide.docx — [brief description]

Setup in ChatGPT:
  1. Create a new Project in ChatGPT
  2. Paste the instruction text from the Instructions .docx into the project's Instructions field
  3. Upload the knowledge file to the project
  4. Test with a sample prompt

After presenting, clean up the temporary JSON file:

rm [skill-name]-conversion.json

Conversion Rules

What Transfers Directly

Role and purpose definitions
Workflow steps (condensed)
Constraints and rules
Output format specifications
Examples and templates
Reference content

What Requires Rewriting

Claude tool references (Read, Grep, Glob, Bash, Edit, Write) → Rewrite as natural language instructions. Example: "Read the user's file" becomes "Ask the user to paste or upload the content."
Dynamic commands (!command syntax) → Not available in ChatGPT. Document as manual steps.
File system operations → Replace with "ask the user to provide" patterns.
Progressive disclosure (loading references on demand) → All content must be in knowledge files upfront.

What Does Not Transfer

Scripts (scripts/ folder) → Document the script's purpose in the knowledge file. Include the code as reference if useful, but note it cannot execute in ChatGPT.
Assets (assets/ folder) → Note in the output: "These assets must be manually transferred if needed."
Cross-skill references → Flag as dependencies: "This skill references [other-skill]. Consider converting that skill separately."
MCP server integrations → Not available in ChatGPT Projects.
Frontmatter fields (version, argument-hint, context, agent, allowed-tools) → These are Claude-specific metadata. Do not include in ChatGPT instructions.

Output Naming Convention

[SkillName]_Prompt_Instructions.docx
[SkillName]_Reference_Guide.docx

Where [SkillName] is the skill name in Title Case with spaces replaced by underscores.

Examples:

copywriting → Copywriting_Prompt_Instructions.docx
digital-product-video-ads → Digital_Product_Video_Ads_Prompt_Instructions.docx
page-cro → Page_CRO_Prompt_Instructions.docx

Document Formatting Standards

All .docx output follows these standards:

Element	Setting
Font	Arial
Font color	Black (default) for all text and headings
Normal text	10pt
Heading 1	20pt
Heading 2	16pt
Heading 3	14pt
Heading 4	12pt
Line spacing	1.15

Additional rules:

Headings are styled by size only. No extra bold on headings.
All text and headings must be default black. No additional colors on any text or headings.
Add space after each paragraph.
Tables use alternating row shading for readability.
When generating .docx, explicitly set Arial font, heading sizes, black color (no theme colors), and 1.15 line spacing on every element. Never rely on Word default styles.

References

references/prompt-structure-guide.md — 9-component prompt formula, character budget allocation, compression techniques
references/docx-generator.js — Node.js script for generating .docx files from JSON data
references/AI Prompting Techniques.pdf — Source material for the prompt structure framework

Related Skills

agent-skill-builder — The reverse direction: converts ChatGPT Projects into Claude skills
skill-creator — Guide for creating new Claude skills from scratch