# Turn your ChatGPT dot into a video editor
The setup, prompts and checks behind my talking-head editing workflow.
By Artem Novitckii ยท 1 October 2026
Give your dot a recording, get the spoken cut right, then add captions and visuals. This guide takes you from the first setup check to an MP4 you can review, revise and keep.
Based on my supplied Dot editing conversation. The setup instructions link to current official documentation; the original exports were not independently inspected for this resource. Start with one short clip and verify your own environment.
## In this guide
- [Start with one short clip](#start)
- [Give Dot a place to edit](#setup)
- [Send the footage and a useful brief](#footage)
- [Paste the master editing prompt](#master)
- [Get the words and cuts right](#cut)
- [Lock the caption style](#captions)
- [Add visuals that explain the speech](#visuals)
- [Export, review and keep versions](#export)
- [Give feedback it can act on](#revise)
- [Save the setup for the next video](#save)
- [When something gets stuck](#stuck)
## Start with one short clip
A small first edit makes setup problems easier to catch.
Choose a 30 to 60 second talking-head recording with clear speech. You need the original MP4, a sentence explaining the video, and the correct spellings of names or products you mention.
1. Open your dot in ChatGPT on desktop. If you have not created it yet, open dots and follow the introduction.
2. Choose the cloud or connected-computer route below, then run the setup prompt.
3. Upload your recording or share it through a supported file connection.
4. Fill in the brief and paste the master prompt.
5. Review the rough cut and a short caption-and-visual sample before the full render.
6. Watch the exported MP4 on your phone with sound before posting.
Dot availability is still rolling out and depends on your account. This guide assumes you can access dots. Your Dot account, delegated work and optional services have their own usage limits.
[Official Dot getting started guide](https://learn.chatgpt.com/docs/dots/getting-started)
[Dot access and preview limits](https://learn.chatgpt.com/docs/dots#access)
## Give Dot a place to edit
Start on its cloud computer. Check the tools before promising an edit.
### Route A: Dot's cloud computer
Your dot has its own cloud computer and browser. Open its profile, then look under Computers to inspect it. Its files and browser sessions are separate from yours. A login in your personal browser does not sign Dot in.
Ask Dot to test the editing tools there first. Having a cloud computer does not establish that speech models, fonts or video rendering already work. Cloud work can continue while your computer is off.
### Route B: your connected computer
1. Open your dot's profile in the ChatGPT app on the computer you want to use.
2. Under Computers, find Your computer and select Allow access.
3. Review the confirmation and select Allow access to connect it.
4. Keep the computer online and the ChatGPT app open while Dot works there.
Use this route if your footage is already on your computer or a required tool is unavailable in the cloud. Open the delegated task to check where it is running. Connecting a computer to Codex separately does not give Dot access to it.
[Official computer and app connection steps](https://learn.chatgpt.com/docs/dots/computers-and-apps)
### The tools doing the work
| Tool | What it does |
| --- | --- |
| FFmpeg + ffprobe | Inspect the recording, cut footage, work with audio and export an MP4. |
| Python + faster-whisper | Transcribe speech and produce word-level timestamps on the chosen computer. |
| HTML, CSS, SVG + GSAP | Build editable diagrams, callouts and visual animations. |
| HyperFrames + browser renderer | Render an HTML video composition into frames and a video file. |
| Inter font files | Give captions a predictable font and weight. |
### Copy prompt: Check and set up the editor
```text
Set up a video-editing project for me. Start on your cloud computer if it can support the work.
First report where the job will run. Check FFmpeg/ffprobe, Python, faster-whisper, Node.js, HyperFrames and its browser renderer, available memory and disk space. Separate installed tools from things you have actually tested.
Use the current official documentation. Prefer local Whisper transcription on that computer so we do not need a transcription API key. Choose a model and compute type that suit the hardware; try turbo if practical and explain any smaller-model choice. Check that the model really downloads and loads.
For HyperFrames, use an available supported integration or set up its CLI in the project. Do not assume locally installed skills are available in a cloud task. Test the renderer, font loading and audio.
Create a separate project folder. Preserve my original recording. Tell me about any required permission or paid service before using it. Do not change security settings to make a download work.
With my supplied clip, render a five-second test containing video, audio, one caption and a simple visual. Return the actual MP4, the project location and a short passed/blocked report before editing the full video.
```
Whisper here means the speech-recognition model. In this workflow, faster-whisper runs it on the selected computer, including Dot's cloud computer. That is different from sending audio to Groq's hosted API.
[faster-whisper installation and word timestamps](https://github.com/SYSTRAN/faster-whisper)
[HyperFrames setup](https://hyperframes.heygen.com/quickstart)
Keep room for originals, model files, temporary frames and exports. Save the final project somewhere you can retrieve it. Execution on your computer does not make every part of the AI service offline.
### If you need Groq instead
Groq supports Whisper transcription with word timestamps. Use verbose_json and request word timestamp granularity. Confirm current file limits and account costs. If secure configuration is available, enter the key there and keep it out of chat, logs and shared files. A browser login alone does not configure an API client.
If no secure configuration route is available, continue with a working local model or the connected-computer route. Do not keep switching methods without a specific blocker and a tested next step.
[Groq speech-to-text documentation](https://console.groq.com/docs/speech-to-text)
## Send the footage and a useful brief
An accessible file and a clear direction save the first round of guessing.
Upload the original if it fits your current chat limit. For a larger file, use a connected Google Drive account or put it in the selected local project folder. Ask Dot to confirm it downloaded and inspected the actual video. Seeing a file name or a Drive preview is not enough.
The original conversation hit a 20 MB attachment limit. Treat that as a limit from that session, not a universal ChatGPT upload rule. Keep private footage private when fixing access.
### Copy prompt: Fill in your editing brief
```text
Audience: [who is watching]
Main point: [what they should understand]
Platform: [Reels / Shorts / TikTok / other]
Target length: [approximate length or keep the whole message]
Original video: [attached file or accessible location]
Names and terms: [exact spellings]
Keep: [lines, pauses or moments that must stay]
Remove: [obvious failed takes or mistakes]
Captions: one word at a time, lowercase, no punctuation
Font: Inter Medium 500; start at 84 px on a 1080 x 1920 canvas
Caption color: white, with a 3 px black outline
Visuals: [what would help explain the idea]
Opening image: [file, first frame and end cue]
References: [supplied examples or links]
Music: none unless I supply or approve a track
Delivery: MP4, editable project and change notes
Access: keep private until I approve sharing
```
Attach the exact opening image, logos and screenshots you want. Tell Dot which assets show the real product and which are only style references. Include any final upload-size limit in the brief.
## Paste the master editing prompt
Use this after the environment test passes.
Fill in the brief first, then paste this with your recording. The prompt asks for separate checkpoints so you can catch a wrong take or unreadable caption before the full render.
### Copy prompt: Give Dot the whole editing job
```text
Edit my talking-head recording using the brief and assets above. First confirm the setup test passed and that you can read the actual video.
Keep the original untouched. Work in a separate project folder. Save numbered versions, editable source files and a short change log.
1. Transcribe the actual speech with word-level timestamps. Check names, numbers and unclear phrases against the audio. Keep a readable transcript and a machine-readable timing file. Flag uncertainty.
2. Make a conservative rough cut. Remove clearly failed takes, repeated starts and distracting dead air. Keep natural pauses, complete word endings and the intended meaning. Keep audio and video together. Save a source-to-edited-time cut map, then remap caption and visual timings. Show the rough-cut MP4 for review.
3. Add one-word-at-a-time captions. Start with lowercase, no punctuation, Inter Medium 500 at 84 px on a 1080 x 1920 canvas, white with a 3 px black stroke. Keep the caption position consistent and clear of the face and platform controls. Preserve proper names and punctuation in the separate transcript.
4. Add a small set of visuals that explain the speech: diagrams, a simple timeline, comparisons or authentic supplied screenshots. Prefer editable HTML/CSS/SVG/GSAP rendered with HyperFrames when supported. Record asset sources. Follow my opening-image timing exactly.
5. Render a short sample covering a cut, fast speech, a long caption word and one visual. Let me approve the style before the full render. Do not add background music unless I approve it.
6. After approval, export 1080 x 1920 MP4 with H.264 video and AAC audio. Use 30 fps for this preset, checking source frame rate, rotation and HDR/color handling first. Reframe without stretching.
7. Check the exported file for clipped words, caption mistakes, timing drift, missing assets, black frames and audio/video sync near the beginning, after cuts and near the end. Separate checks you ran from anything I still need to watch.
8. Deliver the MP4, editable project, corrected transcript, word timings, cut map, asset sources and concise QA notes. If delivery needs a smaller file, make a measured review copy and retain the better export.
Keep the footage and review private. Ask before public publishing or using a paid service. Show concrete outputs and explain blockers plainly.
```
## Get the words and cuts right
Every cut changes the timeline the captions need to follow.
Transcribe the actual audio. A script helps with spellings, but it should not replace what you said. Check product names, numbers and accented speech. A model's language-detection confidence does not prove transcript accuracy.
Remove abandoned takes, repeated starts and unnecessary gaps. Silence detection can suggest cut points, but listen around each join. Leave enough room for consonants, breaths and word endings.
### Why captions can drift
If you remove two seconds before a word originally spoken at 7.2 seconds, that word now starts at 5.2 seconds. The cut map connects the original and edited timelines. Rebuild caption and visual timings from it, or re-align them against the edited audio.
### Copy prompt: Make a conservative rough cut
```text
Transcribe my recording with word timestamps and check the glossary in my brief. Save the corrected transcript and timings.
Make a conservative rough cut. Remove clear mistakes, duplicate attempts and distracting gaps. Preserve the full wording, useful pauses and complete word endings. Listen across each join.
Save each retained segment's original start/end and edited start/end in a cut map. Remap all word timings to the edited timeline.
Return the actual rough-cut MP4, cut map and any ambiguous take choices. Stop before adding visuals so I can review the spoken cut.
```
Approval checkpoint: play the rough cut once with sound. Check the joins and make sure the explanation still makes sense. Approve this version as the dialogue baseline.
## Lock the caption style
Use a preset, then check it at phone size.
My conversation went from Coolvetica to Helvetica alternatives, then Inter, and finally a slightly thicker Inter weight. Give the agent one clear preset to start from. These values come from the supplied guide and revisions; adjust them to your clip.
| Setting | Starting value |
| --- | --- |
| Words visible | One at a time |
| Case and punctuation | Lowercase; no punctuation in visible captions |
| Font | Inter Medium, weight 500 |
| Size | 84 px on a 1080 x 1920 canvas |
| Fill and outline | White fill; 3 px black stroke |
| Placement | Consistent; clear of face, graphics and app controls |
Use the real font file and weight. A shadow is different from an outline. If you specifically want Helvetica, supply a licensed font file or agree on an alternative. Inter is available under the SIL Open Font License; keep the license with any redistributed font files.
[Inter downloads and font license](https://rsms.me/inter/)
### Copy prompt: Test the captions before rendering
```text
Using the approved rough cut, render a short caption sample with fast speech, short words and a long word.
Show one word at a time, lowercase, without punctuation. Use the actual Inter Medium 500 font at 84 px on a 1080 x 1920 canvas, white with a 3 px black stroke. Keep the position consistent and avoid my face and the target app's controls. Scale the preset if the canvas differs.
Check that timings follow the edited audio and the correct font and weight loaded. Keep the readable transcript separately. Return the actual sample MP4 for phone-size review before the full render.
```
Check long words and the last sentence as well as the opening. There is no universal safe-zone rectangle for every app. Use the current target interface and a phone preview.
## Add visuals that explain the speech
Ask for the idea you want to show, then give it a time cue.
Ask for a visual action: a timeline that loses a pause, a file moving through an editing workflow, or a before-and-after comparison. Give each moment a spoken cue and a purpose. Keep your face and the caption area clear.
HyperFrames turns HTML into editable video compositions. Have Dot test it in the actual execution environment. A web animation looking good in live playback does not establish that it renders correctly at an arbitrary frame.
[What HyperFrames does](https://hyperframes.heygen.com/introduction)
### Copy prompt: Plan and build the visual moments
```text
Propose a small set of visual moments for the approved cut. For each, give the spoken cue, edited start/end time, purpose and asset source.
Use authentic supplied or official assets for product logos and screenshots. Mark explanatory diagrams or illustrative UI as illustrations. Do not invent product screens or factual claims.
Build the approved moments as editable HTML/CSS/SVG/GSAP compositions, using HyperFrames when the renderer is working. Make the animation seekable and deterministic. Wait for fonts, images and video assets before frame capture.
Keep motion restrained, preserve the approved dialogue and leave the caption area clear. Render one sample with its real audio before the full composition.
```
### Make the opening frame exact
In my conversation, the opening image needed to appear immediately and stay until the phrase "into my". Saying "show it at the start" left room for an unwanted delay. State the first frame, end cue and whether an entrance is allowed.
### Copy prompt: Specify an exact opening
```text
Use my supplied opening image fully visible from frame 0, with no fade or entrance animation. Keep it until the start of the spoken phrase [exact phrase] in the approved edited audio. Confirm that cue's edited timestamp before changing it.
At that cue, switch to the existing [named animation]. Keep all other approved audio, captions and timing. Verify the first frame and the frames around the switch.
```
Timing example: at 30 fps, an image shown through frame 44 lasts 1.50 seconds. The next visual starts at frame 45. That is an illustrative timing rule, not the required cue for every clip.
## Export, review and keep versions
The exported MP4 is the thing to check.
For this vertical preset, start with 1080 x 1920, 30 fps, H.264 video and AAC audio in MP4. Check the source first: rotation, variable frame rate and HDR phone footage can need extra handling. Check the destination's current requirements before delivery.
[FFmpeg export documentation](https://ffmpeg.org/ffmpeg.html)
### Speech and sound
- [ ] The explanation keeps its meaning and natural pauses.
- [ ] No first consonants or last syllables disappear at joins.
- [ ] Cuts have no clicks, sudden silence or large level jumps.
- [ ] Picture and speech stay in sync at the start, after cuts and near the end.
### Captions and visuals
- [ ] Names, numbers and captions match the actual speech.
- [ ] Captions follow the edited timeline and remain readable on a phone.
- [ ] The intended font and weight rendered.
- [ ] The opening and image switch happen on the intended frames.
- [ ] No missing assets, black frames or frozen animations.
- [ ] Graphics and captions leave the face and platform controls clear.
### Delivery
- [ ] The MP4 plays from beginning to end with sound.
- [ ] Dimensions, frame rate, duration and file size are checked.
- [ ] The original, editable project and higher-quality export are preserved.
- [ ] Versions have clear names and change notes.
- [ ] The intended viewer can play and download the correct file.
If you need a smaller review copy, give Dot the actual delivery limit and ask it to measure the result. A compression-quality setting does not guarantee a file size.
### A review page is optional
You can review numbered MP4s directly or use your existing private file workflow. If private hosting is available, a page with the latest version, past versions, change notes and download buttons makes revision easier. Hosting is a separate setup step.
### Copy prompt: Keep the versions in one place
```text
If a supported private hosting route is available, make a private review page for this edit. Put the latest version first and retain earlier versions with change notes and correct download buttons.
Verify playback, access and download paths for the intended viewer on desktop and mobile where possible. Tell me which checks you completed and which need me. Keep sharing private; ask before making it public.
If private hosting is unavailable, deliver clearly named MP4 versions through our existing file workflow. Save the editable project and originals somewhere durable.
```
Do the final watch-through yourself, with sound. Ask Dot to list checks it actually performed separately from checks it could not perform.
## Give feedback it can act on
Name the version, point to a moment and say what should change.
Use a timestamp from the export you are watching. After cuts, the same time in the original may point to a different sentence. Tell Dot to preserve the approved baseline and save a new version.
### Copy prompt: Restore a clipped word
```text
In [version], the word ending before the cut at [edited timestamp] sounds clipped. Compare it with the original, restore enough linked audio and video to keep the complete word, and remap later caption and visual timings.
Keep the rest of the approved edit. Save a new version and check the repaired join at normal playback speed.
```
### Copy prompt: Change one thing in the approved version
```text
Use [version] as the approved baseline. Change only [specific element] at [edited timestamp or exact phrase].
Desired result: [what should look or sound different].
Keep: [approved cuts, audio, caption style and other visuals].
Save a new version. Compare the affected section and a later unchanged section before delivery. Summarize the change.
```
### Copy prompt: Make a smaller review copy
```text
Create a review copy below [actual upload limit] with a little headroom. Keep the higher-quality export. Preserve readable captions and clear speech. Measure the final file size and verify its duration, playback and sync before delivering it.
```
## Save the setup for the next video
Keep your style, timings and editable source alongside the exports.
```text
video-project/
brief.md
input/ original recording
assets/ fonts, images and source notes
transcript/ readable text and word timings
edits/ cut map and version notes
graphics/ editable visual compositions
exports/ numbered MP4s
qa/ checks and review notes
README.md tested setup and render steps
```
### Copy prompt: Make the edit reusable
```text
Turn this approved edit into a reusable project template. Separate the footage and content from style settings.
Save the caption preset, visual layout rules, export settings, corrected transcript, word timings, cut map, editable graphics, render steps and tested dependency versions. Add an asset-source list, QA checklist, version history and README.
Use placeholders in the shared template. Exclude credentials, private links, private footage, model caches and temporary render frames. Include fonts or media only when their licenses allow redistribution.
For the next video, use this template and recheck the environment before editing.
```
The starter download contains this guide, prompts and blank planning templates. It does not include an installed editor, speech model, footage or a finished video pipeline. Dot sets up and tests those in your chosen environment.
## When something gets stuck
Ask for a concrete result and the next test.
| Problem | What to ask for |
| --- | --- |
| Dot sees a link but cannot edit the file | Confirm the actual download and inspect the video through the supported connection. |
| The cloud desktop looks idle | Ask for the current step, its output and any blocker. Command-line work may have no visible mouse activity. |
| A model download stalls | Name the failed download and error. Test an approved route or move to the connected computer. |
| The transcript gets a name wrong | Supply the correct spelling and ask it to recheck the audio at that moment. |
| Captions drift after a cut | Rebuild timings from the cut map or re-align against the edited audio. |
| The font looks wrong | Check the actual loaded font file and weight, not just the requested CSS name. |
| Animation works live but fails in export | Test frame seeking and wait for fonts and assets before capture. |
| The opening appears late | Specify full visibility from frame 0 and verify the first exported frame. |
| A review link fails | Check access and playback for the intended viewer without making the footage public. |
### Copy prompt: Ask for evidence of progress
```text
Show me the latest completed artifact and what you are working on now. Report: current step, completed output, current blocker if any, and the next concrete test.
If transcription or rendering is running, report observed progress without inventing an ETA. If no export is ready, say so. Do not call the edit finished until an actual MP4 exists and the checks are reported.
```
In the desktop app, Dot's profile has Activity for inspecting delegated work and requests for input. Background commands may explain an idle-looking desktop, but an actual preview is the useful proof.
[Reviewing Dot's work](https://learn.chatgpt.com/docs/dots/getting-started)