Build an AI content engine: one idea to a finished, scheduled video

The easy way: let Claude build it with you

This is the way I'd do it. You paste one prompt into Claude Code, and Claude turns into your setup helper. It asks you questions one at a time, tells you exactly where to click, and builds the whole thing with you. Your job is answering questions and clicking a few buttons. Claude does the typing.

What you need

• A computer. Mac, Windows or Linux. On Windows, you'll turn on WSL first (Windows' built-in Linux). It's one command and a restart. The steps are below.
• A paid Claude plan. Claude Pro ($20 a month) or higher. The free plan doesn't include Claude Code.
• About an afternoon. Most of it is waiting on accounts.

• A clear photo of you, with your eyes and mouth easy to see, and a short voice recording made in a quiet room. These become your AI avatar. Only you. Never anyone else.
• Two more accounts. Claude walks you through both. HeyGen Creator ($29 a month) makes your avatar and copies your voice. Upload-Post Basic ($24 a month) schedules your posts. HyperFrames, the video editor, is free.

• Your social accounts. Instagram has to be a Business or Creator account, and Facebook posts go to a Page.

That's $73 a month at list prices, checked on 2026-10-04. Prices change, so check each page before you buy.

Open Claude Code

Three quick steps. You'll paste a couple of lines into the terminal (the window where you type commands). Never opened one? Anthropic's terminal guide for new users walks you through it.

Open the terminal

• Mac: press Command + Space, type Terminal, and press Return.
• Windows: press Windows + X, pick Terminal (Admin), type wsl --install and press Enter. Restart when it's done. Then open Ubuntu from the Start menu and pick a username and password. Use Ubuntu from here on (Microsoft's steps).
• Linux: press Ctrl + Alt + T, or open Terminal from your apps.

Install Claude Code

Paste this line and press Enter. (Mac: Command + V. Ubuntu or Linux: Ctrl + Shift + V.) When it's done, close the window and open a new one.

curl -fsSL https://claude.ai/install.sh | bash

Make your folder and start Claude

This makes an empty folder, steps into it, and starts Claude. The first time, your browser opens so you can log in. If it asks whether you trust this folder, say yes.

mkdir -p ~/content-engine
cd ~/content-engine
claude

Paste in the setup prompt

Click Copy, paste it into Claude Code, and press Enter. Claude Code may show it as one short line that says Pasted text. That's normal. It's long on purpose: it tells Claude how to talk to you, what it must never do, and the order to build things in. You don't have to read all of it. The safety rules are worth a look, though.

The setup prompt (copy all of it) · lines 1-3 of 80. Copy all copies the whole prompt; read it in full on the page.

Hi Claude. Please be my patient setup helper for the next few hours.

I want to build a simple content engine in this folder. I type one idea. It makes a short vertical video of my AI avatar (a talking video of me, in my own voice) saying it, adds captions, and schedules it to my social accounts. I don't know how to code, so treat me like a smart beginner.

What to expect

• It starts with a chat. Claude says hi and asks you questions, one at a time: what you do, who you talk to, how you talk, where you post. Answer like you're texting a friend. Typos are fine. If it asks something you don't get, say so. It won't get annoyed. That's kind of the whole point.

• Then a shopping list. You get a short list of the accounts you still need, with links and which plan to pick. Sign up, then type “done.”
• Then the build. Claude makes your folder one piece at a time. After each piece, it runs a free test and tells you in one line if it worked.

• Then your keys. A key is a password for apps. Claude makes a private file called .env, opens it for you, and tells you where to get each key and which line to paste it on. Keys go in that file. Never in the chat.

• Claude Code asks before it does things. Before it runs a command or changes a file, it asks you. That's normal. Read the one-line reason, then say yes. If something looks off, say no and ask why.
• Nothing costs money or goes public without your yes. Making the avatar video uses HeyGen credits, and posting is public, so Claude asks first. Every time.

How long: plan on an afternoon. Most of it is waiting: HeyGen checking your avatar, each app confirming its connection, and the first video render.

What you'll have at the end: a folder on your computer that turns one idea into a finished video. Your first video, made and (if you said yes) scheduled, with the AI label on. And a short note from Claude on how to make the next one.

Need a break? Just close the window. When you're back, open the terminal and paste these two lines. Claude picks up where you left off. It keeps a checklist in SETUP-NOTES.md, too.

cd ~/content-engine
claude --continue

Want to see every step yourself? The manual way is below.

What you're building

This is the manual way: every step, every file and every command. Use it to do the whole thing by hand, or keep it open to check what Claude is doing. It's also what the setup prompt tells Claude to follow.

Here's the whole chain. Each box is one tool doing one job, and each one leaves a file behind. So when something comes out weird (it will), you can open the files in order and see exactly which step did it.

Words you'll see

• Terminal: the text window where you type commands. Terminal on a Mac; on Windows, your WSL (Linux) terminal.
• Claude Code: Anthropic's AI assistant that works inside a folder on your computer. It reads files, writes files, and runs the commands you allow.

• Headless: running Claude Code as claude -p "...". One instruction in, one result out, no chat window. That's what lets a script call it.
• Rule files: plain text files that say how you talk and what you never say. Claude reads them before every script.
• CLI: a command-line tool. HeyGen's is called heygen; HyperFrames runs as npx hyperframes.

• API key: a long password that lets a script use your account. Treat it like your bank PIN.
• Environment variable: a named setting a script reads, like UPLOAD_POST_API_KEY. Ours live in a file called .env that never gets shared.
• JSON: plain text with curly braces that holds structured data. The script and captions are saved this way so the next step can read them.

• Render: turning a project into an actual MP4 file.

Before you start

Four tools plus some plumbing. Here's what each one does in this build, which plan actually unlocks the part we use, and what it costs. Prices are list prices on 2026-10-04, US dollars.

HeyGen also bills yearly; check its pricing page for that figure.

Your computer

• macOS 13 or newer, Ubuntu 20.04+ or Debian 10+, or Windows 10 (1809+) through WSL. Windows has to be WSL for this build, because HeyGen's CLI runs on macOS and Linux, and on Windows only through WSL.
• At least 4 GB of RAM (Claude Code's minimum). Rendering likes more; HyperFrames switches itself to a low-memory mode at 8 GB or less.

• Disk space for video. Every run folder keeps its clips.

Time

Plan an afternoon for setup. Most of it is waiting: HeyGen validating your avatar, each social network confirming its connection, the first render. After that, a video is mostly machine time. Your part is reading the script and watching the cut, which, by the way, are the two parts you should never automate.

What you'll have at the end

• A folder (your engine) with your rule files, three prompts and three small scripts.
• One finished vertical video of your avatar, captioned and edited, in runs/<name>/final.mp4.
• That video scheduled to YouTube, Facebook, Instagram, TikTok and Threads, labeled as AI-generated wherever the platform supports it.

• A repeatable set of commands for the next one.

Setup, step by step

Do these in order. Every command goes in the terminal unless I say otherwise, and anything in <angle brackets> is yours to fill in.

Install Node.js, FFmpeg and Python

HyperFrames needs Node.js 22 or newer plus FFmpeg; the glue scripts need Python 3. On nodejs.org, take the LTS download (version 24 on the day I checked). FFmpeg's download page lists builds for macOS and Windows and the packages for Linux. Check first, though: you may already have some of these.

Install Claude Code and log in

You need Claude Pro, Max, Team or Enterprise, or an Anthropic Console account (the free plan doesn't include Claude Code). Install it, open a new terminal window, check the version, then start it once inside your new engine folder to log in.

Write your rule files

This is the whole repo. Small on purpose. Claude Code reads CLAUDE.md at the start of every session, headless ones included, and CLAUDE.md can pull in other files with @path lines. So your rules ride along on every call without you pasting them.

Save each block below as the file named on its label. Fill in the <angle brackets>. The before→after examples in VOICE.md matter more than anything else here: replace mine with three to five of your own.

Repo layout · Part 1 of 2 · Copy copies all 26 lines

content-engine/
├── CLAUDE.md               loads your rules into every Claude Code run
├── rules/
│   ├── VOICE.md            how you talk
│   ├── GUARDRAILS.md       what never goes out
│   └── banned.txt          phrases check.py fails on
├── prompts/
│   ├── 01-script.md        thought -> script.json
│   ├── 02-edit.md          avatar.mp4 -> final.mp4 (HyperFrames)
│   └── 03-captions.md      script -> captions.json, one per platform
├── engine/
│   ├── check.py            the guardrail check
│   ├── avatar.py           HeyGen render (Avatar IV)
│   └── post.py             Upload-Post scheduling, dry run by default
├── .env                    your keys and ids (never shared)

Repo layout · Part 2 of 2 · Copy copies all 26 lines

├── .env.example            the names, no values
├── .gitignore              keeps .env and runs/ out of git
└── runs/
    └── 2026-10-06-retest/  one folder per video
        ├── thought.txt
        ├── script.json
        ├── avatar.mp4
        ├── edit/           the HyperFrames project
        ├── final.mp4
        ├── captions.json
        └── sent.json       Upload-Post's replies (job ids)

CLAUDE.md

# My content engine

This folder turns one thought into a short vertical video and a scheduled post.
Every script, caption and word on screen follows these files:

@rules/VOICE.md
@rules/GUARDRAILS.md

Work only inside this folder. Never open, print or copy .env.

rules/VOICE.md · Part 1 of 2 · Copy copies all 17 lines

# How I talk

Who's talking: <your job title> at <your company>, explaining one idea to one
person, the way I would on a call. Casual, plain words, short sentences, a little
dry humor where it fits. Not a training video. Not a stand-up set.

- Open with the point or a question. Never "In today's video".
- One idea per video. Two ideas means two videos.
- Explain any technical word the first time it comes up, in plain words.
- End on the lesson, or a question to the viewer.

## Before -> how I'd actually say it
Replace these with 3-5 of your own. They teach Claude more than any adjective.
- "Leverage AI to streamline your operations."
  -> "I let the AI do the boring first draft. I still read it."

rules/VOICE.md · Part 2 of 2 · Copy copies all 17 lines

- "Consistency is key to social media success."
  -> "Posting twice and vanishing for a month mostly trains people not to wait for you."

rules/GUARDRAILS.md

# Never publish

- I'm the <exact title> of <company>. Never call me anything else.
- I appear only as my own avatar, in my own voice. Nobody else's face, voice or name.
- No numbers stated as facts unless they're in my thought. No "studies show".
- No income, revenue or results promises. No guarantees. No testimonials.
- No client names, customer details, or anything from a real account or screen.
- Every video says it was made with an AI avatar (on screen and in the caption).
- Scripts run 60-110 words. Banned phrases live in rules/banned.txt, and
  engine/check.py fails anything that uses one.

Add the HyperFrames plugin to Claude Code

HyperFrames is HeyGen's open-source “write HTML, render video” framework. The plugin teaches Claude Code how to build a valid HyperFrames project; the CLI renders it on your machine. The first npx run downloads the CLI, so give it a minute.

Install and check

claude plugin marketplace add heygen-com/hyperframes
claude plugin install hyperframes@hyperframes
claude plugin details hyperframes   # should list hyperframes, general-video and media-use
npx hyperframes doctor             # checks Node.js, FFmpeg and Chrome

Make your avatar and clone your voice in HeyGen

Sign up and pick a plan (Creator is where voice cloning and 1080p show up). Then:

1. Avatar: open the Avatars tab, choose New Avatar, then Upload Photo. Use a photo of you with your eyes, mouth and lips clearly visible and your face filling a good part of the frame. Name it and submit. It has to be validated before you can use it.

2. Voice: open the Voice section, click + New Voice, then Create New Voice, and pick Instant Voice Cloning. Record or upload a clean sample of you talking in a quiet room. HeyGen's tip: keep a mic 6 to 8 inches from your mouth, and not rubbing on your shirt.

Want a different outfit or setting later? Generate a new look from your own photo (HeyGen lists one credit per look). New looks of you: fine. Anybody else's face: no.

Install the HeyGen CLI and find your two ids

The CLI is how avatar.py talks to HeyGen. It can log in two ways, and they bill differently:

• OAuth (heygen auth login --oauth): a browser sign-in; renders use your subscription credits. HeyGen's CLI readme describes this route for “Pro / Max subscription users”; it works on my Creator plan.
• API key (from app.heygen.com/developers/api): renders draw on a separate pay-as-you-go API balance in US dollars, which needs no plan and is kept apart from your plan credits.

Pick one; the CLI keeps one login at a time. Then copy your look id and your voice id into .env as HEYGEN_AVATAR_ID and HEYGEN_VOICE_ID. If avatar looks list asks for more, heygen avatar looks list --help shows the options.

Install, log in, find the ids

curl -fsSL https://static.heygen.ai/cli/install.sh | bash
heygen auth login --oauth          # or: heygen auth login --api-key
heygen auth status                 # which login is active
heygen avatar looks list          # JSON: find your photo avatar by name, copy its look id
heygen voice list                  # JSON: find your cloned voice, copy its id
heygen video create --request-schema   # every field a render request accepts

Set up Upload-Post and connect your accounts

1. Sign up at upload-post.com. Pick Basic if you want TikTok; the free plan can't post there.
2. Open Manage Users and create a profile. The name you type is what the API calls user; put it in .env as UPLOAD_POST_PROFILE.
3. Click each network (YouTube, Facebook, Instagram, TikTok, Threads) and finish its sign-in.

4. Open API Keys, click Generate New API Key, and paste it into .env as UPLOAD_POST_API_KEY. You won't need to look at it again, and you shouldn't.

Two gotchas before you hit them. Instagram has to be a Business or Creator account; personal accounts can't post through the API. And Facebook posts go to a Page: if your login manages more than one, find the right Page id with the second call below and put it in .env as FACEBOOK_PAGE_ID.

Check the key, then list your Facebook Pages

set -a; source .env; set +a   # load .env into this terminal window
curl -s -H "Authorization: Apikey $UPLOAD_POST_API_KEY" https://api.upload-post.com/api/uploadposts/me
curl -s -H "Authorization: Apikey $UPLOAD_POST_API_KEY" https://api.upload-post.com/api/uploadposts/facebook/pages

Add the three prompts and the three scripts

The prompts are plain-English instructions Claude follows. The scripts are the glue: one checks the guardrails, one calls HeyGen, one calls Upload-Post. Save each block as the file named on its label. Read every line; there's nothing clever in them, which is the point.

prompts/01-script.md · Part 1 of 2 · Copy copies all 16 lines

Write a short-video script from my thought. You're given a run folder (runs/<name>).

1. Read <run>/thought.txt. That's my idea, in my words.
2. Write the script I'll say to camera as my avatar, following CLAUDE.md and the
   rules it imports:
   - 60-110 words (about 25-45 seconds), one idea, plain words.
   - The first sentence is the hook: the point, or a question.
   - End on the lesson, or a question to the viewer.
   - Keep my phrasing wherever it works. No numbers, names or results I didn't give you.
3. Write <run>/script.json with exactly these keys:
   {"title": "the hook as a title, 60 characters max",
    "script": "the full script as plain text",
    "word_count": 0,
    "notes": ["anything you changed or dropped from my thought, and why"]}

prompts/01-script.md · Part 2 of 2 · Copy copies all 16 lines

Don't create or edit any other file. End with one line: DONE or FAILED <reason>.

prompts/02-edit.md · Part 1 of 2 · Copy copies all 21 lines

Use the /hyperframes:hyperframes skill. Finish the video for the run folder you're given (runs/<name>).

What's there:
- <run>/edit/ is a HyperFrames project made by `npx hyperframes init` from <run>/avatar.mp4
  (my avatar talking, 1080x1920). The clip is placed; nothing is designed yet.
- <run>/edit/transcript.json has the speech timings from Whisper, if transcription worked.
- <run>/script.json has the title and the exact words.

Build:
1. Keep the avatar clip and its audio exactly as they are: no trims, no speed changes.
2. Readable captions in the lower third, a few words at a time, timed to the audio.
   Use script.json for the exact words. Captions never cover my mouth or eyes.
3. A title card over the first 2 seconds with the title from script.json.
4. At most two simple graphics, only where they show what I'm saying at that moment
   (a short checklist, a before/after, one key phrase). My face stays on screen at least half the time.

prompts/02-edit.md · Part 2 of 2 · Copy copies all 21 lines

5. A small "AI avatar" label in a top corner, visible the whole time.
Every word on screen follows CLAUDE.md.

Then run `npx hyperframes check <run>/edit` and fix every error it reports.
Render with `npx hyperframes render <run>/edit --output <run>/final.mp4`.
Don't touch files outside <run>. End with one line: DONE <path> or FAILED <reason>.

prompts/03-captions.md · Part 1 of 2 · Copy copies all 17 lines

Write the post captions for the finished video. You're given a run folder (runs/<name>).

Read <run>/script.json and follow CLAUDE.md. Write <run>/captions.json with exactly this shape:
{"youtube":   {"title": "the hook, under 70 characters",
               "description": "2-3 short lines, then: Made with my AI avatar.",
               "tags": ["3-6 plain tags"]},
 "facebook":  {"title": "the hook",
               "description": "1-3 short lines, then: (Made with my AI avatar.)"},
 "instagram": {"caption": "hook line, one or two short lines, 3-5 hashtags at the end"},
 "tiktok":    {"caption": "hook line, one short line, 3-5 hashtags"},
 "threads":   {"caption": "one or two lines ending in a question, under 400 characters, no hashtags"}}

prompts/03-captions.md · Part 2 of 2 · Copy copies all 17 lines

Write each one for its platform, not one caption pasted five times. No links in the Instagram
or TikTok captions (they aren't clickable there). No "follow for more" bait. Nothing that
isn't in the script.
Then run `python3 engine/check.py <run>` and fix captions.json until it prints PASS.
End with one line: DONE or FAILED <reason>.

engine/check.py · lines 1-12 of 66. Copy all copies the whole file; read it in full on the page.

#!/usr/bin/env python3
"""Guardrail check for one run. Prints PASS, or FAIL and every reason (exit code 1).

    python3 engine/check.py runs/<name>

Checks script.json (length, banned phrases) and, once it exists, captions.json (banned phrases, caption
lengths, links where they can't be clicked). Edit the numbers and rules/banned.txt to fit you.
"""
import json
import re
import sys
from pathlib import Path

engine/avatar.py · lines 1-13 of 54. Copy all copies the whole file; read it in full on the page.

#!/usr/bin/env python3
"""Script -> your avatar speaking it (HeyGen, Avatar IV, 9:16, 1080p), through the HeyGen CLI.

    python3 engine/avatar.py runs/<name> --dry-run   # print the request, spend nothing
    python3 engine/avatar.py runs/<name>             # render (spends HeyGen credits) -> runs/<name>/avatar.mp4

Reads HEYGEN_AVATAR_ID and HEYGEN_VOICE_ID from the environment or .env. The CLI handles login.
"""
import json
import os
import subprocess
import sys
from pathlib import Path

engine/post.py · lines 1-15 of 98. Copy all copies the whole file; read it in full on the page.

#!/usr/bin/env python3
"""Schedule a finished video on YouTube, Facebook, Instagram, TikTok and Threads through Upload-Post.

    python3 engine/post.py runs/<name> --at 2026-10-06T12:15                # dry run: print every job
    python3 engine/post.py runs/<name> --at 2026-10-06T12:15 --send         # really schedule it
    (add --tz Europe/London if you're not on US Eastern; leave out --at to post right away)

Needs runs/<name>/final.mp4 and captions.json, and a PASS from engine/check.py. Reads UPLOAD_POST_API_KEY,
UPLOAD_POST_PROFILE and (optional) FACEBOOK_PAGE_ID from the environment or .env. AI disclosure is on for
every job. The key is never printed.
"""
import argparse
import json
import os
import subprocess

Environment variables (names only)

These live in .env in your engine folder. .gitignore keeps it out of git. Never paste it into a chat, a doc or a screen recording.

First test: prove it before you spend a credit

First, make sure Claude actually reads your rules. Run this from inside your engine folder:

A good answer quotes your rules back: your title, your 60-110 word range, your actual banned phrases. When this guide was tested with the starter files above, it also pointed out the placeholders still unfilled and two phrases the rules forbid that weren't on the banned list yet. That's the kind of answer you want.

A bad answer is generic advice about “engaging content.” That means your files didn't load: check that CLAUDE.md is in the folder you ran the command from, and that its @rules/... lines match the file names exactly.

Test 2: the free half of the chain · Part 1 of 2 · Copy copies all 10 lines

mkdir -p runs/test
echo "I used to answer every new lead myself. Now an assistant drafts the first reply and I call back the ones that need me." > runs/test/thought.txt

claude -p "Follow prompts/01-script.md. Run folder: runs/test" --permission-mode acceptEdits --allowedTools "Read,Write"
cat runs/test/script.json
python3 engine/check.py runs/test
python3 engine/avatar.py runs/test --dry-run
npx hyperframes doctor

Test 2: the free half of the chain · Part 2 of 2 · Copy copies all 10 lines

set -a; source .env; set +a
curl -s -H "Authorization: Apikey $UPLOAD_POST_API_KEY" https://api.upload-post.com/api/uploadposts/me

What good looks like: script.json has a title, a script that sounds like you, and a notes list explaining what Claude changed; check.py prints PASS (… words); the dry run prints the HeyGen request with your two ids, "engine": {"type": "avatar_iv"}, 9:16 and 1080p, and says no credits were spent; doctor finds Node.js, FFmpeg and Chrome; Upload-Post answers with your email and plan. The script step took about a minute when this guide was tested.

If check.py prints FAIL, that's the guardrail doing its job. Read the reasons, fix the thought (or the rules, if they're wrong for you), and run the script step again.

One video, start to finish

The real thing, in the order I'd run it, with the thought from the episode. Swap in yours. Only two steps spend money (the avatar render and the post), and both wait for you first.

Write the thought

One thought, in your words, no polish. Numbers only if you can back them up. Here's the one from the episode:

Make the run folder and the thought

mkdir -p runs/2026-10-06-retest
cat > runs/2026-10-06-retest/thought.txt <<'EOF'
For a while my AI avatar just wasn't worth it. A cloned
voice over my screen recordings was cheaper and honestly
looked better, so I said no. Then the avatars got good
enough, and I switched. This isn't really about avatars.
Pick the cheapest thing that clears the bar today, and put
a date on the calendar to re-test whatever you said no to.
EOF

Turn it into a script

acceptEdits lets Claude write files without stopping to ask, and the only tools it gets are Read and Write, so apart from basic file commands it can't run anything in this step.

Read it, then run the guardrail check

Read it out loud. If it doesn't sound like you, edit script.json by hand, or rerun step 2 with a note on the end (“shorter, less formal”). This is approval gate one, and it's yours.

Render your avatar (this one spends HeyGen credits)

The dry run shows exactly what goes to HeyGen. The real run waits for the render and downloads avatar.mp4. Avatar IV is named in every request instead of left to HeyGen's default, so a default changing on their side can't quietly swap the engine on you.

Start the edit project

This makes a 1080×1920 HyperFrames project with your clip already placed, and transcribes the audio with Whisper into transcript.json, all on your own machine. Nothing is designed yet; that's the next step. The first run can take a while because it sets up Whisper (about 12 minutes on the Mac this guide was tested on). A hyperframes check on this bare project can fail on purpose (there's no animation yet), so don't panic.

Let Claude design and render the edit

Claude uses the HyperFrames skills to add captions, a title card and a graphic or two, runs npx hyperframes check until it's clean, then renders final.mp4. This is the slow step. The allowed tools let it edit files and run HyperFrames, ffprobe and ffmpeg, and nothing else that changes your machine.

Watch it. All of it.

With sound, start to finish, on your phone if you can. Do the captions match the words? Is anything covering your mouth? Is the AI label there? If not, fix it in plain English (there's a prompt for that under Real use) and render again. Approval gate two.

Write the captions for each platform

Claude writes one caption per platform, then runs the guardrail check itself and fixes the captions until it passes. Run the check once more yourself; trust, but verify.

Schedule it, and label it

The dry run prints every job it would send. Read it, then add --send. The time is read in the --tz you give it (US Eastern by default), and it has to be in the future and no more than 365 days out.

Why four jobs instead of one? In my own setup on 2026-09-27, a scheduled job carrying a separate caption for Instagram and TikTok showed only the shared title on those two. So the script sends Instagram, TikTok and Threads as their own jobs, each with its caption as the title. YouTube and Facebook go together because their own fields worked. Every job carries is_ai_generated=true, and the Facebook job adds facebook_is_ai_generated (more on why below).

See or cancel what's scheduled

set -a; source .env; set +a
curl -s -H "Authorization: Apikey $UPLOAD_POST_API_KEY" "https://api.upload-post.com/api/uploadposts/schedule?profile_username=$UPLOAD_POST_PROFILE"
curl -s -X DELETE -H "Authorization: Apikey $UPLOAD_POST_API_KEY" https://api.upload-post.com/api/uploadposts/schedule/<job_id>

Real use: prompts for real jobs

Start claude inside your engine folder and paste one of these. Swap <name> for the run folder. Claude will ask before running commands, which is fine: you're right there.

4 · A quick critic before you watch

Use ffmpeg to save a frame from runs/<name>/final.mp4 at 0.5 seconds and then every 3 seconds into runs/<name>/frames/. Look at each frame and list anything wrong: text too small to read on a phone, a caption touching my face, a graphic that doesn't match what I'm saying at that moment, a frame that's mostly empty, a missing AI avatar label. One line each: time, problem, fix. Don't change any files.

Number 4 is a baby version of my critic. It's surprisingly good at spotting the caption sitting on your chin before your audience does.

What it costs to run

List prices on 2026-10-04, not a quote. Prices change; check the pages linked at the bottom.

Billed yearly, Claude Pro is $17 a month ($200 a year) and Upload-Post Basic $16 a month ($192 a year). HeyGen bills yearly too; its page has the number.

What HeyGen's credits buy: HeyGen lists an Avatar IV photo look at 16 credits per minute of video. So 600 credits is about 37 minutes of avatar video a month, if every credit goes to that. A short is under a minute, but the same credits also pay for new looks (one credit each) and anything else you make in HeyGen. Unused plan credits roll over for one extra billing cycle.

Claude usage: every headless run counts toward your plan's limits (a rolling five-hour window plus a weekly cap on paid plans). One video's worth of runs is small, but a big batch can hit the cap; Claude's pricing page covers waiting, upgrading or paying for extra usage.

What my version adds (and this guide doesn't)

Honest part. What you just built is one clean slice. Mine is the same slice with a pile of guardrails and a feedback loop on top, and those took weeks of getting it wrong first. Here's what's in it, so you know what you're not getting from a diagram:

• A Studio page. A local web page where I pick a post type, type the thought, and watch each step run: Analyze, Avatar, Design, Captions, Publish. It stops for me after the script if I asked to read it, and always before Publish.

• A real precheck. Not just a banned-words list: a rules pack with my title rules, pace and length, and a list of facts, where a number only goes on screen if it's marked verified with a source.

• A scene designer and a critic. One agent plans the scenes from a library of tested layouts. A separate critic measures every cut (empty space, small text, tiny heads, captions running into faces, repeats) and fails it until there are zero fails. Nothing gets scheduled before it passes.

• Recipes. Every post gets a recipe (hook, opening, look, caption style, transitions, length) under no-repeat rules, so the feed doesn't turn into the same video forty times.
• Analytics back into the plan. Every three hours it pulls each post's numbers per platform, compares posts at the same age, and next week's plan tests one thing at a time.

• Comment GUIDE. Upload-Post's AutoDM watches an Instagram post's comments for the keyword and DMs this page. Its docs cap it at 2 new monitors per profile a day and 15 days per monitor, with 10 DMs a day on the free plan and 500 on paid.

Start with the slice. Add a critic the first time a video makes you wince.

When it breaks

Limits worth knowing

• Claude: a rolling five-hour usage window plus weekly caps on paid plans.
• HeyGen: your plan's monthly credits (Avatar IV photo look: 16 per minute of video); unused credits roll over one extra billing cycle.
• HyperFrames: no render fees locally. It needs Node.js 22+, FFmpeg and Chrome (doctor checks all three).

• Upload-Post: the daily caps per connected account above; it also flags duplicate or near-duplicate posts to the same account within 48 hours. Scheduling goes up to 365 days ahead.
• Caption length (Upload-Post's limits page): Instagram and TikTok 2,200 characters, Threads 500 (counted in bytes, and an emoji is 4). check.py enforces these three.

What each tool can see

• Claude Code runs on your machine and works in the folder you start it in: your thought, rules, scripts and captions. To get answers it sends your prompts and the model's replies to Anthropic, and it keeps session transcripts on your computer under ~/.claude/projects/ (30 days by default). In these commands it can only use the tools you list.

• HeyGen has your photo, your voice sample, every script you render and the videos.
• HyperFrames renders on your machine. The CLI checks its skills against GitHub and has a telemetry command for its anonymous usage data.

• Upload-Post holds the connections to your social accounts and can post as them. It sees every video and caption you send, plus analytics and comments when you ask for them.

How to disconnect

• Upload-Post: Manage Users → disconnect each network. Manage or replace the key on the API Keys page, and delete it from .env.
• HeyGen CLI: delete ~/.heygen/credentials (that's where the login lives). If you used an API key, remove it from your shell too, and manage it from the API dashboard where you made it (app.heygen.com/developers/api).

• Claude Code: type /logout in a session. claude plugin uninstall hyperframes@hyperframes removes the plugin. To remove Claude Code itself (native install): rm -f ~/.local/bin/claude and rm -rf ~/.local/share/claude.

The official docs behind every claim

• Claude Code: Advanced setup
• Claude Code: Terminal guide for new users
• Microsoft: Install WSL
• Claude Code: Run Claude Code programmatically
• Claude Code: Memory (CLAUDE.md)
• Claude Code: Tools reference
• Claude Code: Commands
• Claude Code: Data usage
• Claude: Plans and pricing

• HeyGen: Pricing
• HeyGen Help: How to use credits
• HeyGen Help: API pricing explained
• HeyGen Developers: CLI
• HeyGen CLI on GitHub
• HeyGen Developers: API key
• HeyGen Developers: Create video (v3)
• HeyGen Developers: Avatar IV
• HeyGen Developers: Avatar consent

• HeyGen Help: Photo avatars
• HeyGen Help: Voices
• HyperFrames on GitHub
• HyperFrames: Quickstart
• HyperFrames: Install the plugin
• HyperFrames: CLI reference
• HyperFrames: Add an avatar presenter
• Upload-Post: Pricing and limits
• Upload-Post: Quickstart

• Upload-Post: Upload video
• Upload-Post: Labeling AI-generated content
• Upload-Post: Manage scheduled posts
• Upload-Post: Current user and Facebook Pages
• Upload-Post: Common errors
• Upload-Post: Character limits
• Upload-Post: FAQ
• Upload-Post: AutoDM monitors
• Node.js: Releases

• FFmpeg: Download
• Python: Downloads

What each page backs up is listed at the end of the full guide.

That's the slice

One thought in, one labeled, scheduled video out, and you approve the script and the cut before anything goes anywhere. Build it, break it, then add the pieces from my version one at a time.

Want help setting this up? Receipts Group builds these systems.

Open the full guide as a page (every file in full, plus the table of contents).