How to build a creative engine that gets smarter every week
The step-by-step build: winners in, variations out, learnings back in.
Last post I said the creative loop is where UA productivity actually moves, and that producing fast without a learning loop just leaves you wrong at scale. A handful of you asked what that loop looks like in practice. So here's the build, step by step. This is the engine I stand up before automating anything else.
One rule holds the whole thing together: start from what already won, never a blank prompt.
1. Mine your winners first
Pull your top 10 creatives ranked by D7 ROAS (downstream value, the metric that actually pays rent, not CTR or IPM). Feed them into an LLM and have it name the pattern: the hook, the first 3 seconds, the promise, the CTA, the pacing. You're after the why behind the win, written in plain language you can hand back to the machine.
Most teams brief off vibes and a mood board. Your winners already told you what works. Read them first.
2. Generate at the pattern level
Ask for 25 to 30 new hooks built off that winning pattern. Random concepts only make volume you'll throw away. Pattern-level gives you variations with a reason to exist. Cut anything your product can't actually back, an LLM will happily write a promise your game can't keep, and that creative dies on contact with real users.
3. Batch the production
Push the strongest scripts into your generative video and static tools, and let AI own the mechanical work: aspect ratios, text overlays, background swaps, hook cuts, endcard variants. One concept turns into 20 on-brand variants in about an hour, in every format the networks want. I know because I built this into a tool called Creative Engine: one spec sheet in, a full batch out, auto-named and ready for Meta, TikTok, and AppLovin.
4. Localize on the same rails
Take each winning concept and spin market versions off the same source. Swap the on-screen language, re-voice the hook, re-time the pacing for the network. 12 market cuts by Thursday instead of next quarter, and every one traces back to a proven winner rather than a fresh guess.
5. Tag on the way out, every time
Before anything launches, label it: hook type, visual style, offer, CTA, first frame. Tag at creation and your analysis is basically free later. Skip it and you're back to hand-tagging 20-plus hours a week, or worse, guessing at what drove the installs. This is the step that closes the loop, so protect it when the week gets busy. It's the first thing people drop and the one that costs the most.
6. Test like you mean it
Give each variant enough budget to read a real signal, hold everything else steady, and kill losers fast. A great engine feeding a lazy testing setup just burns money quicker. Decide your read window before you launch (D7 ROAS, or whatever maps to your payback), not after you've gotten attached to a cut you love.
7. Feed the winners back in
This week's champions become next week's step 1. Every cycle starts from a better baseline than the last. That compounding is the entire reason to build an engine instead of prompting ad hoc, and it's why two teams with the same tools and the same budget pull apart fast. One restarts from zero every Monday. The other restarts from its best week yet.
What actually stays human
Notice what's missing from those seven steps: picking the winners. The market does that, against a number you set, and it does it no matter what the creative looks like. Twenty variants go out, your kill line runs, and whatever clears it gets the budget. The polished hero cut you love can die at $1.40 CPI while an ugly text-on-gameplay hook you'd never have shipped scales at $0.84. That's the engine working exactly as intended.
Your job moves up a level. You define what winning means (the metric, the payback window, the kill line), you point the system at the right products and markets, and you read what comes back to place the next bet. That call is worth more than any gut read on a single creative, and it's the part the engine doesn't touch.
One failure mode worth naming: teams jump straight to step 3, generate a pile off a blank prompt, and wonder why nothing scales. Winners in, tags on, loop closed. Build it in that order and it compounds. Build it out of order and you just make bad creative faster.
Get on the list
Creative Engine, the tool I linked above, runs the creative side of this today: it mines your winners, generates at the pattern level, tags every asset on the way out, and feeds the results into the next batch. I'm wiring that same loop together with the tagging analysis, the reporting against your MMP, and the ops grind into one agent called Pablo.
It's early, and I'm letting a first group in before wider release. If you want it, or you just want the next breakdowns as they land (the tagging loop is up next), get on the list.