Source: raw/Opus_5.5_Video_Editing_is_Unbelievably_Good_master_it_in_12_mins.md, raw/Turn_Claude_Into_a_Video_Editing_GENIUS_in_3_simple_steps.md, raw/GPT6_Astra_one-shots_motion_graphics_like_never_before_NEW_Skill.md (auto-caption transcripts, fetched 2026-10-27)
Creator: Robo Nuggets (host Jay) · Platform: YouTube · Skill level: operator
Videos:
- “GPT6 Astra one-shots motion graphics like never before” — youtube.com/watch?v=Ce1Ym1HGyBA · 14:30 · published 2026-09-15
- “Opus 5.5 Video Editing is Unbelievably Good” — youtube.com/watch?v=YKFpSe28mlg · 12:55 · published 2026-09-29
- “Turn Claude Into a Video Editing GENIUS in 3 simple steps” — youtube.com/watch?v=uaVYHiF8f7k · 15:47 · published 2026-10-02
Three Robo Nuggets videos from September and October 2026 describe one method, run on three different models (GPT-6 Astra in Codex, Opus 5.5, Sonnet 5.5). Jay turns raw talking-head footage into motion-graphics edits with an /animate skill. The animation is written as HTML, CSS and JavaScript, with no generative video model. His argument is that a one-prompt skill gives you the model’s default look, and quality comes from refining the skill: a real design system, storyboards before full renders, timestamped review comments, and folding each round of feedback back into the skill. This article merges the three videos into one playbook. The paid community, its templates and the community’s own editor are left out, except where the editor shows a pattern you can build yourself.
Key Takeaways
- The video is code, not pixels. In all three videos the motion graphics are HTML/CSS/JS rendered to video. Jay had Opus 5.5 diagram its own toolchain in Excalidraw: HTML, CSS, JavaScript, three.js and FFmpeg. He stresses that the Opus 5.5 test used neither HyperFrames nor Remotion. The Astra version uses HyperFrames as its render engine. Either way, every element can be selected and changed afterwards, which is the property The Edit Is Text builds on.
- Unrefined vs refined skill. You can create an
/animateskill with one prompt (raw footage in, edited video out). Jay’s warning: its output is the model’s defaults, and “every other person who uses this prompt without refining their skills gets this same design aesthetic”. He calls that “vibe-coded slop”. What separates his reels is the refinement work, not the model. - A three-level ladder (Opus 5.5 video).
- One-shot. A single prompt produces a showreel. He keeps one ceiling-pushing prompt and reruns it whenever a new model ships, as a capability test. It also works for building a portfolio quickly.
- Storyboard first. Ask for still frames of each scene plus a written description of the motion, before any rendering. That way the model cannot spend all its tokens on a wrong full render, and you can steer it while changes are cheap.
- Direct the finished render. Review the actual video, audio and sound effects included, and send timestamped fixes. He estimates that storyboard feedback alone gets you “80 to 90%” of the way.
- Step 1 for talking-head footage: transcribe, then cut. Claude needs a transcript to remove pauses and false takes (his instruction in one case: “keep the latest take”). Jay’s toolchain figures, as he states them:
- AssemblyAI is his choice: about 42 seconds per hour of audio. The cost is captioned as “around 21” per hour with the unit dropped. It may be cents; unverified.
- Whisper is free and local but runs on your CPU: 15 to 50 minutes per hour of audio.
- ElevenLabs Scribe suits you if you already subscribe. He says it takes about 40% longer than AssemblyAI.
- Step 2: a design system is the main lever. Generic prompts disappoint. Codify a style, then call it by name. His sources:
- Refero Styles
DESIGN.mdfiles. He says it holds “2,000 plus” design systems; his Duolingo and Figma demo reels came from them. - Your own brand site’s design system. The Robo Nuggets palette carries straight into his reels.
- Galleries of Claude-made motion videos. The captions give “skillery.dev” and “watchshups.com”; neither name was verified.
- Reverse-engineer a video you like. Give Claude the post link, have it take FFmpeg screenshots into a contact sheet, then ask it to write a design system from those frames. He used this on design themes credited to “Vincent Wei” on X (spelling as captioned).
- Refero Styles
- Add rules the way you would brief a human editor. After one or two test videos, write bullet-point feedback in the same session. His examples from the Astra session:
- When a number is spoken, show a big hero number counting up (“four free plugins” becomes hero text).
- Shorten URLs in browser mockups, which were getting truncated.
- Take screen recordings in a mobile browser when the output is vertical.
- Cut the unnecessary eyebrow text.
- Stop defaulting to the browser-mockup layout every time.
- Build an element library. Keep reusable 3D elements, layouts (the browser mockup), motion presets, infographics and diagrams, generated images, icons and logos, backgrounds, sound effects and music. Pick items, copy their file paths into the prompt, and the render uses them. The library grows every time you use the skill.
- Step 3: direct with anchored comments, then calibrate. His review UI ties each comment to a timestamp and to the exact point clicked in the frame. He copies all comments and sends them to Claude in one message. Two loops follow:
- Corrections to the cuts go back into the skill, so future cuts match how he speaks.
- The session’s design and animation feedback is folded in with a prompt like “calibrate my
/animateskill with this feedback”. If the skill already exists, have Claude update it “based on skill creation best practices”.
- Model notes (creator’s assessments):
- Sonnet 5.5 is “half the token cost” of Opus 5.5. That matches the list prices (10 vs 20 per MTok). He found its animations comparable, across flat-vector, isometric, 3D, glassmorphism and Vox-style cutout styles.
- With Opus 5.5 he needs “less and less comments” per video. He says his Opus-edited tips video passed 300,000 views.
- GPT-6 Astra in Codex runs the same three-step method. He adds that Claude Code with Fable also works.
- Ask for SVGs for icons, illustrations and diagrams. They scale without blurring, you can edit colors by hand, and Claude can animate them.
- Taste is the differentiator. His conclusion: when anyone can one-shot a showreel, what sets your videos apart is your taste plus your review system. One person plus Opus 5.5 can now produce a full motion-graphics video, but with “a lot of human review involved”.
Try It
- Make an unrefined
/animateskill in one prompt. Name the tools: a transcription API, HyperFrames or plain HTML/JS rendering, and FFmpeg. Run it on a 1 to 2 minute talking-head clip, and keep that output as your baseline. - Transcribe and cut first. Use AssemblyAI if speed matters, or Whisper locally if cost matters. Ask Claude to drop pauses and false takes, then check the cut before any animation.
- Pick or extract a design system. Copy a Refero Styles
DESIGN.md, or have Claude build one from an FFmpeg contact sheet of a reference video. Save it as its own skill or reference file and call it by name. - Storyboard before rendering. Ask for one still per scene plus a one-line motion description. Comment per frame, then approve.
- Review the render with timestamps, sound effects included. Batch every note into one message.
- Calibrate. In the same session: “Update my
/animateskill with the rules from this session’s feedback.” Repeat after every video; each round should need fewer notes. - Start an element library folder (layouts, icons, SFX, backgrounds), and refer to assets by path in your prompts.
- Rerun your one-shot benchmark prompt whenever a new model ships, to see where the ceiling has moved.
Implementation
Tool/Service: A coding agent (Claude Code, or Codex for GPT-6 Astra). A transcription API: AssemblyAI, Whisper locally, or ElevenLabs Scribe. A render path: HyperFrames, or the model writing HTML/JS directly, with FFmpeg. Optionally, a review UI that attaches timestamps to comments.
Setup: Prompt the agent to sign you up for and connect the transcription API; it walks you through getting an API key. Keep the skill folder small at first, then add rules, the design system reference and the element-library paths as you refine.
Cost: The model’s tokens (Sonnet 5.5 is half Opus 5.5’s per-token price) plus transcription. No per-render generation fee, because nothing calls a video model.
Integration notes: A review interface is optional; chat feedback works. Jay prefers an interface because comments carry the timestamp and the exact point in the frame. HyperFrames’ timeline and studio tooling is a free place to start. The skill-refinement loop is the general pattern in Skill Design Patterns, applied to video.
Counterpoint (2026-11-11): batch your skill updates
Peter Yang warns that updating a skill after every session “tends to like overfit into whatever your current conversation is”. He starts a new thread that looks through several weeks of threads to “find some common patterns so that it doesn’t overfit to one thing”, and applies only repeated feedback through a skill-editor skill. This is advice that differs from this playbook’s update-after-every-video step, not a factual conflict. See Peter Yang’s one-person AI system.
Open Questions
- The AssemblyAI cost is garbled (“around 21” per hour with no unit). Check current AssemblyAI pricing before budgeting.
- The transcription speed figures (42 s per hour, Whisper 15 to 50 min, Scribe “40% longer”) are the creator’s numbers, with no benchmark shown.
- “skillery.dev”, “watchshups.com” and “Vincent Wei” are auto-caption spellings. They are unverified, and the galleries may have other URLs.
- The review editor shown is a community product (captioned “Rubric editor”). Whether an open tool offers the same click-to-anchor comments was not checked.
- Mel’s feedback rules (this topic’s AGENTS.md) were not compared against this method. The reference there is an archived stub.
Related
- The Edit Is Text — Agentic Video Editing — why code-built edits are agent-editable and cheap to check
- Claude Motion Graphics — Video Model vs Code vs After Effects — another creator’s Opus 5.5 tests and the method choice
- Claude Dashboards and Motion — Anthropic’s hosted code-based animation, for Team and Enterprise
- HeyGen HyperFrames — the open-source render engine in the Astra version
- video-use — an open-source, transcript-driven cutting skill for step 1
- Refero Styles — the
DESIGN.mdsource for step 2 - Anti-AI-Slop Defense Layers — the same “defaults equal slop” argument for web and copy
- Self-Improving Agent Loops — calibrating a skill from feedback, as a general loop