editorial-collage-motion

Original：🇨🇳 Chinese

Translated

2 scripts

Decode a reference image or brief description into an editable halftone paper-collage specification. By default, use the Codex built-in `image_gen` to create brand-consistent stills and transparent layers, then use local FFmpeg or HyperFrames to produce a deterministic motion video that assembles piece by piece from an empty background. Use this when the user mentions halftone collage, paper collage, paper-cut collage, editorial collage, magazine collage, retro print collage, collage motion, collage animation, paper-cut animation, paper-piece assembly, layer-by-layer assembly, from nothing to something, elements flying in and assembling, stop-motion collage, stop-motion animation, Arcads style, reference-image breakdown, style breakdown, reverse-engineering a visual, “make it in this style,” “make something similar,” “generate collage stills,” “animate this image,” “make these elements assemble,” or “create a collage ad or collage explainer video.” English trigger semantics include editorial collage, halftone collage, paper collage, paper-cut motion, stop-motion graphic, assemble from empty, build-on motion, analyze this, break this down, reverse-engineer this look, generate the stills, animate this, and make these move. By default, do not invoke Arcads, Nano Banana, Seedance, or Kling. Enter an external generation path only when the user explicitly requests it and the corresponding connector is available.

1installs

Sourcepluviobyte/rnskill

Added on2026-10-21

NPX Install

npx skill4agent add pluviobyte/rnskill editorial-collage-motion

SKILL.md Content (Chinese)

View Translation Comparison →

Halftone Collage Motion

Divide creation into two stages: first decode the visuals into an editable specification, then build the animation from approved stills or transparent layers. Use the local-compatible workflow by default and accurately record every generator and renderer.

Choose the Delivery Scope

First determine which level the user requires:

Analysis only: deliver the breakdown, generic prompt, and JSON visual specification.
Stills only: complete the analysis and generate and curate stills.
Collage motion: complete still approval and then produce a silent animation base.
Full video: use this Skill as the visual stage while continuing to comply with the video production contract, captions, voiceover, digital humans, and archiving rules.

If no reference image is provided but the user explicitly asks to “analyze this image,” request the image first. If only a brief description is provided, draft the specification directly and do not repeatedly ask for information that is already known.

Choose the Execution Path

Use the local path by default:

Stills or layers: load the
```
imagegen
```
Skill and use Codex's built-in
```
image_gen
```
. Do not switch by default to the OpenAI API, CLI, or another image-generation model.
Simple layer-by-layer assembly: use
```
scripts/render_assembly.py
```
.
Complex layouts, multiple transitions, or component-level timelines: load the
```
hyperframes
```
Skill and follow this specification and its provenance declarations.

Only when the user explicitly requests Arcads, Nano Banana, Seedance, or Kling, and the corresponding tool is callable in the current session, read

references/provider-boundaries.md

and enter the external path. Before uploading local brand images, product images, or images of people, explain the upload destination, cost, and purpose and obtain the user's confirmation.

Do not infer the actual provider from prompts, filenames, or the expected model. Any model that was not actually invoked may only be described as a “target prompt” or a “compatible style,” never as the output source.

Default Production Pipeline (Hard Default)

Follow this sequence strictly:

Decode the reference image or brief description and produce a breakdown, generic prompt, and JSON visual specification.
Use Codex's built-in
```
image_gen
```
to generate a complete still for each scene separately. Brand, product, or people references must remain visible in every relevant call.
Copy the generated results from Codex's default generated-images directory to the project's
```
assets/stills/
```
. The project must not continue referencing files under
```
$CODEX_HOME/generated_images/
```
.
Display the complete stills to the user. Do not generate an animation, FFmpeg assembly plan, or final video until the user has explicitly approved the stills.
After the stills are approved, use Codex's built-in
```
image_gen
```
to generate the individual paper-cut elements. When transparent PNGs are required, first generate a solid-color chroma-key background, then perform local key removal with the
```
remove_chroma_key.py
```
script specified by the
```
imagegen
```
Skill, followed by an alpha preflight.
Use the approved still to lock the final composition, build
```
assembly-plan.json
```
from the transparent layers, and then use local FFmpeg or HyperFrames to assemble the elements one by one from an empty background.

Complete the media probe, keyframe inspection, and provenance manifest. By default, record

actual_still_provider: codex-image-gen

actual_motion_provider: local-ffmpeg

hyperframes

, and

external_uploads: false

If the user directly supplies all stills or transparent layers, change

actual_still_provider

user-supplied

. Arcads, Nano Banana, Seedance, or Kling may be listed only when they were genuinely invoked through an external call.

Stage A: Decode the Reference

During the initial decoding, read

references/visual-contract.md

and

references/schemas.md

in full. Output the following in order:

```
### Breakdown
```
: medium and craft, color fields, elements and cut edges, composition and hierarchy, single-scene concept, text, safe area, and mood.
```
### Generic Prompt
```
: a self-contained natural-language prompt that does not depend on “the image above.”

### JSON Specification

: copied from

assets/templates/collage-spec.json

and completed while remaining valid JSON.

Express observations as reproducible parameters. For example, write “black-and-white circular halftone dots at approximately 65 lpi, with a thin white outline and a soft 6px shadow at the bottom right,” rather than merely saying “has a paper texture.”

Decode multiple reference images separately, then add a shared style summary. If the user asks to “preserve the appearance and change only the colors,” modify only the relevant fields, but output the complete JSON again.

Stage B: Plan the Scenes

Keep only one core concept per scene. Lock the following for each scene:

Background color and aspect ratio.
Primary elements, secondary elements, hierarchy, and final coordinates.
Text content, typography, and editable method.
Entry order from an empty background to the completed composition.
Avoidance zones for real people, digital humans, captions, logos, and platform UI.

Build the assembly plan from

assets/templates/assembly-plan.json

. For the final production, prefer

layered

mode, with each element supplied as a PNG with an alpha channel.

bands

mode merely slices a complete still into strips that slide into view and may only be used for a quick preview or a simplified version explicitly accepted by the user.

Stage C: Generate and Approve the Stills

Load the

imagegen

Skill and use Codex's built-in

image_gen

to generate or combine the complete stills first, then present them for user approval. Keep brand or product references visible in every relevant generation call.

The local production mode works in this order:

Make one separate built-in
```
image_gen
```
call per scene to generate a complete compositional still. Do not combine different scenes into a single large image through one call.
Copy the selected stills to the project's
```
assets/stills/
```
and record the final prompts and reference-image roles.
Display the stills and obtain explicit user approval. Before approval, only prompt adjustments and regeneration are allowed.
After approval, generate the individual collage elements. Use the
```
imagegen
```
chroma-key and local key-removal path to obtain transparent PNGs, preserving white keylines and soft shadows.
Calibrate each layer's size, coordinates, and hierarchy against the approved still. By default, retain text as editable text layers in HyperFrames, HTML, or Remotion.
Export the scene stills and layer manifest before proceeding to the animation stage.

If the built-in

image_gen

is unavailable or fails, do not automatically switch to the CLI. Explain that the CLI/API path requires

OPENAI_API_KEY

, and switch only after the user explicitly agrees.

If only one complete still is available, the

bands

mode can provide a low-cost motion preview, but rectangular strip slide-ins must not be described as true element-by-element assembly.

Stage D: Assemble Layers Locally

First validate the specification and plan:

bash

python3 .claude/skills/editorial-collage-motion/scripts/validate_collage.py \
  --spec /absolute/path/collage-spec.json \
  --plan /absolute/path/assembly-plan.json \
  --project /absolute/path/project

Then render the silent base:

bash

python3 .claude/skills/editorial-collage-motion/scripts/render_assembly.py \
  --project /absolute/path/project \
  --plan /absolute/path/assembly-plan.json \
  --output /absolute/path/project/renders/collage-assembly.mp4

The animation must begin with a solid-color empty canvas, with elements entering from the edges of the frame and settling into place according to the plan. Camera shake, whole-image drift, or continuous zooming must not be used to imitate assembly. Leave enough readable time after the elements settle.

Stage E: Quality Assurance and Provenance

Read

references/qc-and-provenance.md

in full and complete at least the following:

Media probe: dimensions, aspect ratio, frame rate, duration, encoding, and decodability.
Inspect the first frame, the frames immediately before and after each scene settles, each scene's midpoint, and the final frame.
Check the empty-background start, element-by-element entry, shadow stability, text readability, safe areas, and visual density.
Ensure that
```
render-manifest.json
```
agrees with the actual outputs, input plan, and generators.

Explicitly state the following in the production notes:

```
actual_still_provider
```
```
actual_motion_provider
```
```
external_uploads
```
Whether the output is a
```
compatible_render
```
, and which visual specification it is compatible with

When Arcads MCP was not called in the current session, always use “Arcads-style compatible render” or “editorial collage local render.” Never describe the output as native Nano Banana or Seedance output.

Resources

```
references/visual-contract.md
```
: style vocabulary, mandatory visual contract, and counterexamples.
```
references/schemas.md
```
: field descriptions for visual specifications and assembly plans.
```
references/provider-boundaries.md
```
: permission and disclosure boundaries for local and external generation paths.
```
references/qc-and-provenance.md
```
: delivery quality assurance and provenance recording.
```
assets/templates/collage-spec.json
```
: reusable visual specification template.
```
assets/templates/assembly-plan.json
```
: reusable local assembly plan template.
```
assets/templates/assembly-plan-bands.json
```
: strip-preview template used only when a complete still is available.
```
scripts/validate_collage.py
```
: preflight validation for specifications, plans, and assets.
```
scripts/render_assembly.py
```
: deterministic FFmpeg renderer for layer-by-layer or strip-based assembly.