Sep 27, 2026year 2026relevance 48518 min read

Claude Opus 5.5 · Build an AI Shorts System with Shortify

Duncan Rogoff turns one topic into a polished vertical video with an AI avatar, motion graphics, captions, music and a comment-to-DM ending. This guide maps the full Shortify workflow, checks the creator-reported $8.34 cost, and organizes all 11 prompts from the companion PDF.

Video credit: Duncan Rogoff | Learn Claude Code.Source video: Opus 5.5 Just Changed Video Editing Forever (free guide).

Quick Summary

Duncan Rogoff presents Shortify, a Claude Code skill that turns one topic into one vertical short with a face or AI avatar, timed captions, motion graphics, music, sound effects, a cover and platform-specific post copy.
The video describes an eight-step creative loop. The companion guide expands it into ten operational stages: topic card, keyword, hook, script lock, voice and face, visual dissection, build, QA, captions and cover, then scheduling after approval.
The creator reports replacing a $1,500 monthly editing budget with a typical cash cost of $8.34 per short when Claude is covered by his subscription. That figure is his September 2026 setup, not a universal price.
His largest variable cost is the HeyGen digital-twin render. Local FFmpeg and HyperFrames work is counted as $0 cash, but the estimate excludes setup time, review time, electricity and the cost of the computer.
The system is designed as a funnel, not just an editor. Each short has one topic, one comment keyword and one destination: a free guide, a long YouTube video or the paid community.
The guide's strongest production discipline is the approval loop: lock the script before generating the avatar, inspect contact sheets at phone size, fix defects, and never publish or schedule until a person says go.
All 11 starter prompts from the supplied Shortify guide are organized below. They are source material from Duncan Rogoff, with editorial notes where copying, platform rules or automated publishing require extra care.

--what to try first

Start with one topic and one measurable viewer action, not a batch of unrelated clips.
Lock the script before paying for voice or avatar generation.
Split each sentence into visual moments, then let the verb determine the motion.
Use real screenshots for proof and designed graphics for explanation.
Review frames at phone size and test the finished video with sound before approving it.
Automate preparation and QA, but keep publishing behind an explicit human approval step.

Credit, source and what the result proves

This article is based on Duncan Rogoff's embedded video, the supplied transcript and his companion guide, Build Your Own Shortify: A Claude Code Skill That Turns One Topic Into One Short. Rogoff says he spent 15 years as an art director and motion graphics designer, and that Opus 5.5 was the first model to produce automated shorts he felt comfortable publishing.

That is a creator report, not a controlled benchmark. His first AI-made short had about 2,500 views four hours after publishing and was performing comparably to some editor-made posts at that early checkpoint. One post, one account and a four-hour window cannot establish that AI editing always matches a professional editor.

Anthropic released Claude Opus 5.5 on September 22, 2026 and positions it for coding, agentic work and complex professional tasks. The video was published on September 27, 2026, so the workflow reflects an early implementation built during the model's launch week.

The system begins with a funnel, not a timeline

Rogoff originally wanted to turn long YouTube videos into Instagram Reels that send viewers back to the longer material. The guide makes the commercial loop explicit: one topic, one short, one comment, one DM and one warm lead. The short gives a useful payoff, leaves one question open and ends with one clear ask.

The guide divides topics into three lanes. Top-of-funnel posts, about 60% of the proposed mix, use creator outliers, rising repositories or new tools and deliver a free guide. Middle posts, about 20%, come from existing long videos and deliver the full video. Bottom posts, about 20%, use a lesson from the paid community and point to that community.

Treat those percentages as Rogoff's operating model, not a rule. The reusable principle is simpler: decide what the viewer receives before writing the script. A comment-to-DM promise should only be used on a platform where the automation is connected, tested and permitted. Other platforms should carry the direct link instead.

The complete Shortify workflow, from topic to approval

The video summarizes the process in eight steps. The PDF turns it into a ten-stage production chain. 1. Create a topic card with the source, evidence, lane and hook options. 2. Reserve a unique comment keyword. 3. Adapt a proven hook. 4. Write and lock the script. 5. Generate or record the voice and face. 6. Dissect the script into visual moments. 7. Build graphics, proof, captions and audio. 8. Run frame-by-frame QA. 9. Prepare platform captions and the cover. 10. Stop for human approval before scheduling.

The guide recommends developing each stage manually in an ordinary Claude Code session. Only after a prompt works three times in a row should it become part of the skill. This matters because an unreliable step becomes harder to diagnose once it is hidden inside a larger automation.

The deliverable per topic is roughly a 30 to 34 second, 9:16 video, plus one reserved keyword, platform-specific captions, a cover and a QA report. The system can accept a YouTube video, article, GitHub repository, website, product or lesson as source material, but the resulting claims still need to be verified against the original source.

Write for a cold viewer, then lock every word

The guide's script structure is hook, problem, steps, twist, a list of three, payoff and CTA. Rogoff uses numbers and social proof early, then a re-hook such as 'But here's the best part' before the payoff. He recommends 105 to 125 words for a short of about 30 seconds.

The guide says to adapt a winning hook while preserving most of its original wording. That may help analyze structure, but copying distinctive language too closely can create attribution, originality and platform-trust problems. A safer editorial standard is to study the mechanism, verify every number, credit the source where appropriate, then rewrite the hook in your own voice.

Run a cold read before generating the avatar. Every line should make sense to someone who has never seen the project, and every number should have a source. Write currency as spoken words for the voice, while captions can use numerals. Once approved, lock the script. Rogoff reports that an early short required eight avatar renders because the wording kept changing.

One sentence can contain several visual moments

Planning one graphic per sentence is too coarse. The guide breaks each sentence into moments with a start time, end time, job, drawable nouns and a verb. The verb suggests motion: 'turns into' can morph, 'pick one' can select, 'send it to' can show transfer, and 'you don't' can cut to the presenter.

Anything spoken in less than about half a second should usually update the current graphic rather than trigger a new shot. A claim should show real proof within two seconds. A number should be large and count up. A list should add one item on the word. A screenshot should be cropped to the exact detail being discussed and remain readable in about one second on a phone.

Rogoff's preferred balance uses screenshots and recordings as proof for roughly a quarter of the beats, with custom graphics carrying the explanation. That balance keeps the short grounded without forcing viewers to decode a full desktop interface on a small screen.

The production stack: avatar, FFmpeg, HyperFrames and audio

The AI avatar is generated with HeyGen from a short reference clip. Rogoff identifies this as the most expensive part of the workflow. A real camera recording removes that line item and avoids synthetic-identity concerns, while an AI twin needs clear consent, careful review and disclosure appropriate to the context.

FFmpeg handles local trimming, silence removal, zooms, stitching and media processing. HyperFrames, the open-source HTML-to-video framework from HeyGen, supplies programmable motion graphics and deterministic rendering. The guide also names Remotion and After Effects as possible graphics engines, so the prompt architecture is not limited to one renderer.

Captions appear one or two words at a time and should snap to word-level timestamps. Music sits below the voice, while quiet clicks, whooshes and shutters support visual changes. Rogoff generated the music with Suno through an external platform. Check music licensing, avatar rights, logos and source footage before commercial use.

Editing rules that improve clarity before retention

The hook holds without a cut until the first sentence ends. The problem line and the turning-point line can play full frame on the face. After that, cut when the idea changes and let a graphic build while the same idea continues. Something new can land about every second without replacing the entire shot every second.

Keep one idea per picture. Important text stays out of the top strip, bottom fifth and lower-right controls. The guide alternates dark and light visual runs on hard cuts when the topic changes, while the hook and ending return to the dark home style. The aim is visual punctuation, not random variation.

The title visible at frame zero is not necessarily the spoken hook. It should state the outcome in three to eight words, remain readable after profile-grid cropping and double as the cover. A coherent style sheet should define two or three colors, one or two fonts, caption behavior, motion rules and a short list of things never to do.

Use focused subagents, then review their work

Rogoff keeps the main Claude Code session for planning and assigns bounded jobs to helpers: topic scout, creator study, cold reader, graphics builder, script dissector and QA reviewer. Isolated context is useful when several tasks can run independently, but a simple task does not need another agent.

Each brief should stand alone. Give the helper the files to read, goal, constraints, budget and save path, then ask for a short report listing what it made and what remains uncertain. The main session should open the files and decide what is good before the next dependency starts.

QA is visual, not only programmatic. The guide asks for three frames per second, arranged into contact sheets and opened at full size. Review cut-off text, black frames, unreadable screenshots, caption collisions, premature visuals, unsafe placement, hook cuts, duration and loudness. Fix, render and repeat until the defect list is empty, then watch the complete export on a phone.

Covers, captions, comment automation and scheduling

The system generates a cover with GPT Image 2.5 and writes distinct copy for Instagram, Facebook, TikTok, YouTube, X and LinkedIn. Instagram and Facebook can open with the comment-keyword offer when the DM automation is active. Platforms without that response should end with the actual destination link.

Rogoff uses Blotato for cross-platform scheduling and comment-to-DM automation. Blotato's current site documents publishing, scheduling, comment replies, DMs and keyword triggers through its API and MCP. Availability, pricing and platform rules can change, so verify the live plan and test the flow from a second account before launch.

The guide is unambiguous about control: the skill stops and shows the video, cover, captions, links and QA report. Nothing posts until the operator approves it. Keep that gate. Also confirm that the resource is live, the keyword is unique, the link works and the automated reply does not promise something the user will not receive.

What one short cost in the creator's September 2026 setup

Rogoff's typical cash estimate is $8.34 per short when Claude usage is covered by his existing plan. The guide itemizes about $4.84 for one roughly 40-second HeyGen digital-twin render, $3.23 as the monthly scheduling and DM cost allocated across one post a day, $0.14 for a 2K cover, $0.12 for topic research and under one cent for reused AI music. Local rendering, captions and mixing are counted as $0 cash.

If Claude were billed through the API instead, the guide says to add about $13 per short, based on the median of the creator's previous five shorts. The transcript gives $13.30 for the example and describes a total of roughly $21 without the subscription. Anthropic's token pricing and every third-party plan can change, so calculate against current invoices rather than copying this total into a forecast.

The estimate excludes the computer, storage, electricity, setup time, source research, brand design, failed generations and human review. It also compares 30 automated shorts per month with 15 editor-made videos, so it is not a like-for-like quality or labor comparison. The useful lesson is where the money goes: lock the script, trim pauses and aim for one avatar render.

A practical order for building your own version

1. Choose one source you own or can use. 2. Define the viewer, lane, payoff and destination. 3. Create a small style sheet and six reusable graphics. 4. Write one script and run the cold read. 5. Lock it before recording or avatar generation. 6. Dissect it into timed visual moments. 7. Assemble one short with captions and audio. 8. Run contact-sheet QA and a phone review. 9. Create the cover and platform copy. 10. Test links and automation. 11. Approve manually and publish.

Repeat the manual process several times and record every failure. Only then combine it into a reusable skill. The final prompt below tells Claude Code to point to STYLE.md and GRAPHICS.md instead of copying large instructions into every run, to log spend and to keep a memory of corrected mistakes.

The 11 Shortify starter prompts

These prompts are reproduced from Duncan Rogoff's supplied Shortify guide and organized in production order. Replace every [BRACKET] before use. The guide calls them starting points, not a copy of his private implementation. Review permissions, attribution, platform rules, claims, links and every generated asset before publishing.

Prompt pack credit: Duncan Rogoff · Claude Code Club Shortify Guide.

1. Steal a proven hook (Write)

The guide's original hook-analysis prompt. Editorial note: use it to understand a successful structure, then avoid copying distinctive language or implying another creator's work is yours.

Here is a proven hook, word for word: "[WINNING HOOK]"
Source: [LINK], [VIEWS] views. The creator's median is [MEDIAN VIEWS].
My topic: [TOPIC]. My real numbers: [NUMBERS + WHERE EACH ONE IS FROM].
First check the ratio. If views are under 3x the median, stop and tell me to pick a different hook. Adapt it to my topic. Keep every other word and the word order. Swap only the slots: the tool, the topic, the number, the audience.
Give me 3 versions. For each, show the share of original words you kept (aim for 70% or more) and what you swapped.
Then read each one as a stranger who has never heard of me. Flag any word that won't make sense cold: inside terms, jargon, "it" or "this" with nothing to point at. Never add a number I didn't give you.

2. Lock the script with a cold read (Check, subagent)

Checks the entire script before voice or avatar generation. The human lock is the cost-control gate.

Here's my short script: [SCRIPT]. The lane is [TOP / MIDDLE / BOTTOM] and the last line must be: "[CTA LINE]".
Use a subagent that has never seen this project to check it before I record anything:
1) Read every line as a stranger. Flag any line that isn't clear on its own, and offer a plainer one.
2) Line 2 names the viewer's real problem in plain words.
3) Steps say "First" and "Then" out loud.
4) Every line ends on a noun or number a graphic can show.
5) 105 to 125 words. No hype word without a number next to it.
6) Money is written as words for the voice ("five dollars and seventy cents"). Numerals only in captions and graphics.
7) Every number has a source I gave you. Cut any that don't.
Return the fixed script and a list of what changed and why. Once I say "locked", don't change a word.

3. Lock my look (Style sheet)

Creates the reusable visual rules that keep each short on brand and readable at phone size.

Help me write a one-page style sheet for my short videos. My vibe is [3 WORDS, e.g. dark, bold, techy]. Here are 2 or 3 creators or screenshots I like: [LINKS OR IMAGES]. Give me: a dark look and a light look, one accent color for each, one or two fonts, how captions look, how things move in and out, and 5 things I should never do. Rule for every choice: a stranger reads any frame in about one second. Keep it simple, bold, big and clean. Save it as [FOLDER]/STYLE.md.

4. Study creators frame by frame (Research, subagents)

Use only videos you own, have permission to download, or can lawfully analyze. A public transcript and manually captured review frames can replace downloading where required.

I want to learn how these creators build their short videos: [LINK 1], [LINK 2], [LINK 3]. Start one subagent per video, all at the same time. Each one should: download the video, pull a frame every 0.5 seconds, get the transcript with timestamps, and write down: how long the hook holds, how often something new appears on screen, when the face shows, what the captions look like, what graphic sits under each type of line, and how the cover and the post caption work.
Each subagent saves notes to [FOLDER]/creator-name.md and reports back in under 150 words. Then combine them into one list of rules I could copy, with the timestamp that proves each rule.

5. Build a graphics library and its guide (Build, subagents)

Builds six reusable 9:16 components and a decision guide so the agent does not pick graphics at random.

Using [FOLDER]/STYLE.md, build a small library of reusable motion graphics for 9:16 video in [HyperFrames / Remotion / After Effects]. Start with 6: a big number that counts up, a list that adds one row per spoken word, a step ladder, a before/after, a prompt typing into the Claude app and getting an answer, and my ending card with a comment keyword. One subagent per graphic. Each takes text and timing as inputs, renders a 3-second test and saves a still.
Then write a one-page guide: which graphic for which kind of line (claim, number, list, steps, prompt, opinion, hook, ending), when to cut and when to keep building, a "never do" list, and the lines we have no graphic for yet. Save it as [FOLDER]/GRAPHICS.md.

6. QA this render frame by frame (Check, subagent)

Turns visual review into a repeatable loop. Automated checks help, but the operator should still watch the finished export.

Use a subagent to QA [VIDEO FILE]. Pull 3 frames per second and put them on contact sheets, then open the frames at full size. List each problem with its timestamp: text cut off or too small on a phone, empty or black frames, a screenshot you can't read in a second, captions on top of a graphic, something shown before it's said, beats too short to read, a cut during the hook, text in the app's safe zones. Also check length ([TARGET] seconds) and loudness.
Return the list, worst first. Then fix them, render again, and repeat until the list is empty. Save the sheets so I can look too.

7. Dissect a script into visual moments (Plan, subagent)

Maps timestamps, message function, nouns and verbs before choosing proof, graphics or presenter footage.

Take the locked script at [SCRIPT FILE] and the word timestamps from [AUDIO OR AVATAR FILE]. Use a subagent to split every sentence into small visual moments. For each: start and end time, its job (hook, claim, number, list item, payoff...), the nouns you can draw, and the verb. The verb picks the motion (turns into = morph, pick = pick, one to all = zoom out, send to = show it being sent). Then pick what to show from [FOLDER]/GRAPHICS.md: the real thing, a graphic, or my face. Rules: the hook has no cuts; anything under half a second is a step on the current graphic; claims show proof within 2 seconds; every screenshot must read in one second at phone size, or we build our own graphic instead. Show me the plan as a table before building.

8. Check a trigger word (Check)

Reserves a unique, pronounceable keyword before the script promises a comment-to-DM response.

I want [WORD] as the comment keyword for a short about [TOPIC]. Check it's free before I write the script. Look in my keyword list at [FILE], every comment-to-DM automation in [MY DM TOOLS], and my last [NUMBER] post captions. Reject it if it's used anywhere, if it's a common word people type anyway (yes, love, info, link), or if it's hard to spell after hearing it once. If it fails, suggest 5 short, fun, sayable words tied to the topic and check those too.
When one passes, add it to my list as reserved, with the topic and today's date. Never reuse a word that was retired.

9. Captions for every platform (Write)

Separates comment-enabled captions from posts that need a direct link. Confirm current platform limits before publishing.

Write post captions for my short. Script: [SCRIPT]. The comment gets: [THE THING]. Keyword: [WORD]. Link: [LINK].
Instagram and Facebook: line 1 is exactly
Comment "[WORD]" to get [the thing] + [the result].
Then a blank line, then the hook and the script as short one-line paragraphs. TikTok, YouTube, X and LinkedIn: no comment promise, since nothing answers comments there. Same hook and body, then end with the link. Five hashtags at most per platform. Plain words, no hype. Save one block per platform in one file, ready to paste.

10. Cover prompt skeleton (Image)

Creates a 9:16 cover designed to survive the profile-grid crop. Use logos and faces only when you have the rights to them.

A 9:16 short-video cover. Image 1 is my face. Image 2 is the [TOOL] logo. Top: that logo and the name "[TOOL NAME]" in large clean type. Middle: my face, centered, smiling, wearing [WHAT I WEAR], lit with bright, even studio light and true skin tones. Two equal app tiles at ear level, one each side, slightly behind my head: [TOOL 1] and [TOOL 2]. Under my chin, a tight two-line title: "[LINE 1]" / "[LINE 2]", line 2 on a [ACCENT COLOR] bar. Leave the top and bottom 13% empty.

11. Turn it all into a skill (Skill)

Combines prompts 1 to 10 only after the manual workflow has succeeded repeatedly. The prompt preserves the explicit approval gate.

We've now made shorts by hand [NUMBER] times. Turn this into a Claude Code skill called [NAME] that takes one topic and makes one short.
Steps: 1) read the topic card and its lane, 2) reserve a keyword that passes the check, 3) adapt a proven hook, 4) write the script and run the cold read, then stop until I say "locked", 5) voice and face, 6) dissect, 7) build, 8) QA until the list is empty (subagent), 9) captions per platform and a cover, 10) stop and show me everything.
Point to STYLE.md and GRAPHICS.md instead of copying them in. Log what each short spent. It must never post or schedule anything until I say go in that chat. Keep a list of the mistakes we fixed so it doesn't repeat them.

Video Timestamps

Claude Opus 5.5 Shorts Results00:00 AI-Generated Short Example00:56 Editor Costs vs AI Results01:56 Shorts to YouTube Funnel Strategy02:55 How to Research Winning Creators04:11 The 8-Step Shorts System04:47 How to Structure Short Scripts05:33 Splitting Scripts Into Visual Moments06:31 FFmpeg Editing and HeyGen Avatar07:18 Refining Motion Graphics and Captions08:03 Sound Effects and AI Music09:03 Editing Rules That Boost Retention09:49 Splitting Work Into Sub-Agents10:37 Thumbnails, Captions, and Auto-Scheduling11:36 Full Cost Breakdown Per Short12:21

FAQ

What is Shortify?

Shortify is Duncan Rogoff's Claude Code skill for turning one topic into one vertical short with a presenter or AI avatar, captions, motion graphics, audio, a cover, platform copy and a comment-to-DM ending. The public guide explains the method but does not provide his private code or exact settings.

Does Claude Opus 5.5 edit the video by itself?

Claude Code coordinates the workflow and writes or runs the production logic. FFmpeg processes media, HyperFrames or another graphics engine renders motion design, HeyGen can supply the digital twin, and external services handle music, images, scheduling and DMs. A person still approves the script and final output.

Does each AI short really cost $8.34?

That is Rogoff's reported typical cash cost in September 2026 when Claude usage is covered by his existing plan. It allocates the avatar, scheduling and DMs, cover, research and music. It excludes labor, hardware, electricity, setup, failed attempts and the Claude subscription itself. API billing added about $13 in his recent sample.

Do I need an AI avatar?

No. The guide explicitly lists using your own camera as the $0 alternative. A real recording can reduce cost and synthetic-identity risk. If you use a digital twin, secure consent and review the result carefully.

Why lock the script before generating the avatar?

Avatar services are often billed by duration or generation. Every wording change can trigger another paid render. Locking the script first also keeps voice, captions, graphics and timing aligned.

Why use subagents in the workflow?

Focused helpers can research, cold-read, plan graphics or inspect frames without filling the main planning context. They are useful for independent jobs with clear inputs and outputs. The operator still reviews the files and decides what passes.

Can the system publish automatically?

Technically it can connect to scheduling and comment automation, but the guide requires a manual approval gate. It should stop and show the finished video, cover, links, captions and QA report. Nothing should publish until the operator says go.

Can I copy the 11 prompts directly?

Yes, after replacing every bracketed placeholder and adapting the rules to your rights, tools, platform policies and brand. They are starting points. Test each stage manually several times before combining it into one automated skill.