layer-video-looks — Claude Code skill: what it does, how to install
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.
MIT 1,100 installs ★ 10 updated 2026-09-30
npx skills add layerai/skills --skill layer-video-looks -a claude-codeWhat layer-video-looks does
Configures consistent looks across timeline clips inside render_video_timeline. It populates item fields like blur, brightness, and saturation, alongside an effects array featuring duotone, noise, scanlines, and vignette. Because filters apply on the timeline without extra model passes, every render produces repeatable output priced through estimate_video_timeline_price.
Effect order matters: colorKey runs first on the raw screen, color adjustments (duotone, contrast) precede textures like grain, and distortion filters (wave, fisheye) run last. Timeline items lack keyframes, meaning effect parameters remain constant across the entire duration. Animating an effect requires splitting a clip into adjacent stepped items with increasing progress values or rendering a dedicated prompt generation.
What it helps with
- key out green or blue backdrops using
colorKey - apply retro CRT, VHS, or film grain textures across clips
- match exposure and hue across footage from different runs
- fill empty frame borders using a blurred background copy
Example prompts for the agent
- Apply a retro arcade look with scanlines, noise, and light chromatic aberration to these gameplay clips
- Chroma key the green screen presenter clip and position it over the background track
- Fill vertical pillarbox bars around this 16:9 shot with a blurred copy of the video
How to install layer-video-looks
1Skills CLI (Vercel)
npx skills add layerai/skills --skill layer-video-looks -a claude-code2Manually: put the files in place
~/.claude/skills/layer-video-looks/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/layer-video-looks/
1Skills CLI (Vercel)
npx skills add layerai/skills --skill layer-video-looks -a codex2Manually: put the files in place
.agents/skills/layer-video-looks/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add layerai/skills --skill layer-video-looks -a cursor2Manually: put the files in place
.cursor/skills/layer-video-looks/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install layerai/skills plugins/layer/skills/layer-video-looks2Manually: put the files in place
.github/skills/layer-video-looks/SKILL.md1Skills CLI (Vercel)
npx skills add layerai/skills --skill layer-video-looks -a gemini-cli2Platform CLI
gemini skills install https://github.com/layerai/skills --path plugins/layer/skills/layer-video-looksManually: put the files in place
.devin/skills/layer-video-looks/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add layerai/skills --skill layer-video-looks -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about layer-video-looks
How to install layer-video-looks in Claude Code?
Install via the skills CLI: npx skills add layerai/skills --skill layer-video-looks -a claude-code. Alternatively, place the skill file into ~/.claude/skills/layer-video-looks/SKILL.md.
What does layer-video-looks do?
It provides instructions and parameter schemas for applying color grading, styling filters, shadows, and chroma keying to Layer video timelines.
Does the timeline support animated effect keyframes?
Keyframes do not exist on the timeline, so effect properties stay static across each item. Movement is achieved by dividing the clip into stepped items with progressive values or generating animated motion via prompts.
Source text
SKILL.md · MIT
---
name: layer-video-looks
description: "Use when giving a Layer video cut one consistent finish: a colour wash in brand colours, a retro CRT or VHS look, film grain and light leaks, a glitch hit on a cut, keying out a green or blue screen, lifting a cut-out logo off the frame, or filling the bars behind a clip. Also when shots in one edit do not match. Keywords: look, grade, filter, tint, duotone, film grain, vignette, scanlines, glitch, chroma key, green screen, drop shadow."
license: MIT
---
# Layer Video Looks
## Overview
A look is the finish that makes separate shots read as one piece. On Layer it lives in the timeline:
every video and image item in `render_video_timeline` takes an `effects` list plus its own `blur`,
`brightness`, `saturation`, `hue` and `opacity` fields. No model runs to apply them, so a look is exact
to repeat; the render is still priced by `estimate_video_timeline_price`.
Assembly itself (sequence, transitions, overlays, audio) is `layer-video-timeline`. This skill covers
the finish on top of it. A look the timeline cannot make, such as relighting a shot or restyling its
content, is a generation: see `layer-video-fixes`.
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
| Look | Effects, in this order |
| ------------------------- | ------------------------------------------------------------------------------------------ |
| Brand wash | `duotone` with `darkColor` and `lightColor` in brand colours, or `tint` with `amount` |
| Retro CRT | `scanlines`, then `noise`, then a light `chromaticAberration` |
| Film | `noise` (grain), `vignette`, `lightLeak` |
| Glitch hit on a cut | `tvSignalOff` or a strong `chromaticAberration` on a short item at the cut |
| Green or blue screen | `colorKey` first, with `keyColor` set to the screen |
| Cut-out logo or character | `dropShadow` or `outline` on an image that has transparency |
| Dreamy highlights | `glow` with a `threshold` so only the bright parts bloom |
| Plain grade | Item fields: `brightness`, `saturation`, `hue`; `contrast`, `exposure`, `vibrance` effects |
Every effect is `{type: "<name>", ...params}` with camelCase params, and every param has a default,
so `{type: "vignette"}` alone is valid. Colours are `{red, green, blue, alpha}` objects, 0 to 255.
`blur`, `brightness`, `saturation`, `hue` and `opacity` are item fields, not effects: `brightness` and
`saturation` are multipliers from 0 to 2 (1 unchanged), `hue` rotates -180 to 180 degrees.
`render_video_timeline` takes `{workspace_id, template, videos, images, audios}`. `template` is
`{width, height, fps, tracks: [{id, name, items, transitions}]}`; an item is `{id, type, start_frame,
duration_in_frames}` plus `file_id` or `slot`, and optionally `layout {left, top, width, height}`,
`effects`, `start_from_in_seconds` to trim a clip's head, and `volume`; a `solid` takes `color`
`{red, green, blue, alpha}`. The render returns a `generation_id` for `get_generation_run`.
## Order is the look
Effects apply in list order, each on the result of the one before. Order changes the picture:
- **Key first.** `colorKey` must see the screen's true colour. A `tint` or `exposure` ahead of it
shifts the green and the key leaves patches behind.
- **Grade before texture.** Put `tint`, `duotone` and `contrast` ahead of `noise` and `scanlines`, so
the grain sits on top of the colour instead of being recoloured by it.
- **Distortion last.** `wave`, `fisheye` and `zoomBlur` bend whatever reaches them; place them after
the texture so the scanlines bend with the picture.
## One list, every clip
A look holds only if every clip that shares it carries the same `effects` list with the same params.
Build the list once and copy it onto each item. A second clip with a slightly different `tint`
`amount` reads as a mismatch, which is worse than no look at all.
Grade toward the shots, not away from them. Shots generated at different times differ in exposure and
saturation; level them first with the item's `brightness` and `saturation` fields, then apply the
shared list.
## Params are fixed for the whole item
The timeline has no keyframes. An effect's params hold for the item's whole span: a `shine` with
`progress: 0.5` is a sheen parked in the middle, not one that sweeps across, and `lightLeak`
`progress` is one phase of the leak, held.
Two ways to get movement:
- **Stepped items.** Split the span into several short items of the same file on one track, each with
`start_from_in_seconds` continuing where the last stopped, and raise `progress` on each. Four to
six steps read as motion on a short sheen.
- **Generate it.** A sweep that must be smooth is a video generation with the motion in the prompt
(`layer-video`), not a timeline effect.
The same split confines an effect to a moment: cut the clip into before, hit and after items on one
track, and give only the few-frame hit item `tvSignalOff`. Do not stack the pieces on separate
tracks; items on one track must not overlap in time.
## Keying a screen
`colorKey` defaults to green (`{red: 0, green: 255, blue: 0}`); set `keyColor` to `{red: 0, green:
0, blue: 255}` for a blue screen. Tune in the order the schema gives: raise `similarity` when patches
of the screen remain, lower it when the subject's edges get eaten, and raise `spillSuppression` when a
coloured fringe stays on the subject. `smoothness` softens the keyed edge.
Tracks composite in reverse order, so Track 1 is on top. The keyed clip goes on a track above the
background it should reveal.
## Filling around a contained clip
A 16:9 clip in a 9:16 frame leaves bars. The schema's own fix: put a second copy of the clip on a
lower track with a full-frame `layout`, `is_auto_layout: false`, `content_fit: "cover"`, a high
`blur`, `volume: 0`, and its `brightness` lowered, then show the clip above it with
`content_fit: "contain"`. The frame fills with the clip's own colours instead of black.
## Worked example
"Give these four approved gameplay shots a retro arcade look, and put our presenter, shot on green
screen, over the last one."
1. All five clips came from earlier runs, so each has a `file_id`; nothing is uploaded.
2. Build one list for the gameplay clips:
`[{type: "contrast", amount: 1.15}, {type: "scanlines", amount: 0.2, spacing: 4},
{type: "noise", amount: 0.12}, {type: "chromaticAberration", amount: 3}]`. Copy it unchanged onto
all four gameplay items on Track 2.
3. The presenter goes on Track 1, spanning the last shot, with
`[{type: "colorKey"}, {type: "scanlines", amount: 0.2, spacing: 4}, {type: "noise", amount: 0.12}]`:
key first, then the same texture so the presenter sits in the same world.
4. A three-frame `tvSignalOff` item at the cut into the last shot, split from the clip as above.
5. `estimate_video_timeline_price` with the full input. Present the table; above 20 CUs wait for an
explicit yes.
6. `render_video_timeline` with the same input. Poll `get_generation_run` with the returned
`generation_id` at the interval it gives, never a fixed sleep.
7. Watch it end to end. If green patches remain on the presenter, raise `similarity` a step and
re-render; if the hair edge is eaten, lower it.
## Common mistakes
- A different effect list, or different params, on clips meant to share a look.
- A `tint` or `exposure` ahead of `colorKey`, so the screen no longer matches the key colour.
- Expecting `shine` or `lightLeak` to move across a clip; params are fixed per item.
- Putting the keyed clip on a lower track than its background.
- `dropShadow` or `outline` on a clip with no transparency; the schema says they work best on cut-outs.
- Glitching a whole clip when the hit belongs on a few frames at the cut.
- Reaching for a generation to recolour footage the timeline can already grade.
- Uploading clips that Layer generated and that already carry a `file_id`.
© layerai · MIT · layerai/skills