How I edited a video with GPT-6 Astra: the complete step-by-step

In the video, the promise was simple: comment "vídeo" and I'll send you the step-by-step. This article is that step-by-step — the full story of how GPT-6 Astra edited one of my Reels end to end, from prompt to render. Including the part almost nobody talks about: the usage limit hitting mid-work.

If you only care about the result: the video was edited by an AI. I never opened an editor. If you want to learn to do the same in your own project, just follow the steps below.

What you need before you start

Three things, none of which is a paid tool:

1. Raw footage. Phone recordings, vertical (1080×1920). If you record your screen, keep the screen recordings as separate files.
2. Narration. Record the final narration as a single audio file. It's the backbone of the video — everything gets cut around it.
3. An agent that executes. I used GPT-6 Astra (OpenAI's new model) to build everything, and Claude to finish. Any agent with file access and script execution will do.

Step 1: organize your footage as a project

Before any prompt, put everything into a project folder with clear names:

my-video/
├── 01-phone-recording.mp4
├── 02-editor-screen.mp4
├── narration.mp3
└── assets/             # motion, screenshots, anything supplementary

Why it matters: the agent will read this entire folder. An organized folder is free context — and context is what separates an "almost good" result from one you'll sign.

Step 2: have an editing skill (or use video-use)

In the video I mention I already have a skill that edits video. What it does, in practice:

• transcribes the audio with word-level timestamps;
• cuts at the pauses, never mid-word, never speeding up the voice;
• generates dynamic captions synchronized with the speech;
• assembles the video in the requested format and runs the render.

If you don't have a skill like this, the short path is video-use: you can test it and walk away with a video. The key is understanding the division of labor: the model decides, the script executes. Rendering is the last step, not the intelligence layer.

Step 3: write the prompt (and what to ask for)

The prompt I sent Astra, in essence, was this — copy and adapt:

Project: edit video X in vertical format (1080×1920), ~25 seconds.

Material:
- 01-phone-recording.mp4 — raw recording
- 02-editor-screen.mp4 — screen recording
- narration.mp3 — final narration (primary audio)
- assets/ — supplementary material

What I want:
1. Read every file in the project before starting.
2. Cut at the narration pauses, never mid-word,
   never speeding up the voice.
3. Dynamic captions, word by word, synchronized with the speech.
4. Vertical format, 1080×1920.
5. Build a storyboard first and wait for my approval.
   Only render after I approve.

The most important line is the last one: storyboard first, I approve, then render. Without it, the agent renders right away — and you find the problems in a finished video. With it, you see the whole video before it exists.

Step 4: approve the storyboard (and answer the questions)

Astra read the files and built the storyboard: every step of the video in a frame, with the captions already applied. Then came the part I didn't expect.

In the narration I had said a wrong number — I said 7.4 where the benchmark said 7.8. I hadn't even noticed. The agent caught it and asked which one I wanted to keep. I told it to keep the narration as recorded, because the correct number would appear on screen.

That's the lesson of step 4: a well-instructed agent doesn't decide behind your back when the data conflicts — it asks. And that only happens because the material was organized (step 1) and the request was explicit (step 3).

Practical rule: if the agent could pick wrong between two of your sources, say in the prompt what to do: ask, or follow a specific one.

Step 5: render and review

Once the storyboard is approved, it's execution: scripts run the render (1080×1920) and the video comes out done. What I review at the end:

• captions synchronized word by word (nothing drifting ahead of the speech);
• cuts at the right pauses, no breath cut in half;
• on-screen numbers matching what the caption says;
• no screen section shown for less than 1 second.

Step 6: when you hit the limit (and you will)

Here's the honest part: when the video was almost done, my Astra Ultra limit hit. Four hours of waiting, at the worst possible moment.

I wasn't going to wait. I took the base of work Astra had already done — storyboard, decisions, materials, all documented in the project — and finished it in Claude. It didn't change anything Astra had created: from that point on it was just executing the render scripts.

That's step 1 paying off: because the project was organized files, switching agents midway cost nothing. The expensive work (the creative base) was already done; rendering is a commodity.

Practical rule: organize the project so any agent can pick up where another left off. The day you need this, you won't have time to reorganize.

Conclusion

The final result — cuts, dynamic captions, everything — was a video edited by AI, from prompt to render, with me approving every decision that mattered.

The method isn't magic: organized material, an editing skill, an explicit prompt with storyboard before render, and a plan for the day the limit hits. Run it on your own project — and if you get stuck on any step, tag me and I'll help.