Skip to main content
skill CX Codex

layer-vfx — Claude Code skill: what it does, how to install

layer-vfx — a skill for Claude Code designs game visual effects and compiles them into sprite sheets. Generates isolated spell bursts, explosions, or loops and unpacks video clips into engine-ready flipbooks.

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-vfx -a claude-code
Open on GitHub

What layer-vfx does

Builds VFX assets such as spell impacts, explosions, auras, and ambient loops via Layer tools. The sequence begins with an isolated still frame from text_to_image, turns it into motion using image_to_video, and pulls individual frames into a sprite sheet via pack_sprite_sheet.

Engine compositing dictates the background. Additive effects like sparks or fire require a solid black background because video models lack an alpha channel. Smoke or debris requires a flat key color followed by per-frame background removal. Prompts lock the camera using STATIC video effects to prevent jitter across the packed sheet.

Full functionality relies on sibling skills layer for balance control and layer-video for motion handling. Any multi-frame job priced over 20 compute units pauses execution until explicit confirmation is provided.

What it helps with

  • generate an isolated game effect sprite sheet from text
  • produce additive visual effects on solid black backgrounds
  • extract evenly spaced frames from an effect video clip
  • pack looping aura or portal animations without seam jumps

Example prompts for the agent

  • Create an 8-frame fireball impact flipbook on a pure black background
  • Generate a looping magic portal and pack the frames into a sprite sheet
  • Design a hit impact effect with anticipation, burst, and dissipation phases

How to install layer-vfx

1Skills CLI (Vercel)

npx skills add layerai/skills --skill layer-vfx -a claude-code

2Manually: put the files in place

~/.claude/skills/layer-vfx/SKILL.md

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

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

Questions about layer-vfx

How to install layer-vfx in Claude Code?

Run npx skills add layerai/skills --skill layer-vfx -a claude-code. The file saves to ~/.claude/skills/layer-vfx/SKILL.md.

Why does layer-vfx generate effects on a solid black background?

Video generation models do not output native alpha transparency. Game engines remove pure black during additive blending while preserving soft glow falloff.

What is required to run layer-vfx?

It requires the layer skill for account credits and generation tools, along with layer-video for motion controls.

Source text

SKILL.md · MIT
---
name: layer-vfx
description: "Use when generating game visual effects with Layer: spell and skill effects, hit impacts, explosions, pickups and power-ups, loot chest and reward openings, auras, portals, or looping ambient effects such as fire, smoke and magic swirls. Also when an effect comes back with a scene around it, cannot be blended in the engine, or plays with no wind-up. Keywords: VFX, FX, spell effect, impact, explosion, particle, flipbook, aura, loot chest, additive, sprite sheet."
license: MIT
---

# Layer VFX

## Overview

An effect is not an illustration of magic. It is a short, isolated piece of motion that an engine
layers over gameplay, so it has to arrive with nothing around it, on a background the engine can
remove, timed so a player reads it in a fraction of a second. Most failed effects fail on one of
those three, not on how they look.

The route is: design the effect as a still, animate the still into a short clip, then pull frames
from the clip into a flipbook. Generation mechanics and the spend gate are in the `layer` skill;
motion prompting is in `layer-video`.

`pack_sprite_sheet` is named outright below because it is Layer's deterministic packing utility, a
tool rather than a model, with no alternative to discover.

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

| Need                       | Do this                                                                                  |
| -------------------------- | ---------------------------------------------------------------------------------------- |
| Fire, magic, light, sparks | Solid black background, for additive blending                                            |
| Smoke, dust, debris, ink   | Flat key colour, then remove it per frame; these need real alpha                         |
| The look                   | `text_to_image` still, one effect, centred, nothing else in frame                        |
| The motion                 | `image_to_video` with the still as `first_frame`                                         |
| A looping effect           | `loop` capability, the same still as `first_frame` and `last_frame`                      |
| A locked camera            | `video_effects: [{type: "STATIC"}]` where the model exposes it, and say it in the prompt |
| Frames out of the clip     | The clip's `file_id` in an image slot with `video_frame_seconds`, one run per frame      |
| The flipbook               | `pack_sprite_sheet` with the frames' `file_ids` in play order                            |

## Background decides the blend

Engines composite effects one of two ways, and the background has to match.

- **Additive** (fire, lightning, glows, magic trails, sparks): the engine adds the effect's colour to
  the scene, so pure black vanishes. Ask for "pure black background, no floor, no environment, no
  ground glow". Black here is a feature, not a placeholder, and removing it would destroy the glow
  falloff.
- **Alpha-blended** (smoke, dust, rubble, water splashes, dark magic): these darken or occlude, so
  black cannot stand in for transparency. Generate on one flat key colour that does not appear in
  the effect, then remove it frame by frame with a `background_removal` model. Wispy edges suffer,
  so prefer dense, defined shapes for these effects.

Do not promise transparent video. Nothing in a video run's schema delivers an alpha channel, so
transparency is made on the extracted frames, not on the clip.

## Isolate and centre

One effect per run, centred, fully inside the frame with margin on every side. A fireball that
leaves the frame cannot be repositioned in an engine, and a second effect in frame has to be cut out
by hand. Say it: "a single effect, centred, entirely within frame, nothing else in the image, no
characters, no scenery".

Effects are seen small and fast: one bright core, one readable shape, one colour that says what the
effect does.

## Timing reads

A one-shot effect has three phases, and the prompt should name all of them with rough timings:
**anticipation** (a gather or charge), **burst** (the peak, fast), **dissipation** (falloff to
nothing). An effect that starts at full intensity reads as a glitch, and one that never fully fades
leaves a ghost on its last frame. End one-shots on empty black.

Loops (auras, portals, torch flames) have no beginning or end: cyclical motion only, and the loop
capability. See `layer-video` for why prompting "looping" alone produces a clip that jumps at the
seam.

## Frames out of the clip

Any image slot (`init_image`, `reference_image`, `first_frame`, `last_frame`) accepts a video
`file_id` and takes one frame of it, chosen by `video_frame` (`first`, `middle`, `last`) or by
`video_frame_seconds`, which overrides it. Space the timestamps evenly across the clip: eight to
twelve frames is a typical flipbook. Each frame is one run of whatever model receives it, so give the
frame a run that does useful work anyway: background removal for alpha-blended effects, an upscale
when the clip resolution is too low. Use `batch_size: 1`, since the default is four.

Some frame-extraction models take an `init_video` and a `frame_extraction_location` instead;
`get_base_model` says which inputs a model requires.

Frames from one locked-camera clip are already registered, so `pack_sprite_sheet` keeps them aligned:
it centres each frame at its own scale in one cell size. Do not trim frames individually first, or
the effect will jitter.

## Worked example

"A fireball impact for our top-down RPG, as an 8-frame flipbook."

1. `list_base_models` with `filter.use_case: "text_to_image"`, first result. Prompt: "Game VFX, a
   single fireball impact at the moment of burst, orange-white core, licking flames, flying embers,
   centred, entirely within frame, pure black background, no ground, no scenery, top-down view."
   Approve one.
2. `list_base_models` with `filter.use_case: "image_to_video"` and
   `filter.capabilities: {fixed_duration: true}`; `get_base_model` on the first result to see which
   frame slots and `video_effects` it takes.
3. Motion prompt with phases: "A small ember gathers for a quarter second, bursts outward fast, then
   flames and embers dissipate to nothing by the end. Locked-off camera, black background throughout."
   Pass the approved still's `file_id` as `first_frame`, `video_effects: [{type: "STATIC"}]` if supported,
   a short `duration_seconds`.
4. Price the job as a whole: the video plus eight frame runs, each estimated as the run it will be.
   Over 20 CUs, ask and wait for an explicit yes.
5. Execute, poll at `poll_interval_seconds`. Pull eight frames at evenly spaced
   `video_frame_seconds`, each into an upscaling run at `batch_size: 1`. Keep the black.
6. `pack_sprite_sheet` with `file_ids` set to the eight frames in play order and `columns: 4`.

## Common mistakes

- Removing the black background from an additive effect, which deletes the glow.
- Using black as the background for smoke or dust, which then cannot occlude anything.
- A scene, floor, or character in the frame around the effect.
- An effect that clips the frame edge.
- A one-shot with no anticipation, or one that never fully fades.
- Promising a transparent video.
- Trimming frames one by one before packing, so the flipbook jitters.
- Leaving `batch_size` at four on per-frame runs and paying four times.

© layerai · MIT · layerai/skills

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

From the same set33

The whole set →
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 layer-tilesets The layer-tilesets Claude Code skill builds game tiles on a shared grid. It activates for isometric, hex, and top-down tilesets, including buildings shown from several sides. CX Codex +1 1,100installs layer-game-ui layer-game-ui — a skill for Claude Code and Codex that structures game UI generation via Layer. Generates 9-slice buttons, aligns icon sets, and exports kits directly to Unity or Godot. CX Codex +1 1,100installs layer-sprite-animation The layer-sprite-animation Claude Code skill builds 2D character sprites and animation cycles from an approved design. It applies to idle, walk, attack and other actions, including four- or eight-direction views. CX Codex +1 1,100installs layer-typography The layer-typography skill for Claude Code renders exact text and brand fonts onto visual assets. Runs when adding titles, logos, and captions to generated graphics. CX Codex +1 1,100installs

Project sponsors

Companies that keep this analytics open