Here’s how to fix it.

Folder Setup

Create this on your desktop before you do anything else:

[your-brand]-campaign/
├── CLAUDE.md
├── refs/
│   ├── character.jpg
│   └── world-ref.jpg
└── outputs/

• CLAUDE.md — your creative brief. Claude reads this before generating anything.

• character.jpg — your hero shot. The face and outfit every image anchors to.

• world-ref.jpg — a reference image for your world: the environment, lighting, mood.

• outputs/ — where your generated images land.

Step 1 — Write Your CLAUDE.md

Copy this template. Fill in every field. The more specific, the better — vague inputs produce inconsistent outputs.

# [Brand] Campaign — Creative Director Brief

## Character
[Age range, face structure, expression, what they're wearing — be specific]

## World
[Location, time of day, environment — what's in the background]

## Lighting
[Available light / studio / natural. Describe the colour and direction.]

## Camera
[Film or digital. Focal length. Aperture. Framing — close, medium, full body.]

## Shot Types
- [Shot 1 — e.g. walking towards camera, looking off to side]
- [Shot 2 — e.g. standing still, looking into distance]
- [Shot 3 — e.g. three-quarter turn, profile]
- [Shot 4 — e.g. full body, small in frame, environment behind]
- [Shot 5 — e.g. close crop, chest and face, product logo prominent]
- [Shot 6 — e.g. your choice]

## Visual Rules
- Always [rule — e.g. night, never daytime]
- Always [rule — e.g. film grain, never clean digital]
- Never [rule — e.g. studio, always location]
- Mood: [one phrase — e.g. cold, focused, editorial]

Step 2 — Add Your References

Drop two files into refs/:

• character.jpg — your hero shot. Sharp focus on face and clothing. Same energy as the campaign shots you want.

• world-ref.jpg — a photo (or a few) that captures the world: the location, lighting, time of day. Night street, warm bokeh, film grain — whatever your brief says. Claude reads both before it generates anything.

Step 3 — Run It in Claude Code

Open Claude Code inside your campaign folder. Paste this exactly:

“Read the CLAUDE.md and everything in refs/. You are a creative director. Generate 6 fal.ai image prompts based on the shot types in CLAUDE.md. Call the fal.ai API using gpt 2 with image conditioning for each prompt, using refs/character.jpg as the reference image. Save all outputs to the outputs/ folder.”

Claude generates the prompts, calls the fal.ai API, and saves the images to outputs/. You never leave the session.

A good prompt looks like this:

“35mm film photo of a young man in a navy puffer jacket with red script logo, walking towards camera looking slightly off to the side, night city street, warm orange bokeh lights, film grain, f/1.8, editorial streetwear campaign.”

If your prompts come out vague, your CLAUDE.md is too thin. Add more detail and run it again.

This workflow produces 100. One session. No team.

Claude Code reads a brand brief, calls GPT Image 2, generates every format and copy angle automatically, then builds a dashboard so everything is organized and ready for Meta.

Here’s the full setup.

What this is

Claude Code is Anthropic’s AI coding tool. You talk to it like a chat, and it writes and runs code for you. You don’t need to know how to code to use it.

GPT Image 2 is OpenAI’s image generation model — it produces high-quality ad visuals from a text description. In this workflow, Claude Code calls GPT Image 2 automatically using the brand brief you give it.

fal.ai is the platform that hosts GPT Image 2 and lets Claude Code access it via an API. Think of it as the bridge between Claude Code and the image generator. It costs roughly $0.04–0.08 per image, so a full run of 100 ads costs around $4–8.

What you need before you start

1. Claude Code — download it at claude.ai/code. It’s a desktop app. Free to start, paid plans available.

2. A fal.ai account — sign up at fal.ai. Free to create. You’ll add a small amount of credit (a few dollars covers hundreds of ads).

3. Your FAL_KEY — once you’re logged into fal.ai, go to Dashboard → API Keys → Create new key. Copy it. This is what gives Claude Code permission to generate images on your behalf. Keep it private — don’t share it.

4. A brand to run it on — a real product with a real brief. The more specific, the better the output.

Step 1 — Create your project folder

Make a new folder on your desktop called ads-workflow. Open it in Claude Code.

In Claude Code, type: “Create an empty .env file in this folder.” Claude creates it. Then open the file directly in VS Code and add your key yourself:

FAL_KEY=paste_your_key_here

Get your key at fal.ai → Dashboard → API Keys.

Important: Never paste your API key into the Claude Code chat. Always add it directly into the file.

Step 2 — Build the brand brief

Create a file called brief.md. Copy this template and fill in every field for your brand:

brand_name: [Your brand name]
product_name: [Your product name]
product_description: [1–2 sentences. Be specific — what it is, what makes it different]
product_url: [Brand's website — Claude reads this to pull real copy, positioning, and tone. Use the actual product page URL, not the homepage]
product_image: [filename of your product photo — e.g. product.jpg — drop the image into the same folder as brief.md. Claude uses this as the visual reference so every generated ad shows the actual product]
target_audience: [Specific — e.g. "female founders 28–40 running DTC brands"]

primary_color: "[Hex code — e.g. #4A7C59]"
secondary_color: "[Hex code]"
background_color: "[Hex code]"
font_style: [e.g. clean sans-serif, bold serif, modern minimal]
imagery_style: [e.g. studio product photography, lifestyle, dark moody, bright minimal]
product_placement: [e.g. centered, floating, slight shadow, lifestyle context]
mood: [e.g. confident, premium, playful, aspirational]

ad_formats: [square_1x1, story_9x16, banner_16x9]

copy_angles:
  - angle_1: [Name — e.g. "speed" — and a headline idea]
  - angle_2: [Name — e.g. "quality" — and a headline idea]
  - angle_3: [Name — e.g. "simplicity" — and a headline idea]
  - angle_4: [Name — e.g. "value" — and a headline idea]
  - angle_5: [Name — e.g. "transformation" — and a headline idea]

Don’t rush this. A specific brief produces on-brand ads. A vague brief produces generic ones.

Step 3 — Build the generation script

In Claude Code, paste this exactly:

“Read brief.md and build a Python script called generate_ads.py that does the following: connects to fal.ai using FAL_KEY from .env, reads every field from the brief, generates ad images using GPT Image 2 across all three formats in ad_formats, applies each copy_angle to every format, names every output file as format-copyangle-variant-v1.png, and saves everything to an /output folder. Add a --test flag that runs 5 ads. Add a --full flag that runs all 100.”

Claude builds the script. Don’t touch it.

Subscribe now

Step 4 — Test run

python3 generate_ads.py --test

5 ads generate into /output. Check the naming, quality, and format. If it looks right, move on. If something’s off, tell Claude Code what to fix before running the full batch.

Step 5 — Full run

python3 generate_ads.py --full

Let it run. Don’t touch anything. 100 ads generate, named and organized by format, copy angle, and variant.

Step 6 — Build the dashboard

In Claude Code, paste this exactly:

“Read all image files from the /output folder and build a file called dashboard.html. Dark background (#0D0D0D). Display all images in a 4-column CSS grid. Label each image with its filename below it. Add a header that shows the brand name and today’s date. Make it look like a production tool — clean, minimal, professional.”

Builds in under a minute.

Step 7 — Open and review

In Claude Code, type: “Open dashboard.html in my browser.”

Claude opens it for you. Every creative is in there — labeled by format, copy angle, and variant. Scroll through it.

When you’re ready to use them, grab the files from the /output folder on your desktop and drop them into Meta Ads Manager.

That’s the full system. Change the brief, run it again, get 100 ads for a different brand. Takes one session.

The brief template above is everything you need to get started.

Here’s how to set it up.

Step 1 — Install genmedia

Open your terminal and run:

curl <https://genmedia.sh/install> -fsS | bash

Then connect your fal API key:

genmedia setup

Get your key at genmedia.sh. Takes 60 seconds.

Step 2 — Install the UGC Marketing skill

Run:

genmedia init

Then take the skill file at the bottom of this post and drop it into your project:

your-project/.claude/skills/ugc-marketing/SKILL.md

This is what makes Claude Code smart about UGC. It knows which model to use, how to prompt for lifestyle shots, and where to save outputs. Without it you’re prompting from scratch every time.

Step 3 — Upload your references

Upload your character reference:

genmedia upload ./character.png --json

Upload your product image:

genmedia upload ./product.png --json

Both return a CDN URL. Save them — you’ll use them in the brief.

Step 4 — Write your product brief

Create ./brief/product-brief.md in your project folder. Include:

• Character reference URL

• Product reference URL

• Product description — format, color, no logo required

• World — setting, lighting, vibe

• Shot list — 8 to 10 specific moments

• Output — number of images, model, folder path

The more specific the brief, the better the output. Vague brief = generic images.

Step 5 — Run it

Open Claude Code in your project folder and type:

generate the full UGC set from the brief in ./brief/product-brief.md

Claude reads the brief, loads the skill, and fires one genmedia command per shot. Folder fills up. Done.

What you get

A full UGC lifestyle set. Consistent character. Consistent product. One window open.

What used to require a browser, a dashboard, and three tool switches now runs from a single prompt.

The UGC Marketing Skill — copy this into .claude/skills/ugc-marketing/SKILL.md

---
name: ugc-marketing
description: >
  Plan and run UGC and commercial image production with genmedia. Use this
  for UGC lifestyle shots, product photography, ads, e-commerce batches,
  product reveals, background replacement, social formats, and brand-safe
  prompt work.
---

# UGC Marketing with genmedia

Load model-routing alongside this skill for default endpoint choices.
Keep output production-focused. No inflated marketing language, no fake
text in images, no unsupported claims.

## Inputs to collect

- Character: face reference URL, outfit, vibe, expression
- Product: name, format, color, no logo required
- World: setting, lighting, time of day
- Goal: UGC lifestyle, product still, hero shot, social ad
- Shot list: 8–10 specific moments
- Output: number of images, folder path

## Workflow

1. Upload every reference file first.

genmedia upload ./character.png --json
genmedia upload ./product.png --json

2. Run each shot synchronously.

genmedia run fal-ai/gpt-image-2/edit \\
  --image_urls '["<character_url>","<product_url>"]' \\
  --prompt "<shot description>" \\
  --image_size portrait_4_3 \\
  --quality high \\
  --download "./outputs/ugc/shot{index}.jpeg" \\
  --json

3. Use schema fields exactly. Do not pass guessed flags.

## Model routing

- UGC lifestyle stills: fal-ai/gpt-image-2/edit
- Character consistency: fal-ai/gpt-image-2/edit with image_urls
- Fast drafts: fal-ai/flux-2/klein/9b
- Image editing: fal-ai/nano-banana-pro/edit
- Video: bytedance/seedance-2.0/image-to-video

## Prompt build order

1. Character — face, outfit, energy, sweat, expression
2. Product — format, color, position in frame
3. Setting — location, surface, time of day
4. Lighting — natural, harsh sun, golden hour, window light
5. Camera — angle, distance, iPhone selfie feel
6. Tone — raw, unfiltered, authentic, never staged

## Quality bar

- Character is consistent across all shots
- Product placement is natural, never hero or staged
- No invented brand logos or readable text
- Lighting matches the world defined in the brief
- All outputs downloaded via --download flag

The fix is a system.

Claude Code has a feature called custom commands — skill files you drop into your project once and Claude executes as a defined workflow. You type one command. Claude reads your brand rules, asks for inputs, and produces a complete deliverable in sequence. Five skills, one pipeline: brief to shot list to image prompts to ad copy to client deliverable. Everything you need is below.

What you’re building

Two files. That’s the whole setup.

A CLAUDE.md file — your brand rules. Claude Code reads this automatically at the start of every session. Fill it in once with your brand’s colors, visual mood, product description, tone of voice, and visual always/never rules. Every skill reads the same file. You never re-explain the brand.

Five skill files — custom commands that live in .claude/commands/ inside your project folder. One command per workflow, no re-prompting.

The pipeline:

1. /brand-brief — product + brief → campaign creative direction

2. /shot-list — brand brief → complete shot plan

3. /image-prompts — shot list → production-ready prompts for NanoBanana

4. /ad-variations — one hero visual → 10 ad copy variations

5. /campaign-pack — all 5 outputs bundled into one client deliverable

Setup

Step 1 — Create your project folder

Create a new folder on your computer. Name it after your brand. This is your Claude Code project — everything runs from here.

One step most people skip: add reference images before you run anything. Find 3–5 images that show the visual world you want. Save them into the folder and name them ref-1, ref-2, ref-3. Claude Code reads them directly. Without references, outputs are generic. With them, outputs match what you had in mind.

Step 2 — Create your CLAUDE.md

Copy the block below, paste it into VS Code or Cursor, and save as CLAUDE.md inside your project folder. Replace every placeholder with your actual brand details.

# CLAUDE.md — Brand Rules
# Replace all values below with your brand details. Claude Code reads this file automatically at the start of every session.

---

## Brand Name

[Your brand name]

---

## Visual Identity

**Primary colors:**
- [Color name]: [hex value]
- [Color name]: [hex value]
- [Color name]: [hex value]

**Secondary colors:**
- [Color name]: [hex value]
- [Color name]: [hex value]

**Visual mood:** [2–3 words — e.g. "gritty, nocturnal, worn-in" or "clean, clinical, precise"]

**Aesthetic references:** [2–3 reference points — real campaigns, photographers, or lookbooks that show the visual world]

**Visual references (images):**
- ref-1.jpg
- ref-2.jpg
- ref-3.jpg

Save 3–5 reference images into this project folder and name them ref-1, ref-2, etc.

---

## Product

**What it is:** [One sentence — category, materials, key visual detail]

**What it does:** [One sentence — what it delivers for the person using it]

**How it's typically shown:** [One sentence — how the product appears in campaign content]

---

## Campaign Style

**Always:**
- [Visual rule 1]
- [Visual rule 2]
- [Visual rule 3]

**Never:**
- [Visual rule 1]
- [Visual rule 2]
- [Visual rule 3]

---

## Tone of Voice

**Voice in one sentence:** [How the brand talks — e.g. "Direct, no warmup, confident without being loud"]

**Always says:** [2–3 language patterns or word choices the brand uses]

**Never says:** [2–3 things the brand doesn't say]

---

## Target Audience

**Who they are:** [One sentence]

**What they care about:** [One sentence]

---

## Output Format

**Default aspect ratio:** [e.g. 4:5 for feed]
**Secondary formats:** [e.g. 1:1, 9:16]
**Platform primary:** [e.g. Instagram]

Step 3 — Install the skill files

You don’t need to create any folders manually. For each skill below:

1. Open Claude Code with your project folder as the working directory

2. Copy the full code block for that skill

3. Paste it into Claude Code and send this message: “Create the file .claude/commands/[skill-name].md with the content I just pasted.”

4. Claude creates the file and the folder structure automatically

Do this once for each of the 5 skills. After that, type the command to run it.

The 5 Skills

Skill 1 — /brand-brief

Campaign creative direction from your product details and brief. Every other skill in this pipeline reads from this output.

Install as: .claude/commands/brand-brief.md

# brand-brief
# Claude Code custom command. When the user types /brand-brief, follow every step below in order. Do not skip steps or combine them.

---

## Step 1 — Confirm brand rules loaded

Read the CLAUDE.md file in this project folder.

Output a confirmation block in this exact format:

---
**Brand rules loaded**

Brand: [brand name]
Primary colors: [list hex values]
Visual mood: [2–3 word mood]
Product: [one sentence]
Tone: [2–3 word voice description — from CLAUDE.md if defined, otherwise "not specified"]
Target audience: [one sentence if defined, otherwise "not specified"]
---

Then ask: "Does this look right? Type yes to continue, or tell me what to correct."

Wait for the user to confirm before moving to Step 2.

---

## Step 2 — Get the campaign inputs

Ask the user for the following. Accept all answers at once if they provide them together:

1. Campaign name or working title
2. What this campaign is for — product launch, seasonal push, brand awareness, restocking a hero SKU, or other
3. Campaign mood or feeling (e.g. "cold and precise", "warm and tactile", "nocturnal and worn-in") — distinct from the brand's baseline mood if needed
4. Target audience for this specific campaign — who you're trying to reach and what they care about right now
5. Platforms this campaign will run on — list all: Instagram feed, Instagram Reels, TikTok, Meta ads, email, other
6. Campaign timeline — start date, end date, or "ongoing"
7. Any mandatory elements — specific claims, product features that must appear, anything off-limits

If any of the first five are missing, ask for them before continuing.

---

## Step 3 — Generate the campaign creative brief

Using the brand rules from CLAUDE.md and the campaign inputs, generate the complete creative brief. Output every section below in full.

---

**CAMPAIGN CREATIVE BRIEF**

**Campaign:** [campaign name]
**Brand:** [brand name]
**Date:** [today's date]

---

**Campaign objective:**
[One sentence — what success looks like for this campaign. Specific, not general.]

**Target audience (this campaign):**
[2–3 sentences. Who they are, what they want right now, what would make them stop and pay attention.]

---

**Creative direction:**

**Visual concept:**
[2–3 sentences. Describe what the campaign looks like — not a mood board concept, but what a camera would see. Anchored in the brand's palette, mood, and aesthetic rules from CLAUDE.md.]

**Shot type direction:**
List the primary shot types this campaign needs. For each, specify: what it shows, the role it plays (hero / supporting / social), and the platform it's designed for.

- Shot type 1: [what it shows] — [role] — [platform]
- Shot type 2: [what it shows] — [role] — [platform]
- Shot type 3: [what it shows] — [role] — [platform]
[Continue for as many as the campaign requires]

**Tone for this campaign:**
[One sentence — how the copy and captions should feel. Anchored in the brand's voice from CLAUDE.md, adjusted for this campaign's mood if different.]

---

**Platform specs:**

For each platform listed in the campaign inputs:

**[Platform name]**
- Format: [aspect ratio, file type]
- Primary content type: [photo / video / carousel / story]
- Hook approach: [how to open — what earns the scroll on this platform]
- Copy length: [character count or guideline]
- CTA direction: [the action you want]

---

**Visual rules for this campaign:**

Always (in addition to brand rules):
- [Campaign-specific visual rule 1]
- [Campaign-specific visual rule 2]

Never (in addition to brand rules):
- [Campaign-specific visual restriction 1]
- [Campaign-specific visual restriction 2]

---

**Production notes:**
[Any practical constraints — budget signal, team size, whether this is in-studio or location, existing assets that must be incorporated.]

---

After outputting the full brief, ask: "Does this brief look right? Approve to continue to the shot list, or tell me what to adjust."

Wait for the user to confirm before telling them: "Run /shot-list to generate your complete shot plan from this brief."

Skill 2 — /shot-list

A complete, structured shot plan from the campaign brief — hero, lifestyle, detail, ad crops, and social cuts, each specified with scene, framing, and platform destination.

Install as: .claude/commands/shot-list.md

# shot-list
# Claude Code custom command. When the user types /shot-list, follow every step below in order. Do not skip steps or combine them.

---

## Step 1 — Confirm brand rules and brief

Read the CLAUDE.md file in this project folder.

Then ask: "Paste your campaign brief below, or type 'use last' if you just ran /brand-brief and the brief is still in this session."

If the user pastes a brief, read it in full before continuing.
If the user types 'use last', reference the brief output from the current session.

Output a confirmation block:

---
**Ready to build shot list**

Brand: [brand name]
Campaign: [campaign name]
Visual mood: [mood from brief or CLAUDE.md]
Platforms: [list platforms from brief]
---

Ask: "Does this look right? Type yes to continue."

Wait for confirmation before Step 2.

---

## Step 2 — Get shot list parameters

Ask the user for the following. Accept all answers at once:

1. Total number of shots needed (or "as many as the campaign requires")
2. Shot categories to include — choose any combination:
   - Hero shots (product as primary subject, full brand treatment)
   - Lifestyle shots (product in context, environment-forward)
   - Detail shots (close-ups — texture, material, key visual detail)
   - Ad crops (formatted specifically for paid placement, clean background)
   - Social cuts (short-form or story-format, designed for Reels or TikTok)
3. Any specific shots the user already knows they need

If the user says "all categories," generate shots across all five types. Weight toward hero and lifestyle unless the brief specifies otherwise.

---

## Step 3 — Generate the shot list

Using the brand rules, campaign brief, and shot parameters, generate the complete shot list.

Format every shot exactly like this:

---
**Shot [number] — [shot category]**

Scene: [one sentence — the physical setting. Surface, props if any, environment. Specific, not abstract.]
Product role: [hero / supporting / background]
Key visual detail: [the one thing the camera must show clearly]
Framing: [tight / medium / wide] + [angle: overhead / eye level / low angle / 45-degree]
Platform destination: [which platform(s) this asset is designed for]
Format: [aspect ratio]
Priority: [must-have / nice-to-have]
---

Rules for the shot list:
- Every shot must be distinct — vary framing, environment, and product role across the list
- Hero shots: product dominant, brand palette visible, no competing elements
- Lifestyle shots: product in a real context, environment adds meaning
- Detail shots: under 18 inches from the subject, show material or craft
- Ad crops: clean, single focal point, works at small sizes
- Social cuts: designed to work in 9:16, product visible in the first frame

After the full shot list, output:

---
**Shot list summary**

Total shots: [number]
Hero: [count]
Lifestyle: [count]
Detail: [count]
Ad crops: [count]
Social cuts: [count]
Must-haves: [count]
Nice-to-haves: [count]
---

Ask: "Does this shot list work? Approve to continue to image prompts, or tell me what to change."

Wait for approval before telling them: "Run /image-prompts to generate production-ready prompts from this shot list."

Skill 3 — /image-prompts

One production-ready image prompt per shot — under 60 words, written for NanoBanana, locked to your brand’s palette and visual rules.

Install as: .claude/commands/image-prompts.md

# image-prompts
# Claude Code custom command. When the user types /image-prompts, follow every step below in order. Do not skip steps or combine them.

---

## Step 1 — Confirm brand rules and shot list

Read the CLAUDE.md file in this project folder.

Then ask: "Paste your approved shot list below, or type 'use last' if you just ran /shot-list and the list is still in this session."

If the user pastes a shot list, read it in full before continuing.
If the user types 'use last', reference the shot list output from the current session.

Output a confirmation block:

---
**Ready to generate image prompts**

Brand: [brand name]
Visual mood: [mood from CLAUDE.md]
Primary colors: [hex values]
Shots to convert: [total shot count from shot list]
---

Ask: "Does this look right? Type yes to continue."

Wait for confirmation before Step 2.

---

## Step 2 — Check for reference images

Ask: "Do you have reference images in your project folder? If yes, name them (ref-1.jpg, ref-2.jpg, etc.) and I'll incorporate them. If not, type 'no references' and I'll build from brand rules only."

If references are named, note them. Use them to inform the visual language of the prompts — surface quality, light quality, color temperature — without describing them directly.

---

## Step 3 — Generate image prompts

Convert each shot from the approved shot list into one image prompt.

Rules for every prompt:
- Under 60 words
- Photorealistic — describe only what a camera lens would see
- No abstract mood words (no "ethereal", "dreamlike", "luxurious", "editorial") — replace with physical descriptions
- Reference brand palette hex values or tone words directly in the prompt
- Structure: subject → lighting (source, direction, quality) → color (brand palette reference) → framing → surface or environment detail → style note if relevant
- Match the aspect ratio specified in the shot list for each shot

Format each prompt exactly like this:

---
**Prompt [number] — [shot category from shot list]**
Platform: [platform destination from shot list]
Aspect ratio: [from shot list]

[Full prompt text. Subject. Lighting. Color. Framing. Surface. Under 60 words.]
---

After all prompts are output, ask: "Do any prompts need adjusting? Name the shot number and tell me what to change, or type 'done' to finalize."

Make any requested changes, then output the final prompt set as a clean numbered list with no formatting between them — ready to copy into NanoBanana or any image generator.

After the final list, tell the user: "Run /ad-variations to generate ad copy from your hero visual, or run /campaign-pack to bundle everything into a client deliverable."

Skill 4 — /ad-variations

10 complete ad copy variations — hook, body, CTA — each using a different hook type, formatted for the platform you specify.

Install as: .claude/commands/ad-variations.md

# ad-variations
# Claude Code custom command. When the user types /ad-variations, follow every step below in order. Do not skip steps or combine them.

---

## Step 1 — Confirm brand rules loaded

Read the CLAUDE.md file in this project folder.

Output a confirmation block in this exact format:

---
**Brand rules loaded**

Brand: [brand name]
Product: [one sentence]
Tone: [2–3 word voice description — from CLAUDE.md if defined, otherwise "not specified"]
Target audience: [one sentence if defined, otherwise "not specified"]
---

Then ask: "Does this look right? Type yes to continue, or tell me what to correct."

Wait for the user to confirm before moving to Step 2.

---

## Step 2 — Get the hero visual and brief

Ask the user for the following. Accept all answers at once if they provide them together:

1. Hero visual — ask them to drag the image into the chat, describe it in one sentence, or reference it by shot number from the shot list
2. What the image shows — product, setting, key visual detail visible in the frame
3. Campaign goal — awareness, conversions, add-to-cart, or lead gen
4. Target audience for this specific ad — who they are, what they want, what frustrates them currently
5. Platform — Meta (Facebook/Instagram), TikTok, or both
6. Primary CTA — the one action you want them to take
7. Any mandatory claims or restrictions — legal disclaimers, specific features that must or cannot appear in copy

If any of the first five are missing, ask for them before continuing.

---

## Step 3 — Generate 10 ad copy variations

Using the brand rules, the hero visual description, and the campaign brief, generate 10 complete ad copy variations.

Rules for all copy:
- Match the brand's tone from CLAUDE.md exactly — no generic marketing language
- Every variation must be complete: hook, body, CTA
- Hooks must stop the scroll — first line earns the second, no warmup, no greeting
- Body copy: one idea per variation, not a feature list
- CTA must match the platform norms and campaign goal

Hook types to distribute across the 10 (use each at least once, vary the rest):
- Contradiction — says the opposite of what they expect
- Specificity — a number, a time, a result — something concrete
- Direct address — speaks to one person's exact situation
- Result first — leads with the outcome, not the process
- Social proof — anchors on behavior or adoption, not testimonials

Format each variation exactly like this:

---
**Variation [number] — [hook type] — [platform: Meta / TikTok / Both]**

**Hook:**
[First line — under 10 words. No punctuation tricks, no emojis.]

**Body:**
[2–4 sentences. One idea. Specific, not general. Written in the brand's voice from CLAUDE.md.]

**CTA:**
[The action. Platform-appropriate. One line.]

**Character count:** [total character count for hook + body + CTA combined]
---

After all 10 variations, output a summary table:

| # | Hook Type | Platform | Hook Line | CTA |
|---|-----------|----------|-----------|-----|
[Fill in every row]

Ask: "Do you want these formatted for Meta Ads Manager, TikTok Ads Manager, or a CSV export? Or type 'done' to finish."

**If Meta Ads Manager:**
Output each variation with:
Primary Text: [hook + body combined]
Headline: [5 words or under]
Description: [CTA text — under 25 characters]

**If TikTok Ads Manager:**
Output each variation with:
Ad Text: [hook + body combined, under 100 characters]
Call to Action: [select from: Shop Now / Learn More / Sign Up / Download / Contact Us / Apply Now]

**If CSV:**
Output a markdown table with columns: Variation | Platform | Hook Type | Hook | Body | CTA | Character Count
Tell the user: "Copy this table into Google Sheets and save as CSV. It maps directly to bulk upload templates for both platforms."

**If done:**
Leave the copy as formatted above. Tell the user: "Run /campaign-pack to bundle all outputs into one client deliverable."

Skill 5 — /campaign-pack

All four prior outputs bundled into one client deliverable — brief summary, shot list, prompts, ad copy, and a production checklist.

Install as: .claude/commands/campaign-pack.md

# campaign-pack
# Claude Code custom command. When the user types /campaign-pack, follow every step below in order. Do not skip steps or combine them.

---

## Step 1 — Confirm brand rules loaded

Read the CLAUDE.md file in this project folder.

Output a confirmation block:

---
**Brand rules loaded**

Brand: [brand name]
Product: [one sentence]
---

Ask: "Does this look right? Type yes to continue."

Wait for confirmation before Step 2.

---

## Step 2 — Collect the session outputs

Ask the user: "Paste the outputs from this session below — brand brief, shot list, image prompts, and ad variations. You can paste them all at once or one at a time. Type 'done' when everything is in."

Accept all pasted content. Read and organize it before continuing. If any of the four outputs is missing, note which one and ask: "I don't see [missing output]. Paste it now or type 'skip' to leave that section blank in the pack."

---

## Step 3 — Generate the campaign pack

Using all provided outputs, generate the complete campaign pack. Output every section in full.

---

**CAMPAIGN PACK**

**Brand:** [brand name]
**Campaign:** [campaign name from brief]
**Prepared:** [today's date]
**Prepared by:** [leave as "(insert brand name" unless the user specifies otherwise]

---

### SECTION 1 — CAMPAIGN BRIEF SUMMARY

[Condense the full brand brief into a clean 6–8 line summary:]

**Campaign:** [name]
**Objective:** [one sentence]
**Target audience:** [two sentences max]
**Visual direction:** [two sentences max — what the campaign looks like]
**Tone:** [one sentence]
**Platforms:** [list]
**Timeline:** [dates or "ongoing"]

---

### SECTION 2 — SHOT LIST

[Reproduce the full approved shot list exactly as generated by /shot-list. Do not summarize or shorten it.]

---

### SECTION 3 — IMAGE PROMPTS

[Reproduce the final clean prompt list from /image-prompts. One prompt per shot, numbered, no extra formatting between them.]

---

### SECTION 4 — AD COPY VARIATIONS

[Reproduce all 10 variations from /ad-variations in full — hook, body, CTA, character count for each. Include the summary table at the end.]

---

### SECTION 5 — PRODUCTION CHECKLIST

Generate a production checklist based on everything in the pack. Every item is a specific task, not a category header.

**Pre-production:**
- [ ] Brand rules confirmed in CLAUDE.md
- [ ] Reference images saved to project folder (ref-1, ref-2, ref-3)
- [ ] Shot list approved
- [ ] [Any other pre-production item implied by the brief or shot list]

**Image production:**
- [ ] [One line per shot from the shot list — "Hero shot 1 — [scene description]"]

**Ad copy:**
- [ ] 10 ad variations reviewed and top 4–5 selected for testing
- [ ] Selected variations formatted for [platform(s) from brief]
- [ ] [Any compliance or legal review noted in the brief]

**Delivery:**
- [ ] All image assets exported at [format and resolution from CLAUDE.md]
- [ ] Ad copy formatted for upload — [Meta / TikTok / both]
- [ ] Campaign pack document delivered to [leave blank for user to fill in]

---

After outputting the full pack, tell the user: "Your campaign pack is complete. Copy the full output into a Google Doc or Notion page and share with your team or client."

How to use it

One session. Brief in, full campaign out.

Each skill runs in sequence — /brand-brief produces the direction, /shot-list plans the assets, /image-prompts writes production-ready prompts, /ad-variations tests 10 copy angles, /campaign-pack bundles everything. The CLAUDE.md is what makes this reliable — every skill reads the same brand rules at the start. Swap the file for a different brand and all five skills work for that brand instead.

If you want this built for your brand — custom workflow, your tools, done for you — fill out this form: https://app.youform.com/forms/avjlmcgd

What you’re building

Two files. That’s the whole setup.

A CLAUDE.md file — your brand rules. Claude Code reads this automatically at the start of every session. You fill it in once with your brand’s colors, visual mood, product description, and what the brand always and never does visually. After that, Claude already knows the brand every time you open the project.

A skill file (brand-shoot.md) — a custom command. You type /brand-shoot, and Claude runs the full workflow in sequence: confirms your brand rules are loaded, asks for your campaign brief, generates a shot list, writes image prompts, and generates the images. One command, five steps, complete shoot.

The files

File 1: CLAUDE.md

1. Create a new folder on your computer — name it whatever your brand is

2. Copy everything in the block below

3. Open VS Code or Cursor, paste it, and save the file as CLAUDE.md inside that folder

4. Replace every placeholder value with your actual brand details — colors, mood, product description, visual rules

That folder is your Claude Code project. Everything runs from here.

One step most people skip: add reference images to your project folder before running the workflow. Find 3–5 images that show the look you want — campaign photos, editorials, anything — save them into the folder and name them ref-1, ref-2, ref-3. Claude Code reads them directly. Without references the outputs are generic. With them, the outputs actually match what you had in mind.

# CLAUDE.md — Brand Visual Rules
# Replace all values below with your brand details. Claude Code reads this file automatically at the start of every session.

---

## Brand Name

Bloc

---

## Visual Identity

**Primary colors:**
- Off-white: #F0EDE8
- Washed navy: #1A2035
- Faded black: #0D0D0D

**Secondary colors:**
- Concrete grey: #6B6B6B
- Dirty white: #D9D4CC

**Visual mood:** gritty, nocturnal, worn-in

**Aesthetic references:** Supreme campaign photography, Palace lookbooks, Stüssy night shots — real locations, real light, nothing staged

**Visual references (images):**
- ref-1.jpg
- ref-2.jpg
- ref-3.jpg

Save 3–5 reference images into your project folder and name them ref-1, ref-2, etc. Claude Code reads them directly from the folder when writing prompts.

---

## Product

**What it is:** Heavyweight streetwear — graphic hoodies, varsity jackets, oversized tees, outerwear

**What it does:** Bold enough to read from across the street, built to last

**How it's typically shown:** Worn on a real person in a real location — city streets, parking lots, underpasses, storefronts at night. Chest graphic always legible. Environment adds context, never competes.

---

## Campaign Style

**Always:**
- Nighttime or blue-hour light — streetlights, neon, headlights
- Person in frame wearing the piece — chest graphic facing camera
- Real urban locations — nothing rented or sanitized
- Film grain or low-light texture — not clean, not polished
- Single subject, single garment per shot

**Never:**
- Studio lighting or white backdrops
- Flat lay or hanger shots
- Daytime bright sunlight
- Multiple people in the same shot
- Lifestyle props unless the brief calls for it

---

## Output Format

**Default aspect ratio:** 4:5 (portrait) for feed posts

**Secondary format:** 1:1 (square) for grid, 9:16 (vertical) for Stories and Reels

**Platform specs:** Instagram primary — file delivery at 1080px minimum on the short side

File 2: The skill file

You don’t need to create any folders manually. Just do this:

1. Open Claude Code with your project folder open (the folder where you saved CLAUDE.md)

2. Copy the entire code block below

3. Paste it into Claude Code and send this message: “Create the file .claude/commands/brand-shoot.md with the content I just pasted.”

4. Claude creates the file and the folder structure automatically

5. Type /brand-shoot to run it

That’s it. Claude handles the setup.

# brand-shoot
# Claude Code custom command. When the user types /brand-shoot, follow every step below in order. Do not skip steps or combine them.

---

## Step 1 — Confirm brand rules loaded

Read the CLAUDE.md file in this project folder.

Output a confirmation block in this exact format:

---
**Brand rules loaded**

Brand: [brand name]
Primary colors: [list hex values]
Visual mood: [2–3 word mood]
Product: [one sentence]
---

Then ask: "Does this look right? Type yes to continue, or tell me what to correct."

Wait for the user to confirm before moving to Step 2.

---

## Step 2 — Get campaign brief

Ask the user for the following. Accept all answers at once if they provide them together:

1. Campaign name or working title
2. Feeling or mood for this campaign (e.g. "slow morning", "gift-worthy", "clinical trust")
3. Context or setting (e.g. "bathroom shelf", "outdoor market table", "minimalist kitchen counter")
4. Number of shots needed
5. Formats needed — list aspect ratios (e.g. 1:1, 4:5, 9:16)

If any of these are missing, ask for them before continuing.

---

## Step 3 — Generate shot list

Using the campaign brief and the brand rules from CLAUDE.md, generate a structured shot list.

Format each shot exactly like this:

**Shot [number]**
Scene: [one sentence describing the physical scene — surface, props, environment]
Product role: [hero / supporting / background]
Key surface or prop: [specific material or object]
Framing: [tight / medium / wide] [angle if relevant — overhead, eye level, low angle]

Generate one shot per number requested. Make every shot distinct — vary framing, surface, and product role across the list.

After outputting the shot list, ask: "Does this shot list work? Approve to continue, or tell me what to change."

Wait for approval before moving to Step 4.

---

## Step 4 — Generate image prompts

Convert each approved shot into an image prompt.

Rules for each prompt:
- Under 60 words
- Photorealistic — describe only what a camera lens would see
- No abstract mood words (no "ethereal", "dreamlike", "magical") — replace with physical descriptions
- Format: subject → lighting (source, direction, quality) → color (reference brand palette hex values or tone words) → framing → surface detail → style reference if relevant

Output format for each prompt:

**Prompt [number]**
[prompt text]

After outputting all prompts, move immediately to Step 5.

---

## Step 5 — Generate images

Check which image generation tool is available, then follow the matching path.

**Path A — fal.ai MCP is connected:**
Call fal.ai for each prompt using the `fal-ai/flux-pro` model (fall back to `fal-ai/flux-dev` if pro is unavailable).
Pass each prompt as the `prompt` parameter.
Set `image_size` to match the first aspect ratio specified in the brief (use "square_hd" for 1:1, "portrait_4_3" for 4:5, "portrait_16_9" for 9:16).
Run all prompts. Present each image inline as it completes, labeled with its shot number.

**Path B — Google Gemini API is connected (no fal.ai MCP):**
Use the Gemini image generation API (Imagen model) to run each prompt.
Present each image inline as it completes, labeled with its shot number.

**Path C — Neither fal.ai nor Gemini is connected:**
Output all prompts as a clean numbered list. Do not add any other text between the prompts.
After the list, add exactly this note on its own line:

Copy these into NanoBanana, Midjourney, or any image generator. Each prompt is formatted for photorealistic output.

Connect your image generator (pick one)

Option A — fal.ai

Go to fal.ai and create an account. Find your API key in the dashboard under API Keys. In Claude Code, open your project settings and add fal.ai as an MCP server — paste your API key where it asks for credentials. Once connected, Claude generates images directly inside your session at Step 5. No copy-pasting, no tab switching.

Option B — Google Gemini

Go to Google AI Studio at aistudio.google.com and get your API key. In your Claude Code project settings, add it as an environment variable called GEMINI_API_KEY. Claude will use Gemini’s image generation at Step 5, same inline experience.

Option C — Neither

Skip this section entirely. At Step 5, the skill outputs all prompts as a clean numbered list. Paste them into NanoBanana or any image generator. Everything still works — just one extra manual step.

How to use it

1. Open Claude Code

2. Set your project folder — the one containing CLAUDE.md — as the working directory

3. Type /brand-shoot and hit enter

4. Claude reads your brand rules and confirms them — check they look right, type yes to continue

5. Answer the brief questions: campaign name, mood, setting, how many shots, what formats

6. Claude outputs the shot list — approve it or ask for changes

7. Claude writes the image prompts — they run automatically into your image generator, or output as a list if nothing is connected

The whole run takes under 10 minutes. The brand rules stay consistent every time because Claude reads the same file. Swap the CLAUDE.md for a different brand and the skill works for that brand instead.

If you want this built out for your brand — custom workflow, your tools, done for you — fill out this form and I’ll be in touch: https://app.youform.com/forms/avjlmcgd

There’s a difference. A character is an asset you own and reuse. A generated image is a one-off you can never reproduce exactly. That’s why your brand looks like five different people made it.

Here’s what I do instead.

First, build her in Higgsfield.

This is where everything starts. You’re not prompting for a vibe — you’re defining a person. Face structure, skin tone, energy, age, the way she carries herself. Get specific. The more locked-in she is at this stage, the more consistent she’ll be across every single render after this.

Don’t rush it. A character that drifts here drifts everywhere.

Then run her through the DNA Framework.

Nanobanana pro holds the face. Enhancor makes it believable.

This is the step most people skip — and it’s why their character looks slightly different every time. Nanobanana pro keeps the facial geometry locked. Enhancor adds the human layer: skin texture, lighting response, the micro-details that make your eye stop questioning whether it’s real.

Both tools stay in sync. The identity travels with the character, not just the image. That’s the whole point.

Now move her into a new environment.

Same character. Different setting, different lighting, different scenario.

She’s holding your product. She’s in a cafe. She’s looking straight at the camera in a studio. The face doesn’t change — only the context does.

This is what actually makes AI UGC scalable. You’re not rebuilding her for every brief. You’re placing her into whatever scene the ad needs.

The workflow runs in Weavy. Open it directly here — if you’re not set up yet it’ll walk you through it.

Build her once. Use her forever.

Every video from here is an iteration, not a rebuild. She becomes a creative asset your audience starts to recognise. That’s what separates a system from a content grind.

Here’s the full workflow — free.

Everything above, step by step. Higgsfield setup, Character sheet, DNA Framework, environment scripting.

→ Open the Character Lock Workflow in Weavy

If you want to take this further —

The Character Lock System is one workflow. If you’re running paid ads and need 50 variations a week, this is what it connects to.

UGC creators charge $500–$2K per video. You need volume. The math doesn’t work.

The Paid Ads Creative System is 6 workflows built in Weavy that handle the whole pipeline — scripts, characters, variations, batch output, product videos, scene-by-scene builds. One pack, runs everything.

What’s inside:

• Character Identity System — reference photo in, reusable character + blueprint document out

• AI UGC Generator — your character + your script = a talking head video

• Ad Script Generator — product description in, 3 complete UGC scripts out

• Batch Ad Variation Engine — one input, full testing library out

• Product-to-UGC Transformer — product photo in, lifestyle video out, no character needed

• Scene-by-Scene Builder — one script in, full set of clips ready to stitch

One UGC creator video: $500–$2,000. This pack: $97 once.

→ Get the Paid Ads Creative System — $97

They describe what they want to see. The model gives them something that looks fine. Generic. Nothing you’d actually use. They regenerate. Still generic. They blame the tool.

The tool isn’t the problem.

Seedance 2.0 is a visual pattern matcher trained on cinematic video data. When you give it a description, it finds the closest pattern it’s ever seen. Give it something vague — “a woman walking through a city at night” — and it returns the most average version of that it has.

The fix isn’t more detail. It’s structure.

CAMERA → SUBJECT → ACTION → ENVIRONMENT → LIGHTING → STYLE

Six parts. That order. Nothing extra.

Camera — shot type plus one movement. One only. Never stack two.
Slow dolly in. Tracking shot. Orbit. Crane up. Static tripod.

Subject — specific and visual.
Wrong: “a woman”
Right: “a woman in a black leather jacket with silver rings”

Action — one verb. What physically happens.
Wrong: “dynamic movement”
Right: “turns slowly toward camera”

Environment — where it is, plus atmosphere the model can render. Rain, fog, dust, smoke, sparks. Give it particles to work with.

Lighting — the single biggest quality lever. Always name it.
Golden hour. Rim light. Volumetric. Low-key side lighting. Neon. Practical lights only.

Style — 2–3 keywords at the end. Global modifiers.
Film grain. Shallow depth of field. Anamorphic lens flare. Warm tones.

Word count matters. 50–70 words for a single shot. 100–150 words if you’re using timeline structure. Past 150 and the model starts averaging — it stops following your prompt and falls back on what it’s seen most.

Here’s an example at 52 words:

Slow dolly in, 85mm lens, shallow depth of field. A faceted perfume bottle sits on a black mirror surface under a single overhead spotlight. Warm gold light refracts through the crystal. Dust motes drift through the beam. Cinematic, rich blacks, bokeh background.

That’s a cinematic output. “A perfume bottle with dramatic lighting” is not.

For 10-second videos, you can break the prompt into timestamped segments. The model follows them.

[Global setup — shot, subject, environment, lighting, style]

[0:00–0:03] Shot type. Action. One detail.
[0:03–0:07] Shot type. Development. One detail.
[0:07–0:10] Shot type. Resolution. Mood word.

3–4 segments maximum. 1–2 sentences each. Global setup goes before the timeline, not inside it. This is the difference between a clip that drifts and one that tells a visual story in 10 seconds.

What breaks it:

• Two camera movements stacked in one prompt

• Camera brand names (ARRI, RED mean nothing to the model)

• Speed percentages (”30% speed” is not a parameter it reads)

• Post-production terms (rotoscope, composite, keyframe)

• Prompts over 150 words

Run the formula on your next generation. The gap from what you were getting before is usually immediate.

I built a Claude skill that writes these prompts for you.

You give it a brief — as sparse or detailed as you want — and it outputs a full structured Seedance prompt, formatted and ready to paste. It covers single shots, timeline sequences, B-roll runs, and product work. Every output includes three specific tweaks to try if the result doesn’t land.

Here’s how to install it.

Read more

One file. You fill it out once.

Every time you open Claude Code, it reads this file before doing anything. Your brand identity, your visual world, your output standards—locked in permanently.

You stop prompting from scratch every session. Claude already knows who you are.

What You Need

• Claude Code — get it at claude.ai/code

• A code editor — VS Code, Cursor, or Antigravity (any of these work)

• A fal.ai account and API key — get it at fal.ai/dashboard/keys

Setup

If you haven’t installed Claude Code yet, get it at claude.ai/code.

Once installed:

1. Create a project folder

2. Open Claude Code in that folder (claude in your terminal)

3. Create a file called CLAUDE.md in the root

4. Copy the template below into it

That’s it. Claude reads this file at the start of every session.

Fill Out the Template

Open the CLAUDE.md below. Work through every section. Delete the instruction prompts as you go.

The more specific you are, the better your output. A vague brief produces a generic image. A specific brief produces a campaign.

Don’t rush this. This file is your creative director. Treat it like one.

Generate

Once your file is filled out, type in Claude Code:

Generate 5 campaign images from my CLAUDE.md

Claude reads your brief, builds the prompt, calls fal.ai, and saves the images to your project folder.

That’s it.

The Rule

Every time you want a new shot—change one thing in your brief and run it again.

Same brand world, different scene. The identity stays locked. The output keeps improving.

Subscribe now

The Template (Copy This)

# CREATIVE DIRECTOR
# Fill every section. The more specific you are, the better your output.
# Delete the prompts once you've filled each section in.
---

## CAMPAIGN

**What is this campaign for:**
What product, drop, or project are you shooting? One sentence.

**Campaign objective:**
What should someone feel when they see these images? What do you want them to do?

**Campaign name or internal title:**
Give it a name. Helps Claude stay consistent across sessions.

---

## BRAND

**Brand name:**
Your brand name.

**What the brand stands for:**
What does your brand believe? What's the attitude? What does it feel like to wear or use it?

**Who it's for:**
Age range, lifestyle, what they care about, who else they follow.

**Brands that are doing it right:**
Name 2–3 brands whose visual world you respect. Claude uses these as reference points.

**What this brand is never:**
What look, feel, or energy is completely wrong for this brand? Be specific.

---

## PRODUCT

**Hero product:**
Exact product name, colourway, material, and any specific details — logo placement, texture, fit.

**How it appears in the imagery:**
Is it worn? Held? In the background? How prominent is it?

**What the product should feel like in the image:**
Effortless? Considered? Raw? Describe the feeling, not the product.

---

## VISUAL WORLD

**The world this campaign lives in:**
What city, environment, or setting? What does it feel like to be there? Is it busy or empty, raw or polished, day or night?

**Lighting:**
What kind of light? Golden hour, overcast, fluorescent, midday hard sun? Where is it coming from?

**Color palette:**
What colours dominate the frame? What colours are never in frame?

**Texture:**
What surfaces, materials, fabrics define the visual feel?

**What is never in frame:**
Be specific. Tourists? Artificial light? Modern signage? Clean studio backgrounds?

---

## TALENT

**Who is in this campaign:**
Age, energy, attitude. How do they move through the world?

**Physical direction:**
Specific physical details — complexion, hair, build. The more specific, the more consistent.

**Wardrobe:**
What are they wearing beyond the hero product? What never competes with it?

**How they interact with the camera:**
Direct? Candid? Mid-motion? Do they look at camera or away?

**What they are never doing:**
Posing? Smiling on cue? Touching their hair? List what breaks the character.

---

## SHOT DIRECTION

**Shot types needed:**
Write one shot per entry. For each shot describe:
- What is the character doing and where
- What is in the environment around them
- What camera angle and distance

Example format:
Shot 1 — [Name]
[Scene description — what's happening, where, what energy]
Camera: [distance, lens, framing]

Add as many shots as you need.

---

## MOOD REFERENCES

**The one image that defines this entire campaign:**
Describe it in one sentence — the image that, if you captured it, would make the whole campaign worth it.

**The feeling when you see the strongest image:**
One word or one sentence. What emotion or desire does it produce?

**Photographers or directors whose work resonates:**
Name them. Claude uses these as shorthand for lighting, composition, and energy.

---

## OUTPUT STANDARDS

**Aspect ratio:**
9:16 for Reels. 1:1 for feed. 4:5 for feed portrait.

**Number of images per brief:**
How many variations per shot? 1–4 recommended.

**Resolution:**
1K for testing. 2K for finals.

**Every image must be:**
List your non-negotiables — natural light, talent present, environment visible, product readable.

**Every image must never be:**
List your hard rules — no studio backgrounds, no artificial light, no text overlays.

Fill this out completely. The more specific you are, the better your output.

One file. Campaign-level results.

Built by Sean Claude

Ten Claude Code agents run in sequence—each one handles a single production role. You give it a brief. It outputs a complete content package: script, visuals, voiceover, caption.

Nothing manual between them.

Here’s how to build it yourself.

What This System Does

Most people use Claude Code to answer one question at a time. That’s not a system—that’s a chat window.

The difference is agents. Each agent is a skill file that tells Claude Code exactly what role it plays, what it reads, what it produces, and what the next agent needs from it. Chain ten of them together and you have a production pipeline that runs on one command.

The ten roles:

1. Brief Reader — reads your brand brief, extracts context for every agent downstream

2. Script Writer — turns the brief into a complete content script

3. Shot Director — converts the script into a shot-by-shot production list

4. Prompt Engineer — writes generation prompts for every shot

5. Character Generator — generates your hook character image

6. B-Roll Generator — generates supporting visuals

7. Video Agent — animates the character into a clip

8. Voice Agent — generates the voiceover

9. Caption Writer — writes the platform caption

10. Export Agent — packages everything into one delivery folder

One command runs all ten. You get back a folder with everything in it.

Setup

1. Create an Anthropic Account

Go to claude.ai and sign up.

2. Install Claude Code

Mac or Linux — open your terminal and run:

bash

curl -fsSL https://claude.ai/install.sh | bash

Windows — open PowerShell and run:

powershell

irm https://claude.ai/install.ps1 | iex

How to open your terminal:

• Mac: Command + Space → type Terminal → hit Enter

• Windows: Windows key → type Command Prompt → hit Enter

Sign in with your Anthropic account when it opens.

3. Check for Node.js

In your terminal:

bash

node --version

If you see a version number, move on. If not, go to nodejs.org, download the LTS version, and install it.

4. Create Your Project Folder

Create a new folder on your desktop. Name it anything—”brand-content-system” works. Navigate to it in your terminal:

bash

cd ~/Desktop/brand-content-system

5. Open Claude Code in That Folder

bash

claude

Claude Code opens inside your project folder. This is where you’ll run everything.

6. Install Dependencies

bash

npm install dotenv fal-client

The Most Important File: Your CLAUDE.md

Before any agent runs, Claude Code reads a file called CLAUDE.md. This is your brand brief—the document every agent inherits context from. The quality of every output depends entirely on what’s in this file.

Create a file called CLAUDE.md in your project folder. Use this structure:

markdown

# CLAUDE.md — Brand Brief

## 1. WHO WE ARE
[Your brand name] does [what you do] for [who you serve]. Our content is about [your angle — systems, results, proof, etc.]. It is not about [what you're not].

## 2. VISUAL AESTHETIC
[Describe your visual world in 2-3 sentences. What does every frame feel like? What are the non-negotiables?]

Never:
- [Visual rule 1]
- [Visual rule 2]

## 3. TONE OF VOICE
[How does your brand speak? What's the energy?]

Always:
- [Tone rule 1]
- [Tone rule 2]

Never use: [list your banned words or phrases]

## 4. TARGET AUDIENCE
[One paragraph. Who are they, what do they care about, what do they ignore?]

## 5. PRODUCTS OR SERVICES
- [Product 1] — [one line]
- [Product 2] — [one line]

## 6. CONTENT GOALS
Every piece of content drives one action: [purchase / sign-up / DM / comment].
```

Fill this in completely before running the pipeline. Vague brief = generic output. Specific brief = content that sounds like your brand.

---

The Agent Folder Structure

Inside your project folder, create this structure:

.claude/ skills/ agents/ brief-reader.md script-writer.md shot-director.md prompt-engineer.md character-generator.md broll-generator.md video-agent.md voice-agent.md caption-writer.md export-agent.md

Each file is a skill—a set of instructions Claude Code follows when that agent runs.

Subscribe now

How to Write an Agent Skill File

Every agent file follows the same format. Copy this structure for each one:

markdown

---
name: [agent-name]
description: [one line — what this agent does and what it produces]
---

# [AGENT NAME IN CAPS]

Read [input file]. Do the following:

[Exact instructions for what this agent does — in plain language. Be specific. The more specific you are, the better the output.]

Write the result to [output file]. Confirm when done.

That’s it. Claude Code reads the file, follows the instructions, and produces the output.

The key is specificity. “Write a script” produces a generic script. “Write a 30-second reel script in [your brand voice] for [your audience] following this structure: [structure]” produces something you can actually use.

Customize each agent to your brand. The brief-reader should know what to extract from your CLAUDE.md. The script-writer should know your format. The caption-writer should know your platform and your voice.

These are not generic tools—they are customized to you.

Where to get them:

• fal.ai key: fal.ai → Settings → API Keys

• ElevenLabs key: elevenlabs.io → Profile → API Key

• ElevenLabs Voice ID: elevenlabs.io → Voices → click your voice → copy ID

Never share this file. Never upload it to GitHub.

The Run Command

Once your CLAUDE.md is written and your agent files are in place, open Claude Code in your project folder and tell it:

“Build me a run-all orchestrator that chains these 10 agents in sequence and runs them one by one from a single command.”

Claude Code writes the file for you. You don’t write any code. Once it confirms it’s done, run it:

node run-all.js

Brief in. Ten agents run. Full content package out in delivery/.

Tools Required

• Claude Code — claude.ai/claude-code

• fal.ai — image and video generation

• ElevenLabs — voiceover generation

• Anthropic API key — console.anthropic.com

The system is yours to build. Every agent is customizable. The CLAUDE.md is your brief. The output is your brand.

[Download the workflow]

Read more

I’ve been playing around with product content workflows, and what you can do with a single photo is kind of insane.

I can take one model photo, drop it into this system, and generate six completely different 3D product videos. No shoots. No crew. No studio time.

Just the photo and the workflow.

Let me show you how it works.

The System

This entire workflow runs inside Weavy. You provide the model photo and add your products. The system handles everything else.

Step 1: Character Consistency

First, the photo runs through a character consistency node.

This locks the model’s identity across every shot. Same face, same proportions, same styling.

Without this, the model drifts between generations. With it, you get perfect consistency across all six videos.

Step 2: System Prompt for Camera Movements

Here’s the part that makes this actually usable: I built a system prompt that analyzes your image and creates camera movements automatically.

You’re not manually writing “slow pan left” or “zoom in on product” six different times.

The system looks at your image, understands the composition, and generates varied camera movements that work for the shot.

Dynamic angles. Smooth motion. Professional framing.

All automated.

Step 3: Array + Kling Simultaneous Generation

The system prompt output feeds into an array that runs with Kling simultaneously.

This means all six videos generate at once. Not one at a time. You’re not waiting around running prompts manually.

One click. Six outputs.

Step 4: Topaz Upscale

Everything runs through Topaz for the final polish.

Upscales to professional quality. Sharpens details. Removes artifacts.

The difference between “this looks pretty good” and “this is ready to deliver to a client.”

Why This Actually Works

Here’s the thing: most people are still doing this the hard way.

They’re shooting one angle. Running one prompt. Generating one video. Then doing it all over again for the next angle.

And the model never looks the same between shots.

This workflow solves all of that:

• Character stays identical across every video

• Camera movements get created automatically

• All six videos generate at the same time

• Everything gets polished to professional quality in one pass

You build it once. Then you just run it. One click, six outputs.

What You Can Build

• Full product campaigns from a single model photo

• E-commerce video content at scale

• Brand lookbooks with consistent talent

• Social content that looks like professional shoots

Six cinematic 3D product videos from one photo.

Fast. Consistent. Professional.

Get the Complete Workflow

All nodes pre-wired (Character Consistency → System Prompt → Array → Kling → Topaz). Ready to duplicate.

[Download the workflow for free here]

You see it instantly, the plastic skin, the lifeless motion, that flat stock photo aesthetic.

The problem isn’t the tools. It’s that most people generate once in Midjourney and call it done. They skip the steps that actually create depth and professional quality.

This is the system that fixes it.

The 4-Step System

Step 1: Generate Your Base Shot (Midjourney)

Start in Midjourney. Get your hero frame—the composition, lighting, and subject you want.

Focus on:

• Strong composition (depth, leading lines, rule of thirds)

• Cinematic lighting (dramatic, directional, moody)

• Clear subject (athlete, product, character, whatever you’re shooting)

• Environmental context (mountain, city, studio)

This is your foundation. But it’s flat. You haven’t built depth yet.

Step 2: Create Angles (NanoBanana Pro)

Drop your Midjourney shot into NanoBanana Pro and generate different camera angles.

Same shot. Same lighting. Same aesthetic. Multiple perspectives.

Wide. Medium. Close-up.

This is what separates amateur content from professional. Single-angle work looks flat. Multi-angle work has depth and pacing.

Step 3: Add Motion (Kling)

Feed your shots into Kling for animation.

Here’s the thing: Kling needs specific motion prompts. Not “skier moves down mountain.”

More like: “Smooth tracking shot following skier carving left, snow spraying from edges, subtle camera shake, dynamic forward movement, backlight creating rim lighting.”

You need:

• Camera movement (tracking, pan, zoom, static)

• Subject action (carving, jumping, turning)

• Environmental details (snow spray, wind, fabric movement)

• Lighting interaction (backlight, shadows, rim light)

• Timing (smooth and fluid vs. fast and punchy)

The more specific you are, the better the output.

This is where most people waste credits. Generic prompts = garbage results.

Step 4: Upscale (Topaz Video AI)

Run everything through Topaz to get it to broadcast quality.

Upscale to 1080p or 4K. Sharpen details. Remove compression artifacts.

This is the final polish that makes it look professional instead of just “pretty good.”

Why This Works

Most people:

• Generate in Midjourney and stop

• Skip angle variation

• Use lazy motion prompts

• Don’t enhance

This system:

• Builds a cinematic foundation

• Creates depth through angles

• Uses structured motion prompts

• Polishes to broadcast quality

Each step matters. Skip one and the quality breaks.

Subscribe now

What You Can Build

• Brand campaigns that look like high-budget productions

• Product demos with real production value

• Social content that actually stops the scroll

• Portfolio work that gets you clients

Fast. No crew. No location permits. Just the system.

The Part Nobody Talks About

Here’s what I wish someone told me when I started: Step 3 is where you’ll waste the most time and money.

Kling motion prompts are specific. Really specific. And ChatGPT doesn’t know how to write them properly.

I’ve burned thousands of credits figuring this out. You ask for a prompt, it gives you something generic, you generate, it looks wrong, you try again, burn more credits, still not right.

The problem isn’t Kling. It’s that most AI assistants don’t understand Kling’s syntax or motion structure.

After wasting enough credits, I just built my own GPT trained specifically on what works for Kling 2.6.

Now instead of guessing, I get proper motion prompts instantly:

• Camera movements structured how Kling needs them

• Subject actions with realistic timing

• Environmental details that add depth

• Proper pacing and rhythm

It cut my wasted generations down by like 80%. Way more first-try hits.

If you’re serious about this workflow, that’s the piece that’ll save you the most money and time.

[Get the Kling GPT Bot]

Want the Complete Weavy Workflow?

All nodes pre-wired (Midjourney → NanoBanana → Kling → Topaz). Ready to duplicate.

[Download the workflow here]

This is the execution layer.

Read more

If you want the full breakdown of why each step exists and how the DNA Framework maintains consistency across any scene, I recommend reading this first:

Read more

If you want the full breakdown of why each step exists and how the system works end-to-end, I recommend reading this first:

This post contains the exact Weavy workflow I use to create photorealistic AI characters — fully built, wired, and ready to duplicate.

If you’ve read the free post, you already understand the logic, order…

Read more

If you’ve read The Simple Skin Realism Workflow, this is the same system — already built.

Read more

Read more

Important:
This post includes a plug-and-play Weavy workflow.
Read the guide first. The workflow is designed to work with this system — not instead of it.

Most people think Wes Anderson–style AI images come from a clever prompt.

They don’t.

They come from world-building — defining visual rules, then refusing to break them.

This post walks through the exact workflow I use to build cohesive, cinematic AI images that feel like they belong to the same film — not a random set of outputs.

This isn’t about copying Wes Anderson.
It’s about learning how to lock a world and stay inside it.

The Core Idea (Read This First)

AI visuals fall apart when the model has too much freedom.

Cinema works when:

• the world is defined first

• characters come second

• realism is added last

This workflow enforces that order.

If you skip steps, the world drifts.
If the world drifts, nothing feels cinematic.

What You’re Building

By the end of this system, you’ll have:

• a stable cinematic world

• multiple images that feel like adjacent film frames

• realism without “AI plastic”

• a repeatable workflow you can reuse for any style

This is not a one-off trick.
It’s a system.

Before You Start: References Are Non-Negotiable

You should always begin with 2–3 reference images minimum.

More references = more stability.
Weak references = unstable worlds.

This is not optional.

Read more