Communitygithub.com

visual-effects

Designs VFX, particles, trails, glitch, transitions, and hand-drawn effects (drawings that draw themselves, write-on hand lettering, line boil, paper texture) that are deterministic, narratively functional, and safe for photosensitive viewers.

What is visual-effects?

visual-effects is a Claude Code agent skill that designs VFX, particles, trails, glitch, transitions, and hand-drawn effects (drawings that draw themselves, write-on hand lettering, line boil, paper texture) that are deterministic, narratively functional, and safe for photosensitive viewers.

Works with~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/achmdfzn/motionforge-atelier/tree/HEAD/.claude/skills/visual-effects

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

VISUAL EFFECTS

Mission

Create VFX that strengthen focus, energy, and storytelling — not effects that cover up a weak concept.

Workflow

  1. Define the function: emphasis, atmosphere, transition, impact, depth, or brand signature.
  2. Set intensity, duration, color, screen area, and sync point.
  3. Choose the simplest approach: CSS/SVG/canvas/Remotion primitives/3D.
  4. Check compatibility and render cost before adding a library.
  5. Build reusable parameters per scene.
  6. Test legibility, banding, flicker, aliasing, clipping, and performance.
  7. Provide a low-intensity fallback when an effect could hurt accessibility.

Hand-drawn effects

A drawing that draws itself

When a hand-drawn piece is shown being made, the viewer must believe a hand is making it:

  • Frame 0 is the empty surface — bare paper, board, or ground. No pre-drawn parts.
  • Marks follow the medium's order from the Style Bible (style-direction, Hand-drawn media): e.g. pencil before watercolor washes, outline before marker fill, lightest ink layer first.
  • Marks are made, never faded or scaled in. A line grows along its path; a wash spreads from where the brush landed; a paper piece drops and settles. A whole drawing fading in reads as fake.
  • Human pace. Long, simple strokes go fast; small, detailed strokes go slower; leave short pauses between passes (a few frames up to about half a second). Constant speed for every stroke reads as a plotter.
  • The final frames equal the finished still. Hold the completed drawing at the end; the hold itself must not be a frozen frame (see No dead air below).

Implementing a write-on stroke in Remotion

Draw each stroke as an SVG path and reveal it from the frame. With pathLength={1} every path has length 1, so progress maps directly to the dash offset:

const frame = useCurrentFrame();
// stroke drawn over frames [start, start + duration)
const p = interpolate(frame, [start, start + duration], [0, 1], {
  extrapolateLeft: 'clamp',
  extrapolateRight: 'clamp',
  easing: Easing.inOut(Easing.quad),
});
<path d={d} pathLength={1} strokeDasharray={1} strokeDashoffset={1 - p}
      fill="none" stroke={ink} strokeWidth={w} strokeLinecap="round" />
  • Schedule strokes from a central list ({ id, d, start, duration }), computed once from the medium's order; never chain timers.
  • Derive each stroke's duration from its length so pace varies naturally (e.g. duration = base + length × k, clamped).
  • Fills and washes: reveal with an animated mask or clip (a growing blob from the brush-down point), not with opacity.

Hand lettering that writes itself

  • Regular fonts are outlines; revealing their outline traces both edges and looks wrong. Use single-stroke (centerline) lettering — authored paths per glyph or a single-line font with a license that allows it — and reveal each stroke in writing order.
  • Keep hook text short (a few words per line), inside the safe area, on a calm ground or plate so every letter stays readable.
  • Text must stay fully written on screen long enough to read before the next change; budget extra time for long lines or a second-language audience.

Line boil and paper

  • Line boil (the slight shimmer of hand-drawn lines) is optional and must be deterministic: change the wobble seed on a fixed cadence, e.g. random(\${id}-${Math.floor(frame / 6)}`)for 10 changes per second at 60 FPS. Never useMath.random()`.
  • Keep boil subtle and slower than a flicker; it must not violate the photosensitivity guardrail below.
  • Paper texture goes on top of the drawing as one fixed layer (an image or an SVG noise filter with a fixed seed) at a constant opacity. Do not animate the paper.

No dead air

In anything that moves, something visibly changes every second. During a "hold" the camera may creep or a small element may breathe, but the subject never becomes a frozen frame. Check this by watching, not only by measuring: a slow camera move changes every pixel yet can still read as a still to the eye.

Guardrails

Avoid fast flicker/strobing that puts photosensitive viewers at risk. Glitches must be short and motivated. Avoid glow/particles/transitions without a function. Randomness must be seeded/deterministic. Animation is frame-driven. Do not render MP4 without permission.

Output format

  • VFX brief per scene: function, frame in/out (half-open), intensity 0–1, normalized screen area, sync-point frame.
  • Effect stack (table): effect | parameter | value | seed | low-intensity fallback.
  • Parameter sheet per effect: start/end values, easing, duration in frames, and what changes when a parameter is changed.
  • Performance budget: number of effect layers, expensive blurs/filters, and estimated render cost (no benchmark claims without measurement).
  • Dependency notes: libraries used, installed versions, and what happens if a library is missing.

QA checklist

  • Every effect has a written narrative function; effects without one are removed.
  • No fast flicker/strobing; glitches are short and motivated.
  • Randomness is seeded per scene/asset; the same frame produces the same visual on re-render.
  • Text stays readable while effects run; effects do not cover the CTA/logo.
  • A low-intensity fallback is defined and can be enabled without changing the timeline.
  • Render cost checked: large blurs, stacked transparency, and full-frame effects are limited.
  • Drawing-itself sequences start from an empty surface, follow the medium's order, and end on the finished still.
  • No part of a drawing fades or scales in; every mark grows along its path or spreads from a brush point.
  • Write-on lettering uses single-stroke paths, not revealed font outlines.
  • Line boil (if any) is seeded on a fixed cadence and stays below flicker speed.
  • Something visibly changes every second; holds are never frozen frames.

Mini example

Impact reveal (12 frames, half-open): scale 0.9 → 1 with a spring (damping 200), glow rises 0 → 0.4 then falls to 0.1 by frame 8, seed s01-impact. If the glow covers text, lower it to 0.2 before changing the timing.

Failure modes

  • The effect hides the message → lower intensity/area first; do not add another effect.
  • Unintended flicker → check odd/even frames and remove sudden changes between consecutive frames.
  • Performance drop → replace full-frame blur with a local glow or a pre-rendered asset.
  • Drawing looks "pasted in" → it was faded or scaled; rebuild it as strokes revealed in the medium's order.
  • Lettering looks like it is being traced twice → a font outline was revealed; switch to single-stroke glyph paths.
  • Drawing feels mechanical → every stroke runs at the same speed; derive duration from stroke length and add short pauses between passes.
  • The end of the video feels dead → the final hold is a frozen frame; add a slow camera creep or a small breathing element.

Individual skills in this repo

This repo contains 4 individual skills — each has its own dedicated page.

Related Skills