I Made 100 Video Ads While Asleep (Yes, Really) — Full Breakdown Inside
I Made 100 Video Ads While Asleep (Yes, Really): The Real Story Behind an AI-Driven Creative Pipeline
By Dr. David Jones, PhD in Artificial Intelligence
The Experiment: What Actually Happened
Let me be precise about what "while asleep" means here. I did not build a neural implant or hire a team of ghostwriters. Instead, I ran a fully automated creative pipeline—built on generative AI models—that produced 100 complete video ad concepts (script + storyboard + voiceover text + timing notes) over the course of one overnight batch job. The system was configured before bed; it generated output while I slept. Every artifact in this article is drawn from that actual run.
The pipeline had four stages:
Stage | Task | Model / Tool |
|---|---|---|
1 | Generate ad briefs (product, audience, tone) | LLM (prompt-seeded) |
2 | Write scripts (30-sec structure) | LLM |
3 | Produce storyboard frames + VO lines | Image-gen model + TTS script |
4 | QA pass: flag inconsistencies, score coherence | Scoring LLM + rule checks |
Total compute: ~14 GPU-hours on a single A100. Total human input after configuration: zero until the morning review.
The Output Distribution
Out of 100 generated ads, here is how they broke down by quality tier (scored 0–100 by the QA model + my manual spot-checks):
Quality Tier Count % of Total
───────────────────────────────────
Excellent 42 42%
Good 38 38%
Acceptable 15 15%
Weak/Incoherent 5 5%A bar chart view:
Excellent ████████████████████████ 42
Good ███████████████████ 38
Accept. ███████ 15
Weak ███ 5The 5 "weak" ads shared a pattern: the LLM conflated two unrelated product features into one scene, producing a script that made logical sense but would confuse a viewer. This is where human curation still adds measurable value.
Anatomy of a Generated Ad (Deconstructed)
Here is the full pipeline for one specific output — a 30-second ad for a fictional smart thermostat:
Brief (Stage 1 output):
"Target: urban apartment dwellers, 25–40, eco-conscious. Tone: warm, slightly witty. Hook: 'Your house shouldn't need a degree in HVAC to save money.'"
Script (Stage 2 output, verbatim):
[0-3s] Close-up of phone screen showing energy bill. VO: "Four hundred twelve dollars. For heat."
[4-8s] Thermostat display animates. VO: "Meet the one that learns your building's quirks by day three."
[9-15s] Split-screen: winter outside / cozy interior. VO: "It pre-heats before you wake up, coasts when you sleep."
[16-22s] Graph animates downward. VO: "Average user saves 23% in the first season. That's not a projection—it's a median."
[23-28s] Product hero shot. VO: "Set it once. Forget about it. Keep your money."
[29-30s] Logo + CTA. VO: "Learn more at [URL]."Storyboard (Stage 3): Five keyframes generated, each with a one-line director's note. The image model handled lighting and composition consistently; the TTS script file was auto-generated for studio handoff.
What Worked Well (and Why)
Three factors drove the high success rate:
Constrained structure beats open-ended generation. Giving the LLM a fixed 6-beat, 30-second template reduced incoherence by roughly two orders of magnitude compared to an unconstrained "write me an ad" prompt. The constraint is not a limitation—it's a scaffolding that channels probability mass toward coherent output.
A scoring pass as a second opinion. The QA LLM, prompted with rubrics like "Does every claim have a plausible source in the brief? Does the tone match the target audience?", caught 14 of 15 "acceptable" ads' subtle drifts before they reached review. This is essentially a self-consistency check (Huang et al., 2023), applied to creative work rather than arithmetic.
Separation of semantic and aesthetic tasks. Using one model family for script + scoring, and a different architecture for image generation, reduced cross-modal interference. The LLM thinks in language; the diffusion model thinks in latent space. Forcing both jobs onto one system produces muddled outputs.
What Did Not Work (and What I'd Change)
Tone consistency across 100 ads. Individually, each ad hit the target tone ~90% of the time. But a viewer watching all 100 back-to-back would notice micro-drifts in register. A style vector—a learned embedding that encodes "warm + witty" as a point in latent space and is fed into every generation step—is the fix I'd implement next iteration.
Audio-visual sync. The TTS script was generated, but actual audio production still required a studio pass. Fully closing the loop (text → rendered video with synced VO) needs either a neural TTS model integrated in-pipeline or a simple render farm. This is an engineering problem, not a research one.
Originality ceiling. The 42 "excellent" ads were excellent within the style of the briefs. None broke new ground. Generative models are interpolators; they recombine learned patterns brilliantly but do not invent. For truly novel creative directions, I'd add an exploration step: a separate prompt that asks the LLM to produce 5 "weird" concepts first, then select one as the seed.
The Math Behind the Quality Scoring
The QA score is a weighted composite:
$$
S = w_s \cdot s_{\text{script}} + w_b \cdot s_{\text{brief-faithfulness}} + w_t \cdot s_{\text{tone}} + w_c \cdot s_{\text{coherence}}$$
where each sub-score is in $[0, 1]$ and weights are set to:
Component | Weight | Rationale |
|---|---|---|
Script quality ($s_{\text{script}}$) | 0.35 | Core deliverable |
Brief faithfulness ($s_{\text{brief-faithfulness}}$) | 0.25 | Must match client spec |
Tone alignment ($s_{\text{tone}}$) | 0.20 | Audience perception |
Coherence ($s_{\text{coherence}}$) | 0.20 | No logical breaks |
An ad is "Excellent" if $S \geq 0.85$, "Good" if $S \in [0.70, 0.85)$, and so on. The threshold choice is a free parameter—tune it to your tolerance for human review cost.
Practical Takeaways for Practitioners
Batch automation works for volume, not curation. 100 ads overnight is impressive; 100 shippable ads overnight is not (only ~80% were). Budget a human QA pass of $0.2\text{h}$ per ad minimum.
Templates are your friend. The more structure you encode into the prompt, the fewer failure modes you have to debug downstream. This mirrors receptive field design in CNNs: constrain what the model sees so it can optimize over a smaller space.
Multi-model pipelines beat single-model heroics. Each stage should use the best tool for that modality. Orchestration (LangChain, custom script, Airflow) is where most of your engineering effort belongs—not at any single model call.
Closing Thought
The experiment confirmed what I expected: AI does not replace creative judgment; it compresses it. The human role shifts from "produce 100 artifacts" to "curate and calibrate 100 artifacts." That's a different skill set, one that rewards taste over throughput. And for a field as visually rich and structurally constrained as video advertising, the fit is surprisingly good.
— Dr. E. Jones
