A Claude skill that forces a render, inspect and fix loop on every video

The premise is that Remotion was never the bottleneck

The argument the project starts from is about who is at fault when an AI makes a dull video. The stated line is that Remotion is never the bottleneck, motion-design craft is.

The symptom is described precisely: asking an AI to make a video and getting flat fades and linear motion. That is the familiar output of a model asked to animate without a rulebook, and the fix is to give it one. This skill encodes the craft as hard rules plus a mandatory render, inspect frames, fix, re-render loop, so the model verifies its own output instead of shipping blind.

That is the whole idea, and it is a good one. Remotion is a React-based video framework that renders frames deterministically, so the hard part is not the rendering, it is knowing what a good animation looks like and being made to hold to it. Encoding that as ten non-negotiable rules and a checklist is more reliable than asking a model to be tasteful.

The project is an open source Claude agent skill for Anthropic's Claude, MIT licensed, and it works with Claude Code, Claude Desktop and Claude.ai. The last push was on 2026-08-12 and the repository publishes no GitHub releases.

The ten rules, and what they forbid

The rules are listed in a short version, and the short version is enough to see the philosophy.

Never linear interpolation, springs, bezier curves and clamp, always. Entrances animate two to three properties together. Stagger everything. Exits exist and are faster than entrances. A five-layer stack of background mesh, assets, graphics, grade, then grain and vignette. Every still gets Ken Burns, and footage uses OffthreadVideo. Idle elements breathe with sin-wave micro-motion. All timing derives from fps, with no magic frame numbers. One theme.ts, with no inline colors or easings. And render, inspect frames, fix, re-render, never ship unverified.

Several of these are aimed at the failure modes the project names. Linear interpolation everywhere becomes springs and bezier presets. Lonely opacity fades become three-property entrances of fade, rise and scale. Everything entering at once becomes staggered choreography with three to six frame offsets. Flat solid backgrounds become a drifting gradient mesh with grade, grain and a vignette stack.

The fps rule is the one with a technical consequence rather than an aesthetic one. If every duration derives from the frame rate, then changing the target frame rate changes the timing of the whole composition, and a clip made for one platform may need rethinking for another.

The verification loop is the part that makes it work

The rule that distinguishes this skill from a style guide is the last one: render, inspect frames, fix, re-render, never ship unverified.

The mechanics are spelled out. Claude renders the video with Remotion, extracts frames with ffmpeg, inspects them, fixes the issues it finds, and only then delivers. The comparison table makes the contrast explicit, listing ships unverified renders against ffmpeg frame extraction plus visual inspection, every time.

The verification step also gives the user a diagnostic. The install notes tell you to ask Claude to make a three second logo sting as a check, and say that Claude should read the skill before writing any code and should extract and inspect frames before delivering. A render shipped without frame checks means the skill is not loaded. That is a concrete, testable signal, which is more useful than a vague sense that the output looks better.

The rationale is also about honesty. A model asked to produce a video will happily produce one and describe it as finished. Forcing an inspection pass means the model has to look at what it made before claiming it works, and the examples shipped in the repository are each described as having gone through that loop before delivery.

What is in the package

The skill directory contains four things, and the layout is the specification of what gets taught.

The SKILL.md file is the workflow plus the ten non-negotiable motion rules, which is the part Claude always reads. A references directory holds motion-patterns.md, described as seventeen copy-paste components covering reveals, grade, grain, Ken Burns, counters, transitions and captions, and design-rules.md, which covers palettes, typography, pacing, sound and a checklist.

An assets directory holds a single file, theme.ts, a theme template with colors, easings and spring presets. Rule nine says one theme.ts, no inline colors or easings, so the template is where those values are supposed to live.

That structure explains how a skill can be both opinionated and adjustable. The rules are hard, but the theme file is where a brand's actual colours and easings go, so adapting the output to a specific identity means editing one file rather than arguing with the model.

The repository also ships remotion-motion-graphics.skill at the top level, which is the packaged form used for the Claude Desktop and Claude.ai upload path, and an examples directory that is a Remotion project with four finished compositions.

Installation differs by where Claude runs

The install paths are split by product, and the difference is where the skills directory lives.

For Claude Code per-user, so the skill is available in every project:

git clone https://github.com/haidrrrry/claude-remotion-skill.git
mkdir -p ~/.claude/skills
cp -r claude-remotion-skill/remotion-motion-graphics ~/.claude/skills/

For Claude Code per-project, so it can be shared with a team, the same three commands with the project directory instead of the home one:

git clone https://github.com/haidrrrry/claude-remotion-skill.git
mkdir -p .claude/skills
cp -r claude-remotion-skill/remotion-motion-graphics .claude/skills/

For Claude Desktop and Claude.ai the route is different again. You upload the remotion-motion-graphics.skill file in Settings, then Capabilities, then Skills. No clone and no copy, because those products load a packaged file rather than reading a directory.

Updating later means running git pull in the clone and copying the folder again, or re-uploading the .skill file on Desktop. That last point is a small operational detail worth noting, since a skill installed from a file never updates itself.

What it makes, and how it differs from a text to video model

The list of things the skill can produce is specific about format rather than about subject: logo animations, brand intros, vertical Reels, Shorts and TikToks, faceless content videos, product explainers, animated captions and subtitles, lower thirds, kinetic typography, and B-roll driven edits.

Every one of those is a job where the text has to be exact, the colours have to be exact and the timing has to be exact. That is the difference from text to video models such as Sora or Runway, which the project describes as generating pixels and hallucinating. This approach produces deterministic, editable, brand-controlled motion graphics from real code, with exact text, exact colors and exact timing, and re-renderable forever.

That re-renderable part is the quiet advantage. A generative clip cannot be corrected, so a wrong word or an off-brand colour means generating again and hoping. A Remotion composition is a React component, so the fix is a text edit and another render, and the fix survives every future render of the same composition.

The cost is that you need Remotion and a Node toolchain where Claude runs, plus a Claude subscription or API access. The project states plainly that the skill itself is free and MIT licensed, and that Remotion is free and open source, so the running costs are the model access and the render time.

The examples show the rules applied one at a time

The examples directory is a Remotion project with four finished compositions, and each one demonstrates a different aspect of the approach.

There is a profile promo, the Focus Cat app promo which is 15.5 seconds long with a pixel-art mascot drawn in code, a demo where the motion rules apply themselves one by one, which the description calls a watch this video fix itself demo, and a beat-synced code edit with a synthesized 120 BPM track. Each shipped only after the render, inspect frames, fix, re-render loop.

The self-fixing demo is the one to watch if you want to know whether the rules do anything. If applying the rules one at a time visibly changes the result, then the rules carry real information rather than restating what the model would have done anyway.

The sound design and the beat sync are the parts that go beyond the visual rules. A synthesized 120 BPM track means the timing of the edit is locked to audio that was generated to match it, which is the reverse of the usual workflow where the music is chosen to fit the edit. The demo clip at the repository root is a motion graphics clip produced by Claude Code using this skill, with a full quality MP4 with audio available for download.

The repository is MIT licensed with a LICENSE file, and it also has a CONTRIBUTING guide, a scripts directory and a .gitignore.

Editorial conclusion

Adopt this skill if you make motion graphics and want an assistant that applies a fixed set of animation rules instead of inventing linear fades, and you are comfortable letting it iterate on renders. Do not adopt it if you need photoreal footage or generative video, since the whole approach is code-based motion graphics rather than pixels. Before you install, check three things: that you have Remotion and a working Node toolchain in the environment Claude runs in, which Claude product you are using, since the per-user and per-project install paths differ and Claude Desktop takes a .skill upload instead, and that the ten rules fit your brand, because they are hard rules the model is told never to break.

Frequently asked questions

Official sources

1. haidrrrry/claude-remotion-skill on GitHub
2. Issues
3. License: MIT
4. Project website
5. README