Most AI ad copy generators have two problems, and they're both the same problem. They write generic copy, and they ignore the rules of the platform you're writing for.
You type a product name into the generator. It gives you back a headline that's 58 characters long when Meta cuts off at 40, primary text that buries the hook under a sentence of throat-clearing, and a "benefit" that could describe any product in the category. Then you paste it into Ads Manager, watch it get truncated, and rewrite the whole thing by hand. The generator didn't save you time. It gave you a first draft you have to fix.
I got tired of that loop, so I built a small skill that fixes both halves at once. Here's the starter version you can run today.
What an AI Ad Copy Generator Should Actually Do
A useful AI ad copy generator does two jobs, not one. It writes copy that's specific to your product, and it writes copy that fits inside Meta's character limits before you ever see it.
The writing half is a prompt problem. The fitting half is a validation problem. Most tools do a mediocre job of the first and skip the second entirely, which is why their output reads like every other store and breaks the moment it hits the ad preview. The fix is to handle both in one pass: generate against a real brief, then check every line against the limits automatically and throw back anything that fails.
That's a small, buildable thing. You can run it as a Claude Code skill — a markdown instruction file plus one helper script. No paid app, no monthly seat.
Why Generic Generators Produce Copy You Have to Rewrite
The model isn't the problem. The models are good. The input is the problem.
A thin generator asks for a product name and maybe three features. From that, the model has nothing specific to say, so it falls back on the most common patterns in its training data — and the most common ad copy is also the weakest: filler adjectives, vague benefits, and claims that fit every competitor. When the input is generic, the output is generic. This is the same trap I described in the product description piece: the generation step is cheap for everyone now, so the value lives entirely in the brief you write before the model starts.
The character-limit part is even simpler. Meta truncates headlines at 40 characters, shows roughly the first 125 characters of primary text above the fold, and caps link descriptions at 30. A generator that doesn't know those numbers will hand you copy that looks fine in a text box and gets chopped in the feed. The fix is to make the limits a constraint the tool enforces, not a rule you remember.
The Starter Skill
Two files. The first is the skill instruction. Save it as SKILL.md in ~/.claude/skills/meta-ad-copy/.
---
name: meta-ad-copy
description: Generate Meta ad copy from a product brief across four
angles, then validate every line against Meta's character limits.
---
# Meta Ad Copy
Generate paid-social ad copy that fits Meta's character limits on
the first pass.
## When to use
The user gives a product brief and wants headlines, primary text,
and link descriptions for a Meta campaign.
## Inputs you need (ask if any are missing)
- PRODUCT: name + one line of what it is
- BUYER: the specific person — what they've tried, what frustrates them
- WHY IT WORKS: the concrete reason (ingredient, material, feature)
- OFFER: price, guarantee, or promo, if any
## What to generate
Write copy across four angles: problem-solution, direct benefit,
feature-benefit, social proof.
- 5 headlines (40-character limit)
- 5 primary-text options (lead the first 125 chars with the hook)
- 3 link descriptions (30-character limit)
## Rules
- No filler adjectives (premium, luxurious, game-changing).
- No claim you can't back with the brief.
- 6th-grade reading level. Short sentences. No emojis.
## Validate before returning
Write the candidates to copy.json in this shape:
{"headlines": [...], "primary_texts": [...], "descriptions": [...]}
Then run: python3 validate.py copy.json
Rewrite any line the validator marks FAIL. Return only passing copy.
The second file is the validator. Save it as validate.py in the same folder. It's Python standard library only — nothing to install.
#!/usr/bin/env python3
"""Validate Meta ad copy against character limits and banned terms."""
import json, sys, re
LIMITS = {"headlines": 40, "primary_texts": 125, "descriptions": 30}
BANNED = ["premium", "luxurious", "game-changing", "game changer",
"elevate", "unlock", "supercharge", "revolutionary"]
EMOJI = re.compile("[\U0001F000-\U0001FAFF☀-➿]")
def check(line, limit):
issues = []
if len(line) > limit:
issues.append(f"{len(line)}/{limit} chars over limit")
low = line.lower()
issues += [f"banned term '{w}'" for w in BANNED if w in low]
if EMOJI.search(line):
issues.append("contains emoji")
return issues
def main(path):
data = json.load(open(path))
failed = 0
for kind, limit in LIMITS.items():
print(f"\n{kind.upper()} (limit {limit})")
print("-" * 36)
for line in data.get(kind, []):
issues = check(line, limit)
status = "PASS" if not issues else "FAIL"
failed += 1 if issues else 0
note = "" if not issues else " <- " + "; ".join(issues)
print(f"[{len(line):>3}] {status} {line}{note}")
print(f"\n{'ALL PASS' if not failed else str(failed) + ' line(s) need a rewrite'}")
sys.exit(1 if failed else 0)
if __name__ == "__main__":
main(sys.argv[1] if len(sys.argv) > 1 else "copy.json")
The skill writes the copy. The script is the part the generic tools skip — it counts every line, flags the overflows and the filler words, and refuses to pass anything that would break in the feed.
How to Use It
Step 1 — create the two files.
mkdir -p ~/.claude/skills/meta-ad-copy
# paste SKILL.md and validate.py into that folder
Step 2 — give it a brief. In Claude Code, invoke the skill and hand it the four inputs:
Use the meta-ad-copy skill. PRODUCT: a magnesium deodorant, baking-soda-free.
BUYER: switched to natural, started smelling worse by 2pm, blames the brand.
WHY IT WORKS: magnesium for odor, arrowroot for wetness, no baking soda so no rash.
OFFER: refund if it doesn't last 8 hours.
Step 3 — let it validate. The skill generates the copy, writes copy.json, and runs validate.py. Any line that's too long or leans on a banned word comes back FAIL and gets rewritten before you see the final set.
Example Output
Here's what the validator prints on a real run, before the rewrite pass:
HEADLINES (limit 40)
------------------------------------
[ 35] PASS Natural deodorant that lasts all day
[ 33] PASS No baking soda. No 2pm rash.
[ 47] FAIL Experience premium all-day odor protection <- 47/40 over limit; banned term 'premium'
[ 28] PASS Magnesium does the heavy lifting
[ 31] PASS Switched to natural and regret it?
PRIMARY_TEXTS (limit 125)
------------------------------------
[ 118] PASS Switched to natural and started smelling worse by 2pm? That's the baking soda. This one skips it...
[ 121] PASS Magnesium handles odor, arrowroot handles wetness, no baking soda means no rash. Lasts a full day.
DESCRIPTIONS (limit 30)
------------------------------------
[ 24] PASS Refund if it quits early
[ 29] PASS Baking-soda-free, all day
1 line(s) need a rewrite
One headline got caught for two reasons at once — too long and filler. The skill rewrites it and reruns until the whole set passes.
Where the Starter Falls Short
The starter is enough for one product at a time. It stops being enough once you're running paid social across a book of accounts. A few things break down:
- No brand-voice memory. You re-paste tone and rules into every brief instead of having them baked in per client. Voice drifts when you're moving between accounts all day.
- No live customer language. The brief uses whatever you remember, not a current pull from reviews, comments, and support tickets — which is where the words that actually convert live.
- No push to Meta. You still copy-paste into Ads Manager. Nothing lands the validated copy into a paused campaign for you.
- No performance loop. Nothing tracks which of the four angles won on CTR or cost per result, so the generator never gets smarter about what sells for your catalog.
Those are the gaps that matter once volume goes up, and they're deliberate — the starter is a starter.
The Production Version
The full version of this is wired into a campaign workflow instead of a single file. Brand voice is defined once per client and enforced on every line, customer language is pulled from live review data, and the validated copy drops straight into a paused Meta campaign brief ready to push. That lives in the Copy Vault and Ad Operator systems inside The Operator ($397), along with the rest of the Claude Code course.
Bonus: Wire It to the Meta API
The starter stops at validated text. The next step is removing the copy-paste. Meta's Marketing API lets you create ads programmatically, so a passing copy.json can be pushed straight into a paused ad set — built, not yet spending — for a final visual check. Pair that with the AI prompts I actually use for the research that feeds the brief, and the whole path from product to live-ready copy stays in one place.
If you'd rather not build any of it, Clare Digital runs paid-social copy and campaign management across client accounts — book an intro call.
Q: Is AI-generated ad copy against Meta's policies?
No. Meta's ad policies are about what you claim, not who wrote it. AI-generated copy is fine as long as the claims are accurate, substantiated, and within the rules for your product category. Always have a human verify any factual, health, or financial claim before it goes live — the model doesn't know your compliance constraints unless you tell it.
Q: How is this different from the AI ad copy generator built into ad platforms?
The platform tools (Meta's Advantage+ copy suggestions, the generators inside Shopify apps) optimize for speed and breadth, not specificity. They take a thin brief and produce safe, generic copy. A structured skill like this one forces a real brief — buyer, mechanism, objection, offer — and validates against the platform's limits, so you get copy that's specific to your product and fits the feed on the first pass.
Q: Do I need to know how to code to use this?
No. The two files are copy-paste. You edit the brief in plain English and the skill runs the validator for you. The only command-line step is creating the folder once. If you've set up a Claude Code skill before, this is the same pattern.