Claude Code video generation: eight seconds, forty-eight cents

One command, one MP4

What currently ranks for this phrase is a shelf of weekend projects: a toolkit repo, two threads about an automated pipeline somebody assembled, a write-up titled around having built the thing in one afternoon, and a workflow platform that wants you to open an account with it first. They are good work and they all stop at the same place, which we will get to. The installed version is three lines:

$ npm i -g @clize/clize
$ clize install --claude
$ clize gen video "slow drone pass over a foggy pine ridge at dawn" --aspect 16:9 --confirm

By default the command waits, polling until the clip is finished, then downloads it and writes the file. What comes back through stdout is a record rather than the video: job id, model, state, the file path, the cost. Here is a real row from clize gen list --modality video on this account, trimmed:

{
  "id": "gen_366b0679",
  "modality": "video",
  "model": "veo",
  "state": "succeeded",
  "costUsd": 0.48,
  "prompt": "Night shift at a planetary starship yard, cinematic medium-close view: …"
}

No provider account is involved. There is no Google Cloud project to create, no API key to export, no billing profile to attach — the hosted path carries the credential and your Clize balance is what gets debited. That is the same arrangement the image command runs on, and it is why installing once gives you all three modalities rather than three integrations.

Eight seconds, and --duration does not change that

The single most useful thing to know before you plan a shoot: one call produces at most eight seconds, and the model decides the exact length. The CLI is blunt about it in its own help text — the duration flag is described as ignored by veo, which picks the length itself, capped at eight seconds per clip. Underneath, the value is dropped rather than forwarded, because passing it upstream would only buy you a job that fails asynchronously, minutes later, after being charged.

$ clize gen video --help
  --duration    duration in seconds (ignored by veo — the model picks it, ≤8s per clip)

So a thirty-second spot is four or five separate calls, each with its own prompt, and the joining is your editing problem — Clize will not concatenate them for you. That constraint should shape the prompt: eight seconds holds one camera move, not a scene with a beginning and an end. Write it as a shot description rather than as a story, and the hit rate goes up sharply.

Two flags do work and are worth using. --aspect 16:9 is forwarded as given, so ask for the ratio you actually need rather than cropping later. And --from-image first.png starts the clip from a still you already have, which is the reliable way to keep a product or a character stable across several clips: generate the frame once, then reuse it as the opening frame of each shot. You can pass up to three reference images in total on veo, counting the first frame, with anything beyond that refused before you are charged.

The problem every weekend pipeline hits: the session ends

This is where the ranked write-ups stop. Video generation is a minutes-long job. Claude Code sessions are not minutes-long in any reliable sense — you close the lid, a context window fills up, a shell gets killed, the agent moves on to the next task. A pipeline built out of a raw provider API loses the thread at exactly that moment: the request was paid for, the clip is still rendering somewhere, and nothing on your machine remembers where.

Clize models the job as state on the server rather than as an open socket on your laptop. Submit and detach:

$ clize gen video "harbour crane at blue hour, slow push-in" --async --confirm
{ "id": "gen_9c1e04a7", "state": "running",
  "message": "Submitted; generating in the background. Fetch the result with clize gen status gen_9c1e04a7." }

Then, any time later and from any session:

$ clize gen jobs                 # running jobs first, then recent ones
$ clize gen status gen_9c1e04a7  # polls once; if it is done, the file is written to disk

clize gen jobs lists running work ahead of finished work precisely so a fresh agent can pick up what a dead one started. clize gen status polls the provider once, and if the clip has completed it downloads it and writes the file right then — the status check is the retrieval. Nothing is lost by walking away, which turns a fragile foreground pipeline into something a scheduled job can run.

The default is still to wait, with --timeout at 300 seconds, because for a single interactive clip waiting is simpler. Reach for --async when you are queueing several, or when the agent has other work to get on with.

Who pays for the re-take

Video is the modality where cost estimates go wrong, and they go wrong for one reason: nobody keeps the first take. Third-party rate cards quote per second of output, which makes a comparison table easy and a monthly forecast useless, because the number you actually need is seconds kept × attempts per keeper.

Two things about how Clize bills change that arithmetic:

• The price does not vary with length. A clip quotes at $0.48 whether the model gives you five seconds or eight. There is no per-second term anywhere in the pricing, so your forecast is simply the number of clips you intend to run.
• Failures are refunded. The balance is debited at submission and credited back automatically if the provider errors, if submission is rejected, or if the job later reports a failure while you are polling. Attempts that produce nothing cost nothing.

What is not refunded is a clip that arrives and is merely bad — the camera drifts, the hands are wrong, the light is off. It was generated, so it was billed, and the next attempt is another $0.48. That is the honest shape of the budget: failures are free, disappointments are not. If you would rather see that as a monthly figure against published per-second rates elsewhere, the video cost calculator does the conversion without asking for your email.

As always, the bare command spends nothing. Drop --confirm and you get the quote and only the quote:

$ clize gen video "harbour crane at blue hour"
{ "quote": { "model": "veo", "modality": "video", "estUsd": 0.48, "currency": "USD" },
  "message": "📋 Quote about $0.48 (video). Add --confirm to generate." }

You watch it. Claude cannot.

An agent can open a PNG and tell you the composition is off. It cannot watch twenty-four frames a second of anything. This is a real limit, and the interesting design question is whether the tooling admits it or lets the agent bluff.

Clize admits it at the point of use. When a clip finishes, the hint returned alongside the file says the bytes were written to disk, that you cannot watch video or listen to music, and that the path should be handed to a person to judge — explicitly, not to conclude on their behalf. The skill carries the same rule, so a well-behaved session stops and shows you a path instead of reporting that the shot looks great.

In practice the loop is: the agent writes the prompt, submits, retrieves, and then hands over a filename and its own uncertainty. You watch eight seconds. You say "again, wider" and it runs another. That is slower than the image loop and it is the correct speed, because the alternative is an agent burning $0.48 a turn on footage nobody has looked at.

The same reasoning is why the media commands are CLI verbs rather than structured tools: there are no MCP tools for image, video or music generation, and this page will not pretend otherwise. The MCP server covers the other half of Clize — mail, domains, deploys, the storefront — and none of it is needed to make a clip.

What happens to the file afterwards

The clip lands in ./clize-assets/ by default, or at --out ./shot-03.mp4 if you name it, and the record stays queryable with clize gen list --modality video — id, model, prompt, cost and the source URL for each one, which is how you find a render from three weeks ago without a folder archaeology session.

From there it is an ordinary file in an ordinary working directory, which is the whole point of writing bytes to disk instead of into a chat. Claude Code can drop it into a landing page and ship the page in the same session, or hand it to clize email send --attach for a client to review — and that mail still waits for your approval before it leaves. Music works the same way and is its own short page, mostly because the length question there has a genuinely different answer.

$ npm i -g @clize/clize && clize login
$ clize install --claude
$ clize gen video "slow drone pass over a foggy pine ridge" --aspect 16:9