Anthropic · Builds and renders the video
Make a product launch video with Claude Code
Claude Code works in your terminal and your repository, so it can do the whole job: pick a reference launch video from Kuchi, read its shot-by-shot breakdown, write the Remotion scenes and render the MP4 on your machine.
Kuchi supplies what Claude Code cannot see on its own: real launch videos measured frame by frame (when each shot starts, how it enters, how much moves, its colours) and a plan that maps your product onto those frames.
Step by step: Remotion with Claude Code: make a product video from a prompt
Connect Kuchi to Claude Code
No sign-in, no API key. The server is https://kuchi.kalarislabs.com/mcp.
In Claude Code, install the Kuchi plugin. It adds the skill and the MCP server in one step.
/plugin install kuchi --marketplace KalarisLabs/kuchiOr add only the MCP server from your shell.
claude mcp add --transport http kuchi https://kuchi.kalarislabs.com/mcpUsing the Claude desktop app? Open Claude Code there with the setup prompt filled in.
Open in Claude Code
Why use Claude Code for your launch video
- Writes and renders Remotion or HTML video in your own project, so the output is code you keep.
- Installs Kuchi video components straight into the repo with the shadcn CLI.
- Checks its own render against the reference with kuchi_check_remake before handing it over.
How it works
- 1
Choose a template
A short list of real launch videos ranked for your product, with posters and links.
kuchi_suggest_templates - 2
Study it
Every shot's exact frames, how it enters, how much moves, its colours and a sheet of real frames.
kuchi_get_breakdown - 3
Plan the remake
Your product details mapped onto the reference's frames, with a list of anything still missing.
kuchi_plan_remake - 4
Build
Claude Code writes the scenes shot by shot, using Kuchi components where they fit, and renders the video.
kuchi_get_component - 5
Check
Compare your frames with the reference at the times it returns, and fix what differs.
kuchi_check_remake
Prompts to try in Claude Code
Make a 30-second launch video for this repo. Use Kuchi to find three templates that fit a developer tool and show me the posters.
Remake https://kuchi.kalarislabs.com/#video-92 for our product. Use my logo in ./brand and screenshots in ./screens.
Build the video in Remotion, render it to out/launch.mp4, then run kuchi_check_remake and fix the shots that drift.
How Claude Code loads the MCP server
Claude Code keeps MCP servers in three scopes. claude mcp add writes to local scope by default (this project, only you); --scope project writes a .mcp.json at the repo root that teammates get when they pull; --scope user makes the server available in every project on your machine. For a library you will use across repos, user scope is the natural choice: claude mcp add --scope user --transport http kuchi https://kuchi.kalarislabs.com/mcp.
The --transport http flag is what selects Streamable HTTP. Without it Claude Code assumes a local stdio command and tries to execute the URL. claude mcp list shows each server with its status, and /mcp inside a session shows the tools it loaded. The plugin route adds the server and the workflow skill together, and the skill is what makes Claude Code reach for the library unprompted when you say "launch video".
Claude Code asks before the first call to each tool. Every tool on this server is annotated read-only and idempotent, so allowing them for the session is safe; nothing on the server changes and nothing on your machine is touched by the tools themselves.
A full run in Claude Code, step by step
A typical run: Claude Code calls kuchi_suggest_templates with a one-line description of your repo, shows the posters, and waits. After your pick it calls kuchi_get_breakdown, opens the storyboard images (Claude Code reads images natively), and writes a shot analysis: one kind per shot, plus a line on what is on screen. That analysis goes into kuchi_plan_remake with your product name, features, colours and the asset paths you gave it.
Once the plan returns ready=true, Claude Code scaffolds Remotion, writes one component per shot and a single shot list with start and end frames from the blueprint, then renders stills at the compare_frames times from kuchi_check_remake. Because it can read those stills next to the reference storyboard, it can see a headline that sits too low or a screen that enters a few frames late, and fix it before the final render.
Put brand rules in CLAUDE.md (hex colours, font files, the folder with screenshots) so a fresh session does not need them repeated, and ask Claude Code to keep the blueprint in a file such as video/plan.json so later edits work from the plan, not from memory.
What Claude Code sends to the server
The server is a remote MCP server over Streamable HTTP at https://kuchi.kalarislabs.com/mcp. Every message is a JSON-RPC 2.0 request sent as an HTTP POST to that one endpoint. It is stateless: there is no session to keep alive, no cookie and no Authorization header, so Claude Code can reconnect at any time without losing anything.
When Claude Code connects it sends initialize and receives the server's name, version, instructions and capabilities (tools, resources and argument completion), then calls tools/list. The tool list carries a one-hour cache hint, because it only changes when the server is deployed. Each tool call is a tools/call whose arguments are checked against a strict schema: unknown fields are rejected and every string has a length limit, so a malformed call fails with a clear message instead of a half-right answer.
Results come back as text, Markdown by default or JSON when the call passes response_format: "json", and JSON results also arrive as structuredContent. Media is never inlined: the reference MP4, the poster and the storyboard sheets come as resource_link entries pointing at the CDN, which Claude Code can open or fetch itself. A result is capped at 25,000 characters; a long blueprint arrives in pages of up to 40 shots, with shot_offset and shot_limit to fetch the next page.
Every tool is annotated readOnlyHint: true, destructiveHint: false, idempotentHint: true and openWorldHint: false: nothing changes on the server, the same call returns the same answer, and no tool reaches out to the wider web. The server also offers resources (kuchi://workflow, kuchi://videos/{id}, kuchi://breakdowns/{id} and kuchi://components/{name}) with autocompletion, for clients that let you attach a resource to a message.
The 13 tools, and when Claude Code calls them
| Tool | What it returns | When Claude Code uses it |
|---|---|---|
kuchi_get_workflow | The remake method, whole or one step (find, study, plan, build, check) with the rules that hold for all steps. Markdown. | Read once before the first remake, or one step at a time to keep context small. |
kuchi_suggest_templates | A short numbered list of launch videos ranked for a product description, each with poster, link, what fits, what differs, what you would need to supply and one recommendation. | First call of a job; the agent shows the posters and waits for your pick. |
kuchi_search_videos | Searches the whole library by keyword, style, category, format, aspect ratio, length, pace or theme, a page at a time. | When you ask for something specific ("vertical, fast, terminal style"). |
kuchi_get_video | One video by id, slug, site link or original X link: file, poster, storyboard, length and measured rhythm, with resource links to the MP4 and images. | When you paste a link from the site instead of choosing by number. |
kuchi_list_filters | Every valid style, category, format, aspect ratio, pace and theme with counts, plus the 14 shot kinds an agent classifies shots into. | Before a filtered search, so it never guesses a filter value. |
kuchi_get_breakdown | The frame-by-frame measurement of one video: each shot's start and end, entrance, amount of motion and colour roles, a per-second motion and loudness curve, and storyboard sheets of real frames. | Study step; the agent looks at the storyboard and writes its own shot analysis. |
kuchi_plan_remake | Takes your product details, assets and the agent's shot analysis; returns a blueprint re-timed to your length on whole frames, with your content per shot, plus missing_inputs and ready. | Called until ready=true; the blueprint becomes the shot list in code. |
kuchi_check_remake | Checks a shot list against the reference: reused brand text, assets taken from the reference, generated logos or UI, placeholders, timing gaps and drift. Returns passed and compare_frames. | Before delivery; the agent renders stills at the compare_frames times and fixes drift. |
kuchi_list_components | Lists the copy-paste Remotion components (kinetic type, captions, UI screens, cursors, logos, transitions) with dependencies and shadcn install commands. | While building, to find a ready-made component for a shot. |
kuchi_get_component | One component's full source, files, dependencies, install command and usage notes, split into parts when long. | To read a component's source before installing or adapting it. |
kuchi_send_feedback | Reports a failure or a missing capability to the maintainers. The only tool that records what the agent writes. | When a tool fails or misleads. |
search | The generic search tool some clients expect: returns up to 10 video ids, titles and URLs. | Rarely; the kuchi_ tools are richer. |
fetch | The generic fetch tool: one video by the id from search, with notes, links and metadata. | Rarely. |
How the blueprint times your video
A reference video is measured shot by shot: where each shot starts and ends, how it enters and how much of the frame moves. kuchi_plan_remake maps those shots onto your target length, between 5 and 180 seconds, at the frame rate you will render (12 to 120 fps, the reference's own by default).
If your length is at least 75% of the reference's, every shot is kept and re-timed by the same factor (mode retimed). If it is much shorter, speeding everything up would wreck the rhythm, so the plan keeps an evenly spaced subset of shots, at least three, and re-times those instead (mode condensed). Either way every shot starts on a whole frame and lasts at least one, so start_frame and end_frame are exact integers Claude Code can place directly; no rounding happens later.
Each shot also carries compare_at_s: the moment in your video that matches the reference frame shown on the storyboard, so the side-by-side check compares like with like. precision says whether every shot was classified (analysed), some were (partly_analysed) or none were (timing_only); shots without a kind keep their timing and get placeholder content until Claude Code classifies them. One shot from a blueprint:
{
"shot": 3,
"start_s": 4.2,
"end_s": 6.533,
"start_frame": 126,
"end_frame": 195,
"reference_shot": 3,
"reference_start_s": 3.9,
"reference_end_s": 6.07,
"compare_at_s": 5.1,
"enters": "transition",
"motion": "medium",
"kind": "ui_screen",
"reference_shows": "Product UI. Dashboard centered, cursor moves to a button",
"your_content": "Acme: \"Live sync\". A screenshot or recording of the user's product..."
}In Remotion the blueprint maps one to one onto a composition and a <Sequence> per shot. Saving the plan as plan.json and reading the frames from it means Claude Code never retypes a number:
// src/Root.tsx: one composition at the blueprint's fps and length
import { Composition } from 'remotion';
import plan from '../plan.json';
import { Launch } from './Launch';
export const Root = () => (
<Composition id="Launch" component={Launch}
fps={plan.blueprint.fps} durationInFrames={plan.blueprint.frames}
width={1920} height={1080} />
);
// src/Launch.tsx: one <Sequence> per blueprint shot, on its exact frames
import { AbsoluteFill, Sequence } from 'remotion';
import plan from '../plan.json';
import { shots } from './shots';
export const Launch = () => (
<AbsoluteFill>
{plan.blueprint.shots.map((s) => {
const Shot = shots[s.shot];
return (
<Sequence key={s.shot} from={s.start_frame}
durationInFrames={s.end_frame - s.start_frame + 1}>
<Shot />
</Sequence>
);
})}
</AbsoluteFill>
);Use 1080×1920 for 9:16 and 1080×1080 for 1:1. Inside a <Sequence>, useCurrentFrame() starts at 0, so each shot's entrance animation is written relative to the shot, not to the whole video.
The 14 shot kinds Claude Code classifies
While studying the storyboard, Claude Code gives every reference shot one kind. The kind decides what of yours replaces it.
| Kind | In the reference | In your video |
|---|---|---|
title_card | Words on a plain or lightly textured background | A short line in your words |
kinetic_type | Words that are the motion: typing, sliding, scaling | Your headline, animated the same way |
logo | A brand mark on its own, usually a reveal | Your logo |
ui_screen | A whole product screen, flat to the camera | A screenshot or recording of your product |
ui_closeup | One part of a screen enlarged: a button, a field, a cursor | The matching detail of your UI |
device | A screen inside a phone, laptop or browser frame | Your screen in the same frame |
chart | A graph, counter or data graphic drawing in | Your real numbers, never invented ones |
character | A mascot, illustrated figure or avatar | Your own mascot, or a placeholder |
product_render | A physical product, photographed or in 3D | Your product photo or render |
live_action | Filmed footage of people or places | Your own footage, or a placeholder |
collage | Several images, cards or screens arranged together | Several of your screens |
abstract | Shapes, gradients, particles or light | The same motion in your colours |
end_card | The closing frame: logo with a call to action | Your logo and call to action |
blank | An empty frame held as a pause | The same pause, nothing on screen |
Entrances and motion
| Value | Meaning |
|---|---|
enters: cut | Hard cut: the whole picture changes in one frame. |
enters: transition | Animated transition: several frames of heavy change join two pictures (wipe, zoom, morph or dissolve). |
enters: hold | Same scene: motion resumes after the picture held still. |
enters: blank_black | Passes through an empty black frame. |
enters: blank_white | Passes through an empty white frame. |
motion: still | Under 0.4% of the frame moves. |
motion: low | Under 3%. |
motion: medium | Under 12%. |
motion: high | 12% or more. |
What the check catches before you ship
kuchi_check_remake takes the shot list Claude Code built: each shot's start and end in seconds, the reference_shot it rebuilds, how it enters, every line of on-screen text, and where each asset came from (user, generated, stock, placeholder or reference). It returns passed, errors and warnings by shot, and compare_frames.
- Text that carries over the reference's brand, product names or slogans.
- Any asset taken from the reference video: footage, UI, characters or music.
- Generated logos or generated product UI, which should always come from you.
- Placeholders still on screen.
- Gaps or overlaps in the timeline, and shots whose length or entrance drifted from the reference shot they rebuild.
The check reads the shot list, not the file: the video never leaves your machine. Claude Code then renders a still at each compare_frames time and sets it beside the reference storyboard, which catches layout drift a quick watch misses.
Troubleshooting Claude Code
| Symptom | Fix |
|---|---|
| Claude Code says it cannot connect, or tries to run the URL as a command | The server was added without --transport http. Remove it with claude mcp remove kuchi and add it again with the flag. |
| The server works in one repo but not another | It was added in local scope. Add it again with --scope user. |
| Tools never get called when you ask for a launch video | Install the plugin (it adds the skill), or paste the setup prompt once per session. |
| Renders differ from the plan by a frame or two | The shot list was rounded to seconds. Ask Claude Code to use the blueprint's start_frame and end_frame values directly. |
| The tool list is empty or the connection times out | Check that nothing on your network (a proxy, VPN or firewall) blocks HTTPS to kuchi.kalarislabs.com, and that the URL ends in /mcp. |
| A tool says the catalog is temporarily unavailable | The library is refreshing. Retry in a minute; nothing on your side needs to change. |
Launch video templates to start from
All launch videos →Components Claude Code can install
All components →Claude Code and Kuchi: questions
Can Claude Code render the video itself?
Yes. Claude Code runs commands in your project, so it can install Remotion, write the scenes from the Kuchi blueprint and render an MP4 locally. Kuchi does not render anything; it measures references and plans the remake.
Plugin or MCP server: which should I install in Claude Code?
The plugin. It installs the Kuchi skill, which teaches the workflow, and the MCP server, which serves the latest videos, in one command. The MCP server alone also works.
Is Kuchi free to use with Claude Code?
Yes. The Kuchi MCP server is open: no account, no API key and no payment. Your own agent plan applies as usual.
Will my video copy the reference?
No. A remake borrows the reference's timing, motion and layout. Every logo, screen, line of copy and asset on screen comes from your product.







