AI system for automatic generation of advertising creatives: full cycle

Why mass generation of ad creatives breaks

Each new platform doesn't add workload, it multiplies it. The same idea must go out in a dozen formats: square for feed, vertical for stories, static banner, short video with a different editing pace.

Requirements for frame, length, and text differ by platform, so a finished layout is rarely transferred one-to-one.

Hence the main bottleneck in creative production is manual adaptation to channels. Each variant is assembled separately: layers are copied, text is re-placed, cropping is adjusted to the new format.

A single video in five cuts takes days, and a client revision restarts the cycle for all variants at once.

Then duplicate revisions accumulate: five copies of one layout live as five independent jobs. None is linked to the others, so corrected wording from the main version doesn't reach the other copies.

There is no single source of versions — by delivery time it's unclear which version went to the platform and which remained in progress.

This is followed by growth in task volume. Another platform is added — the whole set is reassembled, deadlines stretch, and quality drops on the latest variants. Routine assembly eats team time that should go to ideas and analyzing results.

This is not a question of discipline but a property of a process where template, text, and cuts are not linked to each other.

We break down how this is solved: what a single source of versions provides, automatic format assembly, and rules by which a revision propagates across all channels at once.

What automation gives: measurable effects of implementation

Five effects the client sees in the first month: a set of creatives instead of individual layouts, predictable proofreading, no defects in export, and volume that grows without new hires.

A set of several dozen adaptations for different platforms used to be assembled over weeks — with a queue for the designer and manual resizing.

The pipeline outputs the same volume per shift: the speed of producing a creative set grows by multiples, not by percentages, and preparing variants stops being a bottleneck on the eve of launch.

The share of manual edits falls from 70–80% to 10–15% — only semantic text edits and brand proofreading remain. Everything a human used to catch is now filtered by checks before export: headline truncation in a narrow format, logo loss, wrong palette, duplicate variants.

This class of errors disappears entirely, and every caught issue is recorded in the rules so the correction doesn't repeat in the next batch.

Platform requirements like Meta Ads for safe zones and proportions are baked into generation rules, so adaptation doesn't break composition and doesn't require re-approval.

Pipeline downtime is no longer expensive: a failure at one stage doesn't reset the batch, the queue is replayed from the last successful task, and recovery takes minutes instead of hours of manual reassembly.

Scaling goes without headcount growth — doubling volume is covered by capacity, not new hires: adding a format or platform is a rule change, not hiring.

Operating modes: templated, hybrid, fully automatic

Modes differ not in image quality but in how many decisions remain with a human and where the control point is.

Templated generation, hybrid mode, and automatic generation without review are not stages "from bad to good" but different answers to volume, brand policy requirements, and the availability of a metric by which the result is evaluated without a human.

In practice, modes coexist in one system: flagship campaigns go through review, mass formats — in a stream. Below is a comparison of when each mode fits and where it breaks.

The main limitation of automation is not the model but the lack of a closed loop: without an objective response metric, the system replicates successful and unsuccessful variants with the same confidence.

So the transition to automation is done after an array of verified "creative — result" pairs has been accumulated; otherwise the stop-loop triggers on complaints, not data.

How implementation proceeds: audit, scheme, setup, handover

Implementation is divided into stages so that each leaves a verifiable artifact: process map, scheme, configured rules, test run report.

The client sees at which step the project is and what exactly was accepted at the previous one — without "working blind" until final delivery. Below are seven stages of engineering work.

1. Process audit of production — we analyze how creatives are created now: where tasks come from, who approves, at which step time is lost, what requirements for formats and style. The output is a process map with bottlenecks and a list of operations the system takes over.
2. Pipeline scheme — we design the flow from request to finished set of layouts: variant generation, automatic checks, assembly, delivery to ad accounts. We separately record points where a human is mandatory.
3. Configuration of generation rules — we set style constraints, templates, requirements for text and visuals, rules for rejecting variants. Rules are kept separate from system logic, so they change without a rebuild.
4. Integrations — we connect data sources and placement platforms, configure roles and access rights so generation and publication don't require manual file transfer.
5. Test run — we launch on real tasks from previous periods and compare the result with what the team did manually: share of variants that passed checks on the first try, time per one set of creatives.
6. Team training — we show marketers and designers the working interface, go over typical failures and the procedure for them, and record the regulations in documentation.
7. Handover to operation — we transfer access, configurations, and instructions, and agree on the support mode. The system works on your side, without dependence on us in daily operations.

What we hand over to the client: configurations, creative templates

We hand over not a folder with files but a working kit by which your team itself reproduces generation and changes it for new campaigns. Everything is stored in a repository with versioning: you can see who and when changed a rule, and can revert to the previous revision.

• Library of prompts and style rules — generation templates with fixed wording, palette, and brand prohibitions; an edit in one place propagates to all future creatives.
• Integration schemes — how the system is connected to ad accounts, asset storage, and analytics, what happens when an external service is unavailable.
• Access policies — roles and visibility scopes, the procedure for granting and revoking rights, working rules for external contractors.
• Release regulations — the path from draft to publication: which checks are automatic, who approves, under what conditions a creative returns for revision.
• Team instructions — step-by-step scenarios for the marketer, designer, and on-duty engineer, including typical failures and the procedure.
• Catalog of automatic checks — compliance with platform requirements, text readability on the layout, match with style rules; it is separately marked what the system checks and what a human checks.
• Model passport and retraining procedure — on what data the system was assembled, how to replenish the corpus, and when an update requires re-acceptance.

The kit is designed for work without our participation: the engineer sets up the system according to the schemes, the marketer releases creatives according to the regulations, and any change goes through the same order of checks.

Case: ad production for a clinic network without headcount growth

The marketing team of a clinic network — four people for 14 branches. Every month they produced six ad sets: banners for promotions, service cards, layouts for social media. The set was assembled manually, and any edit meant reassembling the entire set.

Before: queue, manual assembly, approval loops

A set of 20 layouts took nine business days, five of which went to approval — files went by email, versions got mixed up, some edits were lost.

Six sets per month, and every fourth layout returned for revision: either the wrong padding from the logo or a missing mandatory disclaimer. The team didn't cover seasonal promotions — some branch requests never reached production.

What changed

We assembled creative generation into one system: brand book rules are described explicitly, texts and images are assembled from a brief, checks for padding, fonts, and mandatory disclaimers run automatically.

The visual base is prepared by Midjourney, while layout assembly, logo overlay, and export to required formats are done via templates — the designer only gets involved in non-standard tasks.

After: stream of sets and targeted edits

After implementation, production of a set decreased from nine business days to two, approval time — from five days to a few hours: an edit is made in one source and propagates to all layouts at once.

Volume grew from six sets per month to forty, returns for revision — two out of ten instead of four to five. Headcount didn't grow: the same four people manage all branches, and freed-up hours go to analyzing campaign results.

What to do if brand style is already fixed in guidelines?

You don't persuade a strict guideline otherwise — you bake it into the system in layers. Tone is set by fine-tuning on your own materials, mandatory elements are fixed by a composite template, and deviations are rejected by compliance control.

Text style rules in the prompt maintain mood but not composition and details over a long series — as the only layer, they don't work.

The workflow for an immutable guideline is: style rules are described formally — palette in numeric values, allowed typography, logo safe zones; then a sample of materials selected by the art director is assembled, and a weight adapter is trained on top of the base model (in LoRA terms — an add-on that retrains in hours instead of rebuilding the model entirely); on top, a composite layer is placed for the logo and mandatory badges.

Compliance control is moved to a separate acceptance stage: they check palette match by color distance, presence of the logo in the safe zone, and an "in style / out of style" classifier on a holdout sample.

The rejection threshold is tuned to single-digit percentages of false positives — the art director gets 5-10 variants per slot instead of a hundred.

Technical concerns: quality control and moderation

Automatic generation produces dozens of variants per task, and the main question is not how to get them but what happens to them next.

Below are answers to concerns most often raised at acceptance: how defects are filtered out, where automation ends and a human begins, what about rights to materials, and whether a successful creative can be reproduced.

Who checks the result before publication?

Automation filters out obvious defects, but the final say is with the editor: they review meaning, brand compliance, and legal compliance.

Only what passed both stages goes into work — we don't remove the human from the chain; they take on verification, not the routine of sorting through variants.

What about rights to images and creative elements?

The source of each element is recorded: the data on which the model was trained, licenses for auxiliary materials, and the client's own assets.

Provenance is stored in the creative card, so in a disputed situation it's clear where the element came from and on what basis it is used.

Can a successful result be reproduced?

Yes. We save the task text, parameters, and generation seed: the same set of input data gives the same result. Therefore, a successful series can be continued in another format, and creative versions are stored and compared with each other.

Let's discuss the task: we'll analyze the flow and come back with a plan

The easiest way to start is by analyzing the current process: who prepares source materials, where they are stored, who approves creatives, and how many iterations occur before publication.

This analysis shows which steps can be automated immediately and which require manual checks — architecture and the order of work depend on this.

What we need from you for assessment: access to examples of already used creatives and texts, a list of platforms and formats, brand requirements for visuals, the approval point, and the person responsible for acceptance.

If there are internal rules and style restrictions, they will be included in the pre-publication check set.

Then work proceeds in stages, each of which we agree before starting the next:

• Process analysis and task definition — we fix input data, volumes, bottlenecks, and acceptance criteria.
• Prototype on your materials — generation of a limited set of creatives to verify style match before the main work.
• Scheme design — stages of data preparation, generation, checking, and output, with points of manual intervention.
• Assembly and integration — connection to your data sources and publication channels, configuration of check rules.
• Testing — run on real scenarios, measurement of the share of creatives passing checks without edits.
• Handover and training — we show how to replenish the material set and change rules so the system doesn't degrade over time.
• Support — post-launch tuning based on actual results.

Each stage ends with a short report: what was done, what the measurement showed, what is required from you. Describe the task and volumes — we'll come back with an estimate, implementation plan, and work order.