layer-ua-creatives

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.