Skip to main content
skill CX Codex

layer-video-fixes — Claude Code skill for video repair

The layer-video-fixes Claude Code skill repairs specific defects in Layer video clips instead of generating them again. It handles requests to extend a shot, replace a subject, change lighting, or improve image quality.

MIT 1,100 installs ★ 10 updated 2026-09-30

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add layerai/skills --skill layer-video-fixes -a claude-code
Open on GitHub

What layer-video-fixes does

The skill routes a clip to a Layer repair use case, such as extending or inserting footage, swapping an object or character, transferring motion, relighting, interpolation, upscaling, denoising, deblurring, or converting SDR to HDR. It uses list_base_models to find a model and get_base_model to read that model’s accepted input slots.

The original file_id remains the master source. Independent fixes start from it, while upscaling comes last because chained edits compound detail loss. Set keep_audio: true to carry sound through a repair. Inserts, extensions, and interpolation can change clip length. The skill estimates the cost before execution and waits for approval above 20 CUs.

What it helps with

  • extend a shot whose action ends too early
  • replace an incorrect object or character in a clip
  • smooth motion or create a slow-motion segment
  • reduce grain or motion blur in footage
  • convert an SDR master to HDR

Example prompts for the agent

  • Extend the clip with file_id abc123; the action ends too soon.
  • Replace the object in the clip with file_id abc123 while keeping the motion and scene.
  • Remove noise from the clip with file_id abc123 and preserve its audio.

How to install layer-video-fixes

1Skills CLI (Vercel)

npx skills add layerai/skills --skill layer-video-fixes -a claude-code

2Manually: put the files in place

~/.claude/skills/layer-video-fixes/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/layer-video-fixes/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about layer-video-fixes

How do I install layer-video-fixes in Claude Code?

Run npx skills add layerai/skills --skill layer-video-fixes -a claude-code. The skill file is at ~/.claude/skills/layer-video-fixes/SKILL.md.

What does layer-video-fixes do?

It selects a Layer workflow for a specific video repair, such as extending a clip, replacing an object, adjusting lighting, or increasing resolution. The skill reads the chosen model’s input schema before using it.

How does the skill handle several video fixes?

It applies independent fixes to the original file_id to limit cumulative detail loss. Upscaling comes after the other edits.

Source text

SKILL.md · MIT
---
name: layer-video-fixes
description: "Use when a generated or supplied clip on Layer is nearly right and should be repaired, not rerolled: extending it, inserting into it, swapping an object or a character, transferring motion, relighting, smoothing motion or making slow motion, upscaling, denoising, deblurring, or converting to HDR. Keywords: fix video, extend clip, swap character, motion transfer, relight, interpolation, slow motion, frame rate, upscale video, denoise, deblur, HDR."
license: MIT
---

# Layer Video Fixes

## Overview

A clip that is 90 percent right is worth more than a fresh roll. Rerolling throws away the motion,
the timing and the performance that already work, and buys a new set of problems. Layer exposes a
use case for most single defects, so the job is to name the defect, pick the use case that fixes only
that, and leave everything else as it was.

Generating a clip from scratch is `layer-video`; cutting finished clips together is
`layer-video-timeline`. The loop, the spend gate and polling are in the `layer` skill.

If a sibling skill named here is missing from your available skills, ask the user to install it
(`npx skills add layerai/skills --skill <name>`); unattended, proceed from tool schemas and flag the
gap.

## Quick reference

Each route is `list_base_models` with `filter.use_case` set as below; take the first result.

| Symptom                                         | `use_case`             |
| ----------------------------------------------- | ---------------------- |
| Clip ends too soon, action is cut off           | `video_extend`         |
| A moment is missing in the middle               | `insert_video`         |
| One element is wrong (colour, prop, background) | `video_editing`        |
| The wrong object is in shot                     | `video_object_swap`    |
| The wrong character, or an off-model one        | `video_character_swap` |
| Right performance, wrong subject                | `motion_transfer`      |
| Lighting fights the scene it is cut into        | `relight_video`        |
| Motion stutters, or the shot needs slow motion  | `video_interpolation`  |
| Too small for delivery                          | `upscaling`            |
| Grain or compression noise                      | `denoise_video`        |
| Soft or motion-blurred                          | `deblur_video`         |
| Standard range master needed as HDR             | `sdr_to_hdr_video`     |

## Read the model before the first call

These models disagree about inputs more than generation models do. The schema does not fix which
guidance slot a repair model reads the source clip from (`init_video` or `reference_video`), nor
where a replacement subject goes (`reference_image`, `face`, or an `element_*` type). Call
`get_base_model` on the chosen model and use the slots it lists; never assume one because another
model took it. When a fix needs two inputs at once, narrow the search with
`filter.guidance_file_types`, for example `["init_video", "reference_image"]`, which keeps only
models that accept both.

Guidance files are `{file_id, type}` objects in `guidance_files`. A clip from an earlier run already
has a `file_id`; pass it directly. Upload only footage that is local, with `request_file_upload_url`.

## Repair from the original

Every pass through a model costs detail. Three fixes chained on each other look worse than three
fixes each made from the source, and the losses compound in faces and fine texture first. Keep the
original `file_id` as the master, apply each fix to the master where the fixes are independent, and
chain only when a later fix genuinely needs the earlier result (upscale last, after the content is
settled, since an upscale of a clip you then edit is wasted).

To fix only part of a clip (slow motion on the last two seconds), cut that span out first with a
`render_video_timeline` edit (`start_from_in_seconds` and `duration_in_frames`, `layer-video-timeline`),
then repair the cut file.

## Sound, length and frame rate

- **Sound.** Set `keep_audio: true` to carry the source's audio through a fix. Without it, assume
  the output may be silent, and check before delivering.
- **Length.** Extensions, inserts and interpolation change a clip's duration, and some swaps do too.
  Report the new length to the user, especially when the clip sits in an edit cut to music. An
  interpolated slow-motion shot is longer by design; a swap that came back shorter is a defect.
- **Frame rate.** `fps` is honoured only by the models that take it (`get_base_model` says so). Ask
  for interpolation to reach a target rate rather than generating at one the model ignores.
- **Size.** For a reframe, pass both `width` and `height`. With either one missing and a source
  attached, the output geometry is taken from the source file.

For an upscale, `upscale_ratio` sets the factor (2.0, 4.0). `creativity` and `resemblance` trade
invented detail against fidelity; keep resemblance high on footage with faces or text.

## Pricing

The forge guide prices a video edit by its source's length and an upscale by its source's
dimensions. An estimate without the source attached prices a different run, so pass
`estimate_forge_price` exactly the inputs `execute_forge` will get. Several fixes on clips of
different lengths are several estimates, never the first one multiplied. Sum the job and ask before
spending above 20 CUs.

## Worked example

"The hero's 6-second clip is perfect except the sword turned into a staff halfway through. Also make
it 4K for the trailer."

1. The clip is a previous run's output, so it has a `file_id`. Keep it as the master.
2. Defect one is a wrong object: `list_base_models` with `filter.use_case: "video_object_swap"`.
   Take the first result and call `get_base_model` for its source slot and replacement slot.
3. Defect two is size: `list_base_models` with `filter.use_case: "upscaling"` and
   `filter.modality: "video"`; `get_base_model` for its slot and ratio limits.
4. Price both before running either: `estimate_forge_price` for the swap with the master attached in
   its listed slot, the approved sword still as the replacement, `keep_audio: true`, and a prompt
   naming only the change: "Replace the staff in the hero's right hand with the approved longsword.
   Keep the motion, the timing and everything else unchanged." Then estimate the upscale with
   `upscale_ratio: 2.0` against a 6-second source. Present the total; above 20 CUs wait for a yes.
5. `execute_forge` the swap; poll `get_forge_run` at `poll_interval_seconds`. Check the length is
   still 6 seconds and the sword holds across every frame.
6. Upscale the swap's output (`file_id` from step 5), the one fix that must come last. Poll, then
   report both `file_id` values and any change in length.

## Common mistakes

- Rerolling a clip whose only defect a single use case could fix.
- Assuming the source slot instead of reading it from `get_base_model`.
- Chaining independent fixes off each other instead of each off the master.
- Upscaling first, then editing the upscaled clip.
- Losing the soundtrack by leaving `keep_audio` unset.
- Delivering a fixed clip without saying its length changed.
- Pricing several fixes from one estimate when their sources differ in length or size.
- Prompting a repair with a full scene description instead of only the change.

© layerai · MIT · layerai/skills

Similar skills

SKILL.md skills catalog →
project-auditor-fixes Unity-Technologies project-auditor-fixes — a skill that drives Project Auditor through the Unity CLI and works through the issue list in reviewable batches. Use it when a pile of diagnostics needs clearing without breaking the build. CX Codex +1 3,200installs security fixes [email protected] security fixes fixes security scan alerts in your codebase, preserves existing project logic, and adds test cases for every change. GP ChatGPT ★ 178,201repo stars unit-test-controller-layer giuseppe-trisciuoglio unit-test-controller-layer generates isolated MockMvc unit tests for Spring REST controllers with Mockito. Helps verify HTTP status codes, payload validation, and JsonPath assertions. CX Codex +1 4,000installs unit-test-service-layer giuseppe-trisciuoglio unit-test-service-layer — a skill that gives the agent a Mockito pattern for service-layer unit tests: mock repositories, verify calls, cover exception paths. CX Codex +1 4,000installs building-dbt-semantic-layer dbt-labs building-dbt-semantic-layer guides AI agents in creating and modifying dbt Semantic Layer components, including metrics, entities, and time spines for MetricFlow across dbt Core versions. CX Codex +1 1,100installs radian-layer-41-seo-content-marketing-skill-suite reason-machines radian-layer-41-seo-content-marketing-skill-suite is a Claude Code skill for SEO analysis and content marketing. It responds to requests for site audits, keyword research, and competitor gap analysis. CX Codex +1 1,000installs

From the same set33

The whole set →
layer-store-assets The layer-store-assets Claude Code skill helps prepare store artwork for games and apps. It covers icons, screenshot sets, Steam capsules, feature graphics, and preview videos. CX Codex +1 1,100installs layer-motion-templates layer-motion-templates — a Claude Code skill for creating Layer video templates with media slots for batch rendering. Runs when generating ad variants with swappable hooks, localizations or voice-overs. CX Codex +1 1,100installs layer-motion-graphics The layer-motion-graphics Claude Code skill creates motion graphics in Layer, from logo reveals to animated titles. It places words on a timeline and moves them with transitions or a separate video clip. CX Codex +1 1,100installs layer-video-looks layer-video-looks — a Claude Code skill for styling, grading, and keying video items on the Layer timeline. Operates during clip post-processing to unify mismatched shots or add retro and film filters. CX Codex +1 1,100installs layer-video-continuity The layer-video-continuity skill for Claude Code maintains visual continuity across multi-shot Layer video generations. It carries characters, lighting, and action across cutscenes or trailers. CX Codex +1 1,100installs layer-talking-characters layer-talking-characters — a Claude Code skill for generating character speech and matching lip movements to audio. It handles presenter clips, UGC-style ads, cutscene dialogue, and new lines synced to existing footage. CX Codex +1 1,100installs layer-video-direction layer-video-direction — a skill for Claude Code directs camera motion, lenses, framing, and pacing for single video shots on Layer. Runs when choreographing shot generation or resolving camera drift. CX Codex +1 1,100installs layer-environments The layer-environments Claude Code skill creates game backgrounds, parallax layers, 360° panoramas, and worlds with Layer. It runs for environment art, looping or aligning layers, and exports to Godot or Unity. CX Codex +1 1,100installs

Project sponsors

Companies that keep this analytics open