The Pipeline That Lets Claude Code Edit A Full Video In One Shot
A five-tool stack — transcription, cuts, AI b-roll, code-built motion graphics, and a self-review loop — that lets an agent finish a rough cut to a client-ready render without a human in the loop.
Posted
1 weeks ago
Duration
Format
Tutorial
educational
Views
1.5K
113 likes
57 · 43
Big Idea
The argument in one line.
An AI video editing pipeline becomes genuinely autonomous only when the agent can watch its own render frame-by-frame and loop fixes against that visual feedback, not just cut from a transcript.
Who This Is For
Read if. Skip if.
READ IF YOU ARE…
A YouTuber or course creator using Claude Code (or a similar coding agent) who wants to offload rough cuts, b-roll, and motion graphics instead of manually editing in Premiere or CapCut.
A solo creator comfortable setting up CLI tools, MCP connectors, and API-based services (WhisperX, FFmpeg, Higgsfield) rather than clicking through a GUI editor.
Someone building an agentic content pipeline who wants a concrete example of a watch-then-fix review loop applied outside of writing code.
SKIP IF…
You want a drag-and-drop editing tool — every step here requires installing and wiring together developer tools inside a coding agent.
You need editing to be free of any AI-generated footage — the b-roll stage explicitly generates video with third-party AI models.
TL;DR
The full version, fast.
The video argues that AI video editing pipelines stall not at cutting footage but at reviewing the result, because a coding agent that can only read a transcript has no way to judge whether captions cover a face or a graphic looks off. The pipeline runs five stages — WhisperX transcription for word-level timestamps, FFmpeg for the actual cuts, Higgsfield-generated AI b-roll, HyperFrames-built motion graphics as code, and a final music/SFX pass — then closes the loop with a frame-extraction skill that lets the agent inspect its own render, hand itself a fix list, and re-render until a review passes. A live demo shows the intro of this very video cut, reviewed twice, and fixed in about forty minutes from one prompt and a heavily-annotated script document.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
States the pipeline's whole promise up front — raw footage in, fully edited video out — and frames the rest of the video as showing how to build it.
01:05 – 03:06
02 · The pipeline
Breaks AI editing into five stages an agent can run one at a time: transcription (WhisperX), rough cut (FFmpeg), b-roll (Higgsfield), motion graphics (HyperFrames), and SFX/export.
03:06 – 03:50
03 · Costs
Breaks down the roughly $90 in tokens per video, notes it's covered by an existing Claude Code Max subscription, and compares it to a $150-3,000 human editor.
03:50 – 06:33
04 · My secret weapon
Identifies the review gap — an agent editing from transcript alone can't see its own graphics — and introduces a frame-inspection skill plus a Think/Observe/Act review loop where sub-agents check the render and hand back fixes.
06:33 – 08:00
05 · Setup
Walks through installing the review skill and HyperFrames, connecting the AI b-roll generator as an MCP connector, and installing FFmpeg and WhisperX inside a coding-agent project folder.
08:00 – 14:35
06 · Live Edit
Runs the full pipeline live on this video's own intro: prepping a script document with comments, sending one prompt, watching the rough cut land, generating AI b-roll, and going through two review passes before the final render.
14:35 – 17:00
07 · My tips for one-shot edits
Lists four additions that push results from decent to consistently one-shot: a design 'taste' skill, generating assets mid-edit, a style file that absorbs corrections, and pre-work planning in the script.
Atomic Insights
Lines worth screenshotting.
A coding agent can't hear audio or see video by default, so an AI editing pipeline needs a word-level transcript before it can decide where to cut.
Editing a full video down to a rough cut takes only a good transcript, which is why AI nails first-pass cuts almost every time.
Motion graphics and AI b-roll are where autonomous edits usually break down, because the agent never actually sees the finished frame it produced.
Building motion graphics as code instead of as fixed templates removes any ceiling on how many unique graphics an agent can generate per video.
A frame-extraction skill that lets an agent inspect specific timestamps of its own render turns a one-way editing prompt into a genuine revise-and-check loop.
An agent that can't check its own output is just guessing at the quality of the final result.
One creator's tracked token cost for a fully AI-edited video was about $90, covered inside an existing coding-agent subscription rather than billed separately.
AI-generated b-roll segments cost only a few dollars each, the one true out-of-pocket cost beyond the subscription.
A single video render can go through half a dozen automated review passes before a human even opens the file.
Writing detailed comments directly into a script document before recording is described as saving more editing time than any tool in the pipeline.
Feeding an agent reference images and specific instructions (music choice, zoom direction, graphic style) inside script comments is what avoids generic-looking AI output.
A style file that permanently absorbs every correction from a review means the same note never has to be given twice.
Comparing AI-assisted editing's per-video cost (roughly $90) against a human editor's $150-3,000 per video reframes token spend as cheap by comparison.
A three-hour AI edit turnaround is described as faster than any human editor the creator has worked with.
Takeaway
What actually makes an AI editing pipeline finish a video unsupervised
WHAT TO LEARN
An agent-run editing pipeline only becomes trustworthy once it can inspect its own rendered output and revise against what it actually sees, not just what a transcript says happened.
01One-shot editing
A pipeline that looks fully automated to the viewer is still built from discrete, checkable stages — cut, b-roll, graphics, sound — not one giant undifferentiated prompt.
The stated failure mode for most people attempting this isn't the tooling, it's spending hours manually directing an agent that can't evaluate its own output.
02The pipeline
A word-level, sub-second transcript is the prerequisite for automated cutting, because the agent has no other way to know where a sentence or silence actually starts and ends.
Separating 'decide what to cut' (reading a transcript) from 'physically make the cut' (a dedicated tool executing the edit) avoids asking a language model to do frame-accurate work it's bad at.
Building motion graphics as code rather than picking from fixed templates removes the ceiling on how many distinct graphics a pipeline can generate.
03Costs
Tracking actual per-video token cost (roughly $90 here) turns 'is AI editing worth it' into a concrete comparison against paying $150-3,000 for a human editor, rather than a vague intuition.
Subscription-included AI usage can make an expensive-looking per-task token cost effectively free in practice.
04My secret weapon
A coding agent editing video from a transcript alone will nail cuts but consistently produce graphics with visible errors, because it never sees the rendered frame it just created.
Giving an agent a way to inspect specific frames of its own output — not just read logs or transcripts — is what enables a genuine build-check-fix loop instead of one-shot guessing.
An agent that can't verify its own work is unable to know whether the task is actually done — validation is what makes 'done' a real claim rather than an assumption.
05Setup
An AI production pipeline is assembled from independent single-purpose tools connected to one agent, not one platform that does everything.
Connecting an external AI service to an agent via a standard protocol lets that agent call it directly mid-task instead of a human copying outputs back and forth manually.
06Live Edit
A first-attempt automated render is expected to have visible issues — the value is in the fix loop catching them before a human has to.
The rough-cut stage is reliably correct on the first attempt because it depends only on a clean transcript, while creative stages like graphics still need review passes.
Running two explicit review passes — a technical pass, then a composition/fidelity pass — before calling a render final mirrors how a human editor checks their own cut.
07My tips for one-shot edits
Applying general design-quality rules to code-generated graphics matters because those graphics are just front-end code under the hood, so anything that improves generated UI also improves generated motion graphics.
Writing every correction from a review back into a persistent style file — instead of only fixing the current render — stops the same note from having to be repeated on the next video.
The single biggest lever for a usable first-pass result isn't a tool at all: detailed planning comments written into the script before the agent starts, describing music, pacing, and reference visuals.
Glossary
Terms worth knowing.
Rough cut
The first version of an edit with silences, filler words, and bad takes removed, but before graphics, b-roll, or sound design are added.
B-roll
Supplementary footage cut in around the main talking-head shot, sourced here from screen recordings or generated by an AI video model.
Word-level transcript
A transcript where every individual word carries its own timestamp, letting an editing tool cut audio or video at the exact moment a word starts or ends.
MCP (Model Context Protocol)
A connection standard that lets an AI agent call an external service's tools directly, used here so the agent can request AI-generated video from a third-party model provider.
Motion graphics as code
Building animated on-screen graphics as small programs rather than editing them by hand in a timeline tool, so an agent can generate and modify them by writing code.
Agent review loop
A repeating cycle where an agent produces output, inspects that output against a goal, and revises it — the pattern used to explain the self-review the AI performs on its own edited video.
Style file
A persistent notes file the agent reads before every edit, into which corrections from past reviews are written so the same mistake isn't repeated on the next video.
“Ten minutes of comments here will literally save you hours of back and forth.”
actionable and specific→ newsletter pull-quote↗ Tweet quote
The Script
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
17px
metaphoranalogystory
All I do is drop my raw footage into this folder, and Claude edits the entire video for me in one shot. It handles motion graphics like this, generates perfect AI b roll completely automatically, bakes in captions like these ones, and the music you're hearing right now.
All of it. This pipeline has edited every single video on this channel over the past month, but most people trying this are spending hours going back and forth with Claude because they're missing the one skill that turns AI editing into a completely autonomous video production engine. In this video, I'll show you how to build the entire thing, no gatekeeping, starting with how AI editing actually works.
AI editing is pretty simple because it's essentially the same thing that a human editor would do just broken down into stages that can actually run. The problem is that Claude code can't just log in to Premiere Pro and start editing for you. So we need to design an AI editing pipeline around a toolset and the capabilities of what Claude can actually do.
And the best part of the one that I've designed is that the whole thing runs on about five tools and almost all of them are free. Stage one is transcription. And for that, we'll use WhisperX.
It's a small AI model that runs locally on your machine and transcribes your raw footage word by word with a timestamp on every single word. And that matters because Claude can't actually hear the audio for the clips, so it has no idea where a cut should land unless it knows the sub second timing of what was actually said.
It also can't physically make that cut without writing complicated custom code, so we need a package for that, FFmpeg. Claude can now read the transcript and decide what goes, so it takes out the silences, the bad takes, and the filler. And the FFmpeg is what physically makes those cuts for it.
It trims the clips, joins them back together, and cleans up your audio. It's free and it's open source, and it turns twenty five minutes of raw footage into about twelve minutes of tight video. Once we've taken out all of our mistakes and silences, we've got our rough cut.
But without some extra footage, that's gonna make a pretty boring video just staring at me for twenty minutes. So next, the b roll comes in. Claude will look at all the screen recordings that I've taken for the video and merge them in where the script calls for it.
And when I don't have any footage for a line, I use Higgs Field to automatically generate the b roll that fits perfectly for that scene. Higgs Field lets Claude access all the best image and video models in one connection using its MCP. So Claude reads the context of the script and then can go and generate footage that fits exactly what I'm saying.
Keyroll is great, but the real power of this editing pipeline is in generating those motion graphics that you saw earlier. And that all happens with Hyperframes, which is a 100% free open source graphics engine from the team at Hagen.
And it builds every graphic as code, so Claude has literally no limits in how many of these it can create for your video. It even handles the scene setup and changes that you're seeing right now. Hyperframes is very much the backbone of this pipeline and what takes it from trimming clips to actually generating videos.
Once we've got the graphics in, we layer in the special effects. So that's the background music and the sound effects that you've heard throughout the video. And again, that's FFmpeg doing all of the work here.
So you're probably wondering how much this all costs because I've been running my edits over the last couple of weeks and each video has averaged out to about $90 worth of tokens. But the thing is I never actually paid that because it all came out of my Claude code max plan that I'm already on.
The only real cash cost is the AI b roll, which runs a few dollars per segment on Higgs Field. Now compare that to paying an editor, which might cost you anywhere between a 150 and $3,000 per video.
But the thing is, these edits come back in three hours, which is way faster than any editor I've ever worked with. You could 100% try and run this on a cheaper model and optimize it even further than I have.
And I'm really hoping to seeing what you guys have done there, so leave a comment if you've got ideas how to make this cheaper. So that's the pipeline, and most AI editing workflows actually stop right here, which is exactly where they fall apart because here's what actually happens. The first draft comes back and the captions might be covering your face.
The graphics aren't using the space properly. So you type move that down, make the graphic bigger, and suddenly you've spent about two hours as the director for what is essentially a blind video editor. And you don't save any time at all.
So I plugged that gap, and it's the reason why this whole workflow runs on its own for me now. I gave Claude the ability to actually watch the video it's editing. Because see Claude code can't see video.
It can only read the transcript. That's why it always nails the rough cut every time because cutting raw footage down just needs a good transcript. But the graphics overlays always come back with little issues because Claude never actually sees the finished result.
So a few months back, I built a skill called watch, and it gives Claude eyes. It pulls out the video's frames one by one so Claude can see exactly what's going on on screen at every single moment. And it is a massive upgrade to this editing workflow because once Claude can see its own work, it can edit the way a real editor does.
Because think about it for a second. The real editor is working on a timeline. They make a change.
They watch it back. They spot what looks off, and then they fix it. They keep doing that until the video looks right.
No editor can edit a video in one go with its eyes closed. So why are we asking Claude to? This cycle is called an angel loop, and it's made up of two ingredients.
First is a goal, which is finish the video, and a way for Claude to actually go and check what it's working on. So that's the watch skill. So here's exactly what that agent loop looks like in my pipeline.
Once the render is finished, I have sub agents use the watch skill to review it like a picky editor. They check for visual glitches, spacing, alignment, and just the general feel of the clip. Then they hand their report back to Claude as a list of fixes.
Claude then makes those fixes, renders again, and reviews again, and the whole process keeps going around in that loop until the video So by the time I sit down for my final review, it's already been through half a dozen reviews using these sub agents. And that validation loop is the key here because an agent that can't check its own work is really just guessing about the quality of the final result.
It's also exactly why I don't use a video understanding model like Gemini because Claude can control exactly where it looks in these clips. So we can go and inspect the seams between the graphics and those scenes specifically. Now validation is the biggest part of getting these edits done in one shot, but it's not the only job that the watch skill does.
It's also how I steal any editing style and how I can pick my b roll completely automatically, but we'll go through both of those when I run the full pipeline in just a little bit. So let's get everything set up so you can start running this for yourself today.
The first thing that you need to do is go to your desktop or anywhere and create a folder called video editor. Then open that folder inside of your Claude code. I'm actually running Claude code inside of my founder OS, which is one folder and workspace that I can run my entire business out of.
It has my sales, my delivery, my content, everything. If you wanna build a founder OS just like mine, so you can run your business out of one folder, I'm hosting a live build shop this month, and the link for that in is in the description below. But if you don't wanna do that, you don't need the founder OS or anything fancy to get this to work.
You can just open up that folder inside of the desktop app as well. Then once we've got that set up, we wanna start installing everything we need. So we go and grab the watch skill from the guide I'll link in the description below, as well as the link to the HyperFrames GitHub, and ask Claude to just install both of those inside of that project.
Then we'll connect Higgs Field as an MCP for the b roll. So you'll need to head to Higgs Field Dot Com Slash M C P, copy the link, and then ask Claude to install that MCP for you. If you wanna use it on the Claude chat as well, you can do that.
Just go to the connectors menu, then add it in there. Then we'll grab FFmpeg and WhisperX. These are both doing the heavy lifting for cutting and transcription.
Once again, grab the GitHub URLs for both and ask Claude to install it for you. If you want one prompt that will set up absolutely everything for you, it's linked in the description below in my video editing playbook. So that's the stack, means we can point it at some actual footage now.
So what I'm gonna do is try and one shot the intro for the video that we've just recorded. So let's go ahead and do that. But quickly, I wanna show you what I do in order to prepare the editor to actually get a good result on the first try.
So I have a folder on my computer with all of the footage that I have already recorded. So I've got my main cam footage which has all the clips and then I have the script. So we're only doing the intro, so I've only done the intro script so far.
But essentially, this is what I said as part of the intro. I actually create this in a Word doc or Google doc because I can then come in and add comments on what I actually want to do. So I tell it what intro music I wanna use.
I tell it to start zoomed in and then, uh, rapidly zoom out. I tell it, uh, what type of graphics I wanna create and if there's reference images that I wanna incorporate into those graphics, then I go and just grab a link to those. This is super super important because if you don't do the prework for the edit and you don't actually think about what you want the end result to look like, you're gonna end up with a really sort of AI slop looking video that doesn't, uh, really fit with what you're trying to create.
So now that I have that one folder on my computer, I can just go to Claude now and just say, just edit clip one, the intro is here, and then I just give it the file address of where that folder is located, so it's just in my movies folder, or you can just tell it, you don't need to do it that way. And then a little bit of a prompt about what I want.
So I always make sure to include like, hey, there is a word doc there with the script. Go and check the comments because those comments have all the information that you need. And then I also just include like a bit of a reminder, hey, use the watch skill for that self improvement loop that we talked about earlier.
And then we'll hit go. And now Claude is going to start on the rough cut and once that's finished, we'll come back and I'll show you what it looks like. So Claude just started working here and it's created a project called Claude code edits my videos.
You can see it has a few folders. We've got assets, which it's gone and found a bunch of assets that I linked to it. Uh, some of the screenshots from the YouTube videos that this harness has edited as well as it's gone and found that, uh, intro music that I, uh, wanted.
And then it's scaffolded some of the other folders that we'll need later. What it's doing now is it's running WhisperX, that local AI model, to go and transcribe that clip so it knows exactly where each, uh, word lands when I'm saying it so it can start to do that rough cut.
And the transcription has just landed. You can see how it looks here. We've got literally sub second timings for every single word that I say in this intro clip.
And this goes on for a couple 100 lines. So so this is what Claude will use to go and find that rough cut and find any silences or gaps. So it looks like the rough cut has just landed, I'll open that up now.
All I do is drop my raw footage into this folder and Claude edits the entire video for me in one shot. It handles motion graphics like this, generates perfect AI b roll completely automatically, bakes in captions like these ones, and the music you're hearing right now.
All of it. This pipeline has edited every single video on this channel over the past month, but most people trying this are spending hours going back and forth with Claude because they're missing the one skill that turns AI editing into a completely autonomous video production engine. In this video, I'll show you how to build the entire thing, no gatekeeping, starting with how AI editing actually works.
So it's just absolutely nailed that rough cut and that's pretty expected because it's just a transcript that it needs to go and take out those, uh, silences and gaps. It's cut about I think it was about a minute thirty of footage down to thirty nine seconds. So now that it's got the rough cut, the next thing it's going to go do is read all my comments and start to create that graphics plan.
And that graphics plan is essentially based on all of the comments that we just gave it in that word doc. So it's going to go read all those and start generating some of that, um, AI b roll And then from there, it'll merge everything together. So we'll come back once that is done.
You can see that it started rendering here in Higgs field. Now this is using c dance two at ten eighty p, so it's probably gonna take a few minutes. But while this is happening, Claude is actually still working.
It's gone through and started to do its graphics plan, and then it'll incorporate that footage once the footage is finished rendering. So it's just finished generating that AI b roll, and it looks pretty good. So that is now gonna be downloaded back into the project and then automatically merged in using hyperframes.
So Claude just completed the first version of the render, which means it hasn't gone through any of the revision loops yet. This is its first attempt and here it is. All I do is drop my raw footage into this folder and Claude edits the entire video for me in one shot.
It handles motion graphics like this, generates perfect AI b roll completely automatically, bakes in captions like these ones, and the music you're hearing right now. All of it.
This pipeline has edited every single video on this channel over the past month, but most people trying this are spending hours going back and forth with Claude because they're missing the one skill that turns AI editing into a completely autonomous video production engine. In this video, I'll show you how to build the entire thing, no gatekeeping, starting with how AI editing actually works.
I mean, it's interesting. That's an interesting take, but we'll we'll have to run with it. I think what I'll actually do, like, just to remind you, like, this is a brand new instance of this editor that I've just set up to do the demos.
So So I probably need to give it some more instructions about how it actually renders, uh, Claude. Um, but I might fix that up in the intro that you see at the beginning of this video, so don't hate me.
Now I can see Claude is going through the process of watching that video using the skill and going through frame by frame to find any bugs or any issues. It's gonna go fix it all now and then rerender and then we'll see the final result. Claude's just finished and it took about forty minutes to do this intro, but it's important to remember that Claude did this completely autonomously.
So the only thing I told it was to use the second copy of some b roll that it ended up regenerating and asked my input on. It's gone through and done two passes of technical q and a and composition of fidelity, and here is the final intro. All I do is drop my raw footage into this folder and Claude edits the entire video for me in one shot.
It handles motion graphics like this, generates perfect AI b roll completely automatically, bakes in captions like these ones, and the music you're hearing right now, all of it. This pipeline has edited every single video on this channel over the past month, but most people trying this are spending hours going back and forth with Claude because they're missing the one skill that turns AI editing into a completely autonomous video production engine.
In this video, I'll show you how to build the entire thing, no gatekeeping, starting with how AI editing actually works. Pretty good. There are a few little changes here that I'd probably make, but essentially, I think that's almost perfect.
Now the next step here is just to do the rest of the video. I've only done the intro, but that's exactly how the whole pipeline works. So the watch skill gives you the loop, but there are four other things that take these edits from pretty good to genuinely one shot.
Number one is the taste skill. Every graphic Hyperframes creates is basically front end design because it's building these graphics in HTML, which means that anything that makes Claude better at front end design makes your motion graphics better too.
And that's exactly what the taste skill does. Left to its own devices, Claude builds pretty much AI slop for graphics. The taste skill gives it rules that a designer would actually work to, so it all looks a little bit nicer.
I like it because it doesn't just give Claude a preset to follow, it gives it a design approach to make better graphics in any style. Number two is generated assets. I told you Higgs Field was being used for the b roll, but it also earns a spot a second time here because Claude can use it mid edit to generate an image or a short clip and drop it straight into part of a graphic.
And that changes what a graphic can be because up until this point, your graphics were just text, charts, and screen recordings, essentially limited by what HTML could do. But sometimes you want icons or graphics that hyperframes can't build with code. So you can get Higgs Field to generate them and then have hyperframes incorporate those new images into the graphic.
Number three is making your style file absorb every correction. Because right now, every note you give Claude in that final review is a note you're going to give it again next week. The rule I've got in mind is that any correction coming out of the review gets written back into that style file before the edit is closed out.
This is really, really important for getting this workflow fully automated over time because that way Claude is always learning from your inputs. And number four is the one that I think matters absolutely most to getting this done in one shot. It's not a tool, it's the prework that you put in before you even edit it.
One of the biggest learnings I've had from using this over the past month is that the more time you spend planning, the closer you will get these edits in one shot because the agent isn't guessing what you want anymore, It's just reading the comments from your script. Ten minutes of comments here will literally save you hours of back and forth, and it's the single biggest difference between an edit that comes back usable and that and one that comes back needing hours of back and forth with Claude.
So that's the whole system. I've actually packaged the entire pipeline into a guide with every prompt from this video, and you can grab it completely free at the link below. And if you wanna build the AIOS that runs this, that's what I'm teaching live at the FounderOS build shop on August 26.
The link is down there too.
The Hook
The bait, then the rug-pull.
The pitch: drop raw footage into a folder and Claude Code hands back a finished video — cuts, motion graphics, AI b-roll, captions, and music — with no manual editing. What makes that claim survive contact with an actual render is a review loop most people skip: an agent that can inspect the frames it just produced, not just the transcript it started from.
Frameworks
Named ideas worth stealing.
01:05list
The Five-Stage AI Editing Pipeline
Transcription
Rough cut
B-roll
Graphics
SFX / Export
Splits video editing into five sequential stages, each matched to a single-purpose tool, so a coding agent works through a checklist instead of one undifferentiated editing task.
Steal forAny agent-driven creative pipeline that needs to break a fuzzy end-to-end deliverable into stages a model can actually execute and check one at a time.
04:59model
The Agent Review Loop (Think / Observe / Act)
Think — the model decides what to do
Observe — a frame-inspection skill checks the actual rendered output
Act — tools execute the decision
Frames validation as a closed loop: the agent finishes a version, inspects it with a dedicated skill, and uses what that inspection finds to drive the next decision, repeating until a check passes.
Steal forAny agent task with a visual or otherwise-unverifiable output — force a real inspection step of the rendered artifact before letting the agent call the task done.
14:50list
The Four One-Shot Upgrades
Taste skill (design rules for graphics)
Generated assets mid-edit (AI images/clips dropped into a graphic)
A style file that absorbs every correction
Pre-work: detailed comments in the script before editing starts
Four additions layered on top of the base pipeline that are credited with taking results from usable to reliably correct on the first pass.
Steal forAny recurring AI-produced deliverable (decks, graphics, one-pagers) where the same corrections keep getting repeated across runs.
CTA Breakdown
How they asked for the click.
VERBAL ASK
16:51product
“I've actually packaged the entire pipeline into a guide with every prompt from this video, and you can grab it completely free at the link below. And if you wanna build the AIOS that runs this, that's what I'm teaching live at the FounderOS build shop on August 26.”
Stacks a free lead-magnet download with a paid live-workshop pitch at the very end, after the full pipeline has already been taught rather than gated behind either offer.
A Claude Code skill that turns real sales-call transcripts into a standing panel of customer-clone AI agents who argue back instead of agreeing with everything.
A screen-recorded walkthrough of turning a raw voiceover into a fully synced, AI-generated b-roll edit — using a timestamped transcript as the bridge between audio and images.
A creator wires Claude Code into DaVinci Resolve through a free MCP bridge and runs every stage of an edit live on camera, rough cut, motion graphics, and color grade, with a timer running so you can see exactly how long each pass actually takes.
A screen-recorded, un-sped-up walkthrough of five real motion-graphics jobs — rough cut, animated background, number counter, typography titles, Vox-style collage — built entirely by prompting Claude Code and letting it drive CapCut.
00:17
00:34
00:47
01:11
01:25
01:38
01:52
02:05
02:18
02:32
02:49
02:59
03:13
03:41
03:50
04:08
04:15
04:29
04:43
05:01
05:14
05:24
05:36
05:49
06:14
06:26
06:33
07:05
07:12
07:28
07:41
07:51
08:01
08:18
08:30
08:43
08:55
09:20
09:32
09:44
09:57
10:09
10:21
10:46
10:58
11:14
11:23
11:36
11:47
11:55
12:13
12:21
12:32
12:52
12:59
13:18
13:27
13:39
13:47
13:59
14:19
14:26
14:35
15:07
15:21
15:34
15:47
16:00
16:13
16:27
16:35
07:03
08:31
13:53
13:47
19:02
27:04