How to Build Meta Ad Creative With Claude Code Skills: A Five-Stage Agent Workflow

A folder on disk beat a better prompt

The extractor said it had clicked five downloads. One file was on disk. Chrome had quietly dropped the other four, the page had no way to observe it, and the run looked like a clean success from every angle except the folder it was supposed to fill.

That failure is why the workflow below exists in the shape it does. On 2026-07-28 we shipped three Claude Code skills into this repository for a single job: take a competitor's live Meta ad and rebuild it as creative we can run. A skill, in Anthropic's own definition, is one of the "organized folders of instructions, scripts, and resources that agents can discover and load dynamically to perform better at specific tasks." Anthropic introduced them in October 2025 and published the format as an open standard that December, so the tooling is established rather than new. What is worth writing down is what happens when you aim it at ad creative and let it fail a few times.

What follows is the five-stage workflow, what each stage is actually for, and the places where the agent made the work worse until we told it to stop.

What a Claude Code skill actually is

A folder, not a longer prompt

The useful mental model is a directory on disk. The only required file inside it is SKILL.md, and Anthropic's Claude Code documentation is blunt about everything else: "The SKILL.md contains the main instructions and is required. Other files are optional and let you build more powerful skills: templates for Claude to fill in, example outputs showing the expected format, scripts Claude can execute, or detailed reference documentation."

Where the folder lives decides who gets it.

Where you put it	Who it applies to
Personal, in ~/.claude/skills/	All your projects
Project, in .claude/skills/	That project only

Ours are project skills, committed to the repo. That is the part that turns a personal habit into something a teammate inherits by cloning.

It loads only when the task calls for it

The economic argument for the format is context. The documentation puts it plainly: "a skill's body loads only when it's used, so long reference material costs almost nothing until you need it." That is what makes it reasonable for our video skill to carry a full reference file of prompt rules, each one derived from a render that came back wrong. Nobody pays for those pages until a clip is actually being rebuilt.

That property also changes how you write the folder. Instructions that must always be true go in the short SKILL.md; the long, specific, painful material goes in a reference file the skill points at. The frontmatter description carries the routing, since the docs describe it as "What the skill does and when to use it. Claude uses this to decide when to apply the skill."

The part that is code, not instructions

The half most people skip is that a skill can ship executables. Anthropic's documentation states that "Skills can bundle and run scripts in any language, giving Claude capabilities beyond what's possible in a single prompt," and the engineering post frames the same idea from the other end: "Skills can also include code for Claude to execute as tools at its discretion."

This matters for ad work more than for most jobs, because the checks worth running are deterministic. None of the following needs a language model, and all three are scripts in our folders:

• Whether a prompt names an actor in every single shot
• Whether the generation ratio matches the source ad's measured ratio
• Whether a finished still has white bands down its sides

Each exists because a render came back broken once.

Stage one: get the competitor's real ads onto disk

One media mode per run, and never a guessed list

Our spy-competitor-ads skill does one thing: find what a brand is currently running in the Meta Ad Library and put the files in a dated folder. It does not rank them, explain why they win, or write a brief. Splitting collection from analysis is what keeps the second half honest.

It asks before it guesses twice. Video ads and static ads are different research questions, so the skill picks one mode per run and asks rather than assuming. And if it had to find the competitor list itself, it shows the shortlist before opening a single tab, because scraping against a list nobody approved produces a swipe file nobody trusts.

Why a zero has four different meanings

The rule that took the most work to encode: an empty result is a claim that needs evidence. The extractor returns a stage-by-stage count, so a zero can always be traced to the stage that starved, and the four causes are not interchangeable.

Stage that starved	What it actually means
No media on the page	A consent or login wall
No cards resolved	The Ad Library markup changed
No brand match	Same-name pollution, or a wrong filter
Every download failed	Expired or geo-blocked media links

Only the last row is anywhere near "this brand runs no ads." The third is the one that bites most often, the classic case being an AI tool and an unrelated sticker shop trading under one word. And a scraper that returns an empty list after a markup change is indistinguishable from an honest empty result, so every conclusion built on top of it inherits the lie.

The download that reports five and delivers one

Then there is the Chrome behaviour from the opening. The browser gates repeated programmatic downloads per origin, and once it trips, every later click is dropped with no error the page can see. So the skill treats the page's own success count as untrustworthy and reconciles against the filesystem with an explicit expected count, exiting non-zero when fewer files landed. A partial swipe file that looks complete is worse than an obviously empty one.

Stage two: read the creative into a reproduction kit

For video, find where the hook ends

A hook is the first few seconds that earn attention before the pitch, and rebuilding one starts with knowing where it stops. Our clone-hook skill trims the clip first, because an eighty-second ad costs the same to read as its first twenty seconds and gives the model room to drift past the boundary. Then it reads what is left into a structured kit:

• The hook boundary, plus the observable signal behind it
• A beat-by-beat timeline of setting, camera moves and pacing
• A casting line locked once and reused, so the actor holds across cuts
• The verbatim script and the caption track, quoted rather than paraphrased
• One generation prompt per zone that is actually generated video

The detail that saves the most money is small. The kit must name the observable signal behind the boundary, not just a timestamp. A model will happily answer "5.0 seconds" with total confidence; requiring it to say what visibly changes at that moment is what turns a guess into a finding. If you are building hooks from scratch instead of cloning them, the patterns behind ad hooks that stop the scroll are the same ones this stage is reverse-engineering.

For static, split structural from brand

The image equivalent, clone-static-ad, reads one frame into a zone map, and the split it enforces is the entire idea.

• Preserve, because it is why the ad works: layout, focal point, copy positions, lighting direction, palette, type hierarchy.
• Swap, because it is not ours: product, logo, wordmark, category claims.

A logo zone marked structural would ship a competitor's mark inside our own ad, so the linter treats that as an error rather than a warning.

It also measures the aspect ratio from the pixels rather than trusting the model's guess, because regenerating a square ad at nine by sixteen reframes every zone and quietly destroys the composition that made it worth copying. If you want the broader version of this discipline, our guide to rebuilding proven ad structures rather than inventing new ones covers the same instinct applied to campaigns Meta documented itself.

The read is a map, not the territory

Both skills carry the same warning, and it comes from a real incident. A video model once reported a hand pressing a pump in a segment that contained no hand. That single invented detail became a wrong archetype, then a wrong documented rule, then a confident defence of a defect that was not there.

So the procedure is to open the structured read beside a contact sheet of frames and check the two against each other. Three details get checked hardest, because they are what every downstream decision turns on:

• Hands, which the model invents more than anything else
• On-screen type, which it paraphrases while sounding certain
• What is visible at the first frame, which sets the archetype

The same caution applies to copy. An illegible headline is a valid answer; a confidently invented one ships as a real claim.

Stage three: lint the prompt before you spend a credit

The rules that catch the most

Every render costs money, so the prompt gets its own pass before anything is dispatched. Three rules earn their place in the video linter, and all three came from renders we paid for twice.

• Every shot needs its own actor descriptor. The video model carries no identity across cuts, so a phrase like "same female creator" resolves to nothing. One test returned three different women across five beats of what was supposed to be one person.
• But keep the descriptor terse. Establish the actor in roughly 37 to 53 characters in the first shot, then hold with 11 to 30 after, anchored on wardrobe rather than a face. A 203-character line held the actor and made everything else in the clip visibly worse.
• Hold printed labels explicitly. On-screen type is re-imagined every frame while logos tend to survive, which is how a real product label came back as an invented brand name with the numbers scrambled.

Keeping one actor stable across a whole set of variations is its own problem, and we wrote it up separately in how to keep one AI actor consistent across every ad variation.

Refusing is part of the job

The static linter refuses in the other direction. It will not generate without a real product image, and it errors on the words "unbranded" and "blank label" in a prompt. A blank-label mockup reads as a stock template rather than an ad, which is precisely what an ad is supposed to prove it is not.

Our social-asset skill goes further and refuses whole formats. It measures an image, matches it against a small registry of layouts it knows how to build, and when nothing matches it says so and offers the copy rewrite alone. "Not built yet" is recorded as a successful result. That line does more for output quality than any prompt improvement we have made, because the alternative is an agent improvising a format nobody has ever validated.

Stage four and five: generate variants, then judge two things

Two takes for video, three for static

The models are probabilistic, so a single render is a sample rather than an answer. Both skills roll more than once, for different reasons.

	Rolls	Why that number
Video	Two	Lip-sync and motion liveness vary per take
Static	Three	Cheaper per call, failures are independent

The video rule has a second half that is easy to get wrong: do not change the prompt between rolls. Varying it tests two ideas instead of two takes of one thing. On the static side, a roll that nails the product often misses the text, and the reverse happens just as often, which is why the third roll pays for itself.

What actually renders it

The pixels come from the same engines any serious tool rents. In these skills, video runs through Seedance 2.0, which handles voice and lip-sync in the same call, so the spoken line goes into the prompt rather than into a separate audio pass. Branded stills route to Nano Banana Pro, which gets logos right on the first try more reliably; unbranded ones route to GPT Image 2. That routing has flipped twice across different input classes, which is exactly why it lives in a script instead of in somebody's memory.

All three are in the Novoads model picker too, which is the point at which this stops being an internal experiment and starts being something you can run without a terminal.

When to stop re-rolling and burn the text on

Reviewing is two questions, not a general impression:

• Does the product match the reference exactly, down to label, colours and proportions?
• Did every text zone render correctly, right spelling, right position, right size?

If no variant lands the wordmark, the answer is not a fourth roll. Wordmarks stay unreliable even when spelled out letter by letter, so the reliable path is compositing clean text over the best render. That is the plan, not the fallback. Everything handed off names which variant won, what was preserved, what was swapped, and which numbers or copy are still placeholders.

Where the agent helps, and where it makes the work worse

It is good at the boring, expensive middle

The honest accounting: the agent adds the most value in the middle of the pipeline, where the work is mechanical, tedious and costly to get wrong.

• Watching a clip beat by beat and writing down exactly what changes
• Checking a prompt against a list of failures somebody already paid for
• Dispatching four renders in parallel and waiting on all of them
• Reconciling what a page claimed against what is actually on disk

None of it is creative work, and all of it is where an afternoon disappears.

It also compounds in a way a person does not. Each new bug becomes one more line in the folder, so the skill is measurably better next month for reasons anyone can read in a diff. That is the same argument behind treating creative operations as a system rather than a scramble.

It is bad at the decisions that are yours

Each of our skills stops and asks rather than deciding. Four questions come back to a human every time:

• Which brand appears in the ad. A fabricated ad for a real company, published on our own account, implies a client relationship that does not exist.
• Whether to keep the source's claim structure. Their hook may rest on a number. Ours needs a real one or a different hook.
• Whether the source's call to action gets dropped. Risky is not the same as not-mine-to-drop-silently.
• Whether the wordmark is generated or burned on. Generated is a coin flip; burned on is deterministic and costs nothing.

None of these are hard for a model to answer. That is the problem. They are easy to answer and expensive to answer wrong, which is the worst possible combination to automate.

The refusals are the feature

Read our four skills and the most valuable lines are the ones that stop:

• No real product photo, no generation
• No readable headline, no invented headline
• No matching format in the registry, no improvised format
• No reconciled download count, no delivered file list

Every one of those refusals costs an output that would have looked fine in a review and been wrong in production. An agent that always produces something is not more useful; it just moves the failure downstream to whoever runs the ad. Knowing which variations are actually worth testing is a separate skill, and it does not survive a supply of plausible-looking creative that nobody checked.

How Novoads solves the creative-supply problem

This workflow assumes you have a terminal, a repository and a reason to maintain folders of prompt rules. Most advertisers do not, and they still have the same problem: Meta ad creative decays and the account needs a steady supply of new angles.

Novoads is the version of stage four without the other four. You upload a product image or write a script, pick an AI actor, and get an ad-ready vertical video, using the same frontier engines these skills call directly. A video runs roughly two to eleven dollars depending on the model, which is what makes running many angles a budgeting question instead of a production one. You can try it for $1, which covers three days of access and converts to the $49 Inicial plan afterwards, and you can cancel at any point. If you want the tool-agnostic version of the process first, start with how to create ads with AI, or with the audience side of a Meta campaign if the creative is already handled.

The skill is the artifact, not the ad

The clips this workflow produces are disposable. Most ad creative is: it runs, it decays, it gets replaced, and the winner from March is a curiosity by August. What survives is the folder, and specifically the guardrail section at the bottom of each one, which grows by exactly one line every time something breaks.

That is the actual output of building ad creative with an agent. Not a faster render, but a written, executable, version-controlled record of every way this work has gone wrong, that a machine reads before it spends money again. If you want the collecting half of the workflow on its own, we broke it out in how to clone a competitor's ads.