Skip to main content
skill CX Codex

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

layer-ua-creatives — a skill for Claude Code that orchestrates game performance ad production on Layer. Builds variant testing matrices across static concepts, motion, reframed aspect ratios, and CTA cards.

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

What layer-ua-creatives does

The skill coordinates game user acquisition workflows across Layer tools, structuring tests into clear axes with IDs like H2-V1-C1. It binds generations to approved game key art using reference_image or reference_sets so characters and visual style remain consistent across all variants.

Copy is layered via render_text and compose_image without burning Creative Units or relying on model spelling. Different placement ratios derive from a single master through reframing, while statics convert to motion using image_to_video with the still frame set as first_frame.

Operation depends on sibling skills layer, layer-image, layer-video, layer-video-timeline, and layer-typography. Jobs projected above 20 Creative Units halt for explicit approval before running.

What it helps with

  • Build an attributable ad variant matrix across hooks and visuals
  • Reframe a master visual into 9:16 and square aspect ratios
  • Convert an approved static frame into a video ad
  • Overlay clean typographic copy and CTA cards without model spelling errors

Example prompts for the agent

  • Make an ad creative test for our merge game: three hooks, square and 9:16, plus motion for the winning static
  • Reframe this master art to vertical 9:16 and compose the headline text on top

How to install layer-ua-creatives

1Skills CLI (Vercel)

npx skills add layerai/skills --skill layer-ua-creatives -a claude-code

2Manually: put the files in place

~/.claude/skills/layer-ua-creatives/SKILL.md

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

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

Questions about layer-ua-creatives

How to install layer-ua-creatives in Claude Code?

Run npx skills add layerai/skills --skill layer-ua-creatives -a claude-code in your terminal.

What does layer-ua-creatives do?

It designs structured UA creative batches for games on Layer, covering prompt setup, aspect ratio reframing, static-to-motion transitions, and CTA end cards.

What is required to run layer-ua-creatives?

It requires access to Layer along with sibling skills layer, layer-image, layer-video, layer-video-timeline, and layer-typography.

Source text

SKILL.md · MIT
---
name: layer-ua-creatives
description: "Use when making user acquisition or performance marketing creative for a game with Layer: static ad concepts, hook variants, statics turned into motion, video ads for TikTok, Meta, YouTube or ad networks, end cards and CTAs, or one master resized for every placement. Also when a creative test needs attributable variants. Keywords: UA, user acquisition, ad creative, performance ads, hook, CTA, end card, static to motion, variants, A/B test, placements, 9:16."
license: MIT
---

# Layer UA Creatives

## Overview

A user acquisition creative is a test, not a portrait. It exists to learn which hook, visual, and
call to action bring players in, so the unit of work is a **matrix of variants** that each differ in
one known way, not one beautiful ad. A batch where every image changes the character, the copy, and
the background at once cannot tell the user anything when one of them wins.

Generation mechanics and the spend gate are in the `layer` skill, prompt craft is in `layer-image`,
motion is in `layer-video`, and assembly with end cards is in `layer-video-timeline`. Exact copy on
an image is `layer-typography`. This skill covers how those combine into a creative test.

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

| Step                    | Tool or filter                                                      | Why                                                      |
| ----------------------- | ------------------------------------------------------------------- | -------------------------------------------------------- |
| Anchor the look         | Approved key art as `reference_image`, or the game's reference sets | Every variant must look like the same game               |
| Static concepts         | `use_case: "text_to_image"`, `capabilities: {image_editing: true}`  | Reproduces the game's subjects from the references       |
| One master, many ratios | `use_case: "reframing"`, explicit `width` and `height`              | Extends the frame instead of cropping the subject        |
| Static to motion        | `use_case: "image_to_video"`, the still as `first_frame`            | The approved frame fixes the look; the model adds motion |
| Exact copy              | `render_text`, then `compose_image`                                 | Image models misspell; these spend no Creative Units     |
| End card and CTA        | `render_video_timeline`                                             | Holds the CTA as a designed card, not generated text     |

## Build the matrix before generating

Write the test down as axes before the first run: two to four **hooks** (the opening idea: a near
miss, a power fantasy, a choice the viewer wants to make, a before and after), one or two **visuals**
per hook, and one or two **CTAs**. Give every cell an id such as `H2-V1-C1` and pass it as the file
`name` wherever a tool takes one, so a result in the ad dashboard maps back to exactly what changed.

Change one axis per variant. If the user wants a new character and a new hook, that is two tests.

Show the game as it plays. A creative that promises mechanics the game does not have wins the click
and loses the player after install. When the user has
real gameplay captures, upload them with `request_file_upload_url` and build on them.

## Statics

Anchor every static on the approved key art or the game's trained reference sets, never on prose
alone: rewriting the same description does not reproduce a character. Attach the key art as
`reference_image` on a model filtered for `image_editing`, or pass the game's sets in
`reference_sets` and read `reference_sets_degraded` on the estimate before trusting the batch.

Compose for the thumbnail. A feed shows the ad small and briefly, so one subject, one
action, and high contrast between them beat a detailed scene. Leave clear space where the copy will
go, and say so in the prompt ("empty sky across the top third for a headline").

Keep copy out of the generation. Set the headline with `render_text` on a canvas sized to its box,
then layer it over the art with `compose_image` (art at the bottom with `fit_and_crop`, text above).
Both spend no Creative Units, so copy variants are free.

## One master, every placement

Do not generate each placement separately: the character moves, the palette shifts, and the test
now varies by placement as well. Approve one master, then derive each placement from it with
`use_case: "reframing"` and the master as `init_image`.

Pass both `width` and `height` for every target: with either missing and an init image attached,
the output takes the master's shape. Take exact pixel sizes from the user or the network's current published spec,
not from memory.

## Motion

Static to motion tests whether a winning static works as video. Reframe the static to the video's ratio first, then animate that frame with `image_to_video` and the frame as
`first_frame`. Cropping a finished video to another ratio is where heads go missing.

The hook has to land in the opening seconds, so the motion prompt leads with the action, not with
an establishing move: "the tower topples toward the camera in the first second" rather than "slow
push in on a village, then the tower falls". Clip length and loop behaviour are in `layer-video`.

Assemble shots, logo, music, and a held CTA end card with `render_video_timeline`; the card carries
exact text, never generated lettering.

## Pricing a batch

Price the whole job before the first call. Per `get_forge_instructions`, calls that differ only in
prompt wording or seed share one estimate times their count, but each distinct kind prices apart:
one estimate for the statics, one per reframe target size, one per video length, plus
`estimate_video_timeline_price` for the edit. Sum them; above 20 CUs, show the table and wait for an
explicit yes. Then execute and poll each run at `poll_interval_seconds`.

## Worked example

"Make a creative test for our merge game: three hooks, square and 9:16, plus motion for the best
static."

1. `list_reference_sets` for the game's sets; the approved key art already carries a `file_id`.
2. Matrix: hooks H1 (near miss), H2 (satisfying merge chain), H3 (before and after board), one
   visual each, one CTA. Six statics: three hooks at two ratios.
3. `list_base_models` with `filter.use_case: "text_to_image"` and
   `filter.capabilities: {image_editing: true}`; take the first result. Generate three square masters
   with the key art as `reference_image`, each prompt naming one hook and the empty band for copy.
4. `list_base_models` with `use_case: "reframing"`. Each master becomes `init_image` with
   `width` and `height` set to the user's 9:16 size.
5. `render_text` for the headline and CTA once per ratio; `compose_image` onto each of the six
   frames, named `H1-V1-C1-1x1` and so on.
6. For motion: the user picks one static. Its 9:16 frame goes to `image_to_video` as `first_frame`
   with `duration_seconds` set (filter `fixed_duration: true` so the model honours it),
   then `render_video_timeline` adds the logo and a held CTA card.
7. Before step 3, estimate every kind (statics, reframes, video, timeline), present the total, and
   wait for a yes above 20 CUs.

## Common mistakes

- Variants that change several things at once, so a winner teaches nothing.
- Generating each placement separately instead of reframing one master.
- Passing only `width` or only `height` when reframing, and getting the master's shape back.
- Asking the image model for the headline instead of using `render_text`.
- Cropping a finished video to a new ratio instead of reframing its first frame.
- An opening that establishes before it hooks.
- Depicting gameplay the game does not have.
- Estimating one static and running thirty.

© layerai · MIT · layerai/skills

Similar skills

All skills for Marketing and content →

From the same set33

The whole set →
layer-image layer-image — a skill for text-to-image runs through Layer: what to put in the prompt, how to set aspect ratio, and when to upload a reference instead of describing it. CX Codex +1 4,900installs layer-workflow-import layer-workflow-import converts third-party node graphs, exported pipelines, or prose descriptions into Layer Blueprint workflows. Helps migrate external AI pipelines directly into Layer. CX Codex +1 4,000installs layer-live-ops layer-live-ops — a Claude Code skill for producing art content for live games. It handles item evolution, upgrade chains, currency packs, and seasonal reskins. CX Codex +1 1,100installs layer-localization The layer-localization Claude Code skill prepares video and image assets for multiple languages. It activates for dubbing, voice-over, burned-in captions, or text changes derived from an approved master. CX Codex +1 1,100installs 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

Project sponsors

Companies that keep this analytics open