Multi-Channel Asset Production

The master concept gets the senior people, the careful crit, and the client presentation. The forty adaptations that actually meet the audience get whoever is available, a compressed timeline, and a review pass that checks the loud things — the headline, the logo — and misses the quiet ones: a color pulled from memory instead of the token, a legal line dropped from the smallest banner, a tone that drifts as the copy gets cut to fit.

The result is familiar to every studio: the campaign that looked coherent in the deck arrives in market slightly different in every channel, and the brand team spends the following week filing correction requests against work that already shipped.

This workflow treats adaptation as a production system rather than a pile of tasks. Per-asset agents work from one channel spec matrix and one approved master concept, and a brand-compliance agent checks every asset against the brand guidelines file before any human sees it. Failures loop back with the violation named, so the human review board reviews creative quality instead of playing spot-the-wrong-blue across forty files.

Use it when one approved concept has to become many assets across channels with hard specs: launch campaigns, seasonal promos, localization waves, always-on refreshes. The workflow produces HTML and code-template assets plus copy variants — the formats where text, tokens, and layout are inspectable — which is most of web, email, in-app, and HTML5 display work, and a structured copy-and-spec package for the formats that still end in a design tool.

Skip it for one-off hero pieces where the craft is the point, and do not expect it to art-direct. The master concept, the photography, and the design system it draws from are inputs the workflow adapts, not things it invents.

• Launch campaigns with 20+ assets across web, email, paid social, and display.
• Localization waves where copy length and reading direction break layouts.
• Seasonal promos that touch the ecommerce site and the email program on the same day.
• Retainer clients whose brand team rejects assets for token and legal-line violations more than for creative reasons.

This runs as a Claude Code dynamic workflow. Including the word workflow in the prompt — or running /effort ultracode — makes Claude write a JavaScript orchestration script that runs in the background. The script reads the channel spec matrix, fans out one production agent per asset (each receiving only the master concept, the brand guidelines, and its own row of the matrix), then routes every produced asset through a brand-compliance agent before anything is queued for human review. Intermediate assets and check results stay in script variables and on disk, not in Claude's context, which is what lets a forty-asset matrix run without the orchestrator drowning in its own output.

The runtime allows up to 16 concurrent agents and 1,000 agents per run, so a large matrix runs in waves the script manages itself. Workflows are resumable: if the run stops after thirty assets, it picks up at thirty-one rather than regenerating the lot. Save the working script to .claude/workflows/ in the project (or ~/.claude/workflows/ for personal use) and the production run becomes a slash command; the production and compliance agents are markdown definitions in .claude/agents/.

The gate is the structural point. The brand-compliance agent is not a reviewer the team hopes to book time with; it is a stage every asset passes, applying the same written rules to the first asset and the fortieth, at the same level of attention.

The matrix is the contract between strategy, production, and the gate. One row per asset: channel, format, dimensions or breakpoints, copy length limits, mandatory elements, the legal line that must appear, and the output format expected — an HTML template, an email module, a copy-and-spec package for a static format.

Building the matrix is human work and it is where most of the half day's quality is decided. A vague row produces a vague asset and an argument later; a precise row produces an asset the gate can actually check.

{
  "campaign": "spring-launch",
  "masterConcept": "concept/master-concept.md",
  "brandGuidelines": "brand/brand-guidelines.md",
  "assets": [
    {
      "id": "web-hero",
      "channel": "web",
      "format": "homepage hero",
      "output": "html",
      "breakpoints": [390, 768, 1440],
      "copy": { "headlineMax": 60, "subheadMax": 140, "cta": "required" },
      "mandatories": ["product lockup", "legal-line-A"],
      "notes": "Uses existing hero component and design tokens; no new type sizes."
    },
    {
      "id": "email-module",
      "channel": "email",
      "format": "promo module",
      "output": "html-email",
      "width": 600,
      "copy": { "headlineMax": 45, "bodyMax": 220, "cta": "required" },
      "mandatories": ["legal-line-A", "unsubscribe block untouched"],
      "notes": "Dark-mode safe; system font stack fallback."
    },
    {
      "id": "paid-social-1080x1080",
      "channel": "paid-social",
      "format": "feed square",
      "output": "copy-and-spec",
      "dimensions": "1080x1080",
      "copy": { "onImageMax": 30, "primaryTextMax": 125, "headlineMax": 40 },
      "mandatories": ["product lockup"],
      "notes": "Three copy variants for testing; no claims beyond approved list."
    },
    {
      "id": "display-300x250",
      "channel": "display",
      "format": "MPU",
      "output": "html5",
      "dimensions": "300x250",
      "copy": { "headlineMax": 25, "cta": "required" },
      "mandatories": ["legal-line-B"],
      "notes": "Max 150KB initial load per ad-server policy."
    },
    {
      "id": "in-app-banner",
      "channel": "in-app",
      "format": "top banner",
      "output": "html",
      "dimensions": "100% x 96",
      "copy": { "headlineMax": 50, "cta": "required" },
      "mandatories": ["dismiss control"],
      "notes": "Must respect app safe areas and existing banner component."
    }
  ]
}

The brand-compliance agent is only as good as the rules it is given, and the rules have to be written as checks, not aspirations. Logo clear space in pixels relative to logo height, the exact color token names allowed for backgrounds and CTAs, the type scale steps that exist, the tone rules phrased as things to reject, and the legal lines verbatim with the formats each one applies to.

Writing this file is a one-time investment per brand, usually an afternoon with the brand guidelines PDF open. It pays back on every campaign, and it tends to surface ambiguities in the guidelines themselves that the brand team is glad to resolve once instead of asset by asset.

# Brand compliance rules — checked on every asset

## Logo and lockup
- Only the SVG lockups in /brand/logos/ may be used; no recreations or rasterized copies.
- Clear space: minimum 0.5x logo height on all sides. Reject if any element intrudes.
- Never place the logo over photography without the approved scrim treatment.

## Color
- Backgrounds and CTAs must use named tokens from brand/tokens.json (e.g. --brand-primary,
  --surface-warm). Reject any hard-coded hex value not present in the token file.
- Text over imagery must meet WCAG 2.2 AA contrast (4.5:1 body, 3:1 large text).

## Typography
- Only the type scale steps defined in brand/tokens.json. Reject ad-hoc font sizes.
- Headlines in the display family; body and legal lines in the text family.

## Tone
- Reject exclamation marks in headlines, all-caps body copy, and unapproved superlatives
  ("best", "#1", "guaranteed") unless quoted from the approved claims list.

## Legal lines
- legal-line-A (verbatim): "[exact approved sentence]" — required on web, email, display.
- legal-line-B (verbatim): "[exact approved sentence]" — required on display formats only.
- Reject any paraphrase, truncation, or font size below the minimum legible size for the format.

## Output of a check
For each rule: pass or fail, the evidence (file, line, or element), and — on failure —
one sentence naming exactly what to change. Never fix the asset yourself.

Two subagent definitions carry the run. The asset producer builds one asset from the master concept, the brand guidelines, and one matrix row, in the output format that row demands. The brand-compliance agent reads an asset and the rules file and returns a structured pass-or-fail report — and, deliberately, has no write access to the assets, so the gate can never quietly become an editor.

---
name: brand-compliance
description: Checks one produced asset against the brand-check rules file. Returns a structured pass/fail report with named violations. Read-only; never edits assets.
tools: Read, Glob, Grep
---

You check exactly one asset against brand/brand-check-rules.md.

Rules:
- Work only from the asset files, the rules file, brand/tokens.json, and the matrix row
  you are given. Do not assume intent that is not in the files.
- Check every rule section: logo, color, typography, tone, legal lines, and the matrix
  row's mandatories and copy length limits.
- Output JSON: { "assetId", "status": "pass" | "fail", "violations": [ { "rule",
  "evidence", "requiredChange" } ] }.
- A missing or altered legal line is always a failure, never a warning.
- Name the smallest change that would make the asset pass. Do not rewrite copy or code.
- If a rule cannot be checked from the files (e.g. rendered contrast on imagery you
  cannot see), report it as "needs-human-check" rather than guessing.

The sketch below shows the shape of the script Claude Code writes: read the matrix, run production in waves, gate every asset, loop failures back to the producer with the violations attached, and stop looping after two retries so a stubborn failure goes to a human instead of burning the run. The plan lives in the script's variables — the asset list, the pass/fail ledger, the retry counts — which is why none of it crowds the main conversation.

// Sketch of the orchestration script Claude Code generates for this workflow.
// agent(prompt, options) runs a subagent and resolves with its final answer.
import { readFile, writeFile } from "node:fs/promises"

const matrix = JSON.parse(await readFile("campaign/channel-spec-matrix.json", "utf8"))
const ledger = []

for (const asset of matrix.assets) {
  let attempt = 0
  let report = null

  while (attempt < 3) {
    const feedback = report ? "\n\nPrevious gate failures to fix:\n" + JSON.stringify(report.violations) : ""
    await agent(
      "Use the asset-producer agent rules. Build asset " + asset.id + " from " + matrix.masterConcept +
        " and " + matrix.brandGuidelines + " according to this matrix row:\n" + JSON.stringify(asset) +
        "\nWrite output to campaign/assets/" + asset.id + "/." + feedback,
      { model: "sonnet" }
    )

    const checkRaw = await agent(
      "Use the brand-compliance agent rules. Check campaign/assets/" + asset.id +
        " against brand/brand-check-rules.md and this matrix row:\n" + JSON.stringify(asset),
      { model: "sonnet" }
    )
    report = JSON.parse(checkRaw)
    if (report.status === "pass") break
    attempt += 1
  }

  ledger.push({ id: asset.id, status: report.status, attempts: attempt + 1, violations: report.violations })
}

await writeFile("campaign/review-board.md",
  "# Review board\n\n" + ledger.map((e) =>
    "- " + e.id + ": " + e.status + " (" + e.attempts + " attempt(s))" +
    (e.violations?.length ? " — outstanding: " + e.violations.map((v) => v.rule).join(", ") : "")
  ).join("\n")
)
// In the real script, production runs in concurrent waves (up to 16 agents at once)
// rather than strictly one asset at a time; the retry-and-gate logic is the same.

The prompt names the matrix, the concept, the rules, the agents, and the retry policy. After the first successful campaign, ask Claude to save the script to .claude/workflows/ so the next campaign starts from the matrix file rather than from this prompt.

Run an asset production workflow for the campaign defined in campaign/channel-spec-matrix.json.

Inputs:
- campaign/channel-spec-matrix.json (one row per asset: channel, format, output type, copy limits, mandatories)
- concept/master-concept.md (the approved concept: message, visual direction, approved claims)
- brand/brand-guidelines.md, brand/brand-check-rules.md, brand/tokens.json
- Agent definitions in .claude/agents/asset-producer.md and .claude/agents/brand-compliance.md

Orchestration:
1. For every row in the matrix, run an asset-producer agent (in concurrent waves) that builds
   the asset in the row's output format — HTML template, email module, HTML5 banner, or
   copy-and-spec package — into campaign/assets/<id>/.
2. Pass every asset through the brand-compliance agent. On failure, send the asset back to
   its producer with the violations attached. Maximum two retries per asset; after that,
   mark it for human attention with the outstanding violations listed.
3. Write campaign/review-board.md summarizing every asset's status, attempts, and any
   outstanding violations or needs-human-check items.
4. Return only the review-board summary to the conversation.

The compliance agent never edits assets. Do not relax copy limits or legal-line rules to make an asset pass.

What reaches the humans is a matrix where every cell has already passed the written rules, plus a short list of assets the gate could not settle. The review board's job is the part only humans can do: does the adaptation still carry the idea, is the crop of the photography right, does the smallest banner still feel like the campaign or just legally resemble it.

Keep the board's decisions in the same folder as the assets. Approved, approved-with-notes, or rejected-with-reason per asset is enough, and it becomes the audit trail the client's brand team almost never gets from a traditional production scramble.

An agency producing a fintech launch ran a 40-asset matrix across six channels: web hero and three landing modules, an email series, four paid social formats, five display sizes, in-app banners, and a partner co-marketing variant of most of the above. Production and gating ran in just under three hours; the review board took ninety minutes.

The gate failed 13 of the 40 assets on the first pass. Eleven were fixed on the automatic retry — the most common violations were a paraphrased regulatory disclosure on the small display sizes and CTA buttons using a hex value instead of the token. Two assets went to humans: the 300x250 banner could not fit the verbatim disclosure at a legible size, which became a genuine format decision escalated to the client's compliance team rather than something a designer quietly shrank to 6px.

The brand team's post-launch correction list, which had run to two pages on the client's previous launch, contained one item.

An in-house team localized a campaign into five markets, which multiplied the matrix to roughly 120 assets and introduced the classic failure: translated copy running 30 to 45 percent longer than the English master and breaking layouts that were approved at English lengths.

The matrix carried per-market copy limits, and the gate enforced them, which moved the argument to where it belonged — before production. German headlines failed length checks on 9 of 14 formats on the first pass; the producer agents resolved most by switching to the approved short-form message variant, and three formats were redesigned once with a smaller display step that the brand team approved as a documented exception and added to the rules file.

The exception is the durable lesson: the rules file got smarter because a failure was named and decided once, instead of five markets each improvising their own workaround.

A retailer's seasonal promo touched the ecommerce site — homepage hero, category banners, a promo strip on product pages — and the email program on the same morning. The matrix was small, sixteen assets, but the formats were live HTML against an existing component library and an email template with hard dark-mode constraints.

The gate caught the two failures that historically caused morning-of incidents: a promo strip that introduced a new font size instead of using the existing scale step, and an email module whose dark-mode background made the legal line effectively invisible — flagged as needs-human-check on contrast and confirmed by a human in two minutes. The team reported the calmest promo launch of the year, less because the assets were better than because nothing surprising reached the review board.

A weak run produces forty files that look plausible until the brand team opens them. A strong run produces assets built from tokens and components, a ledger that says exactly what was checked and what failed, and a review board that spent its time on the idea rather than on policing hex values.

The brand gate enforces written rules over inspectable files. It cannot judge whether a crop flatters the product, whether an adaptation still feels like the campaign, or whether the idea survives at 300 by 250 pixels — those calls belong to the review board, and the workflow exists to protect their time for exactly that. Rendered output also needs human or browser-based eyes: contrast over photography, dark-mode rendering, and anything the gate marks as needs-human-check.

Final claims and legal sign-off remain with the client and their counsel. The gate enforcing the verbatim line is an early-warning system, not approval. And the rules file is a human responsibility: the gate will enforce a wrong rule as diligently as a right one.

• It cannot art-direct or judge craft; it checks compliance with written rules.
• It cannot verify rendered visuals it cannot inspect; those route to humans or to a browser-based check.
• It does not replace client legal approval of claims.
• It cannot catch rules nobody wrote into brand-check-rules.md.

Save the script to .claude/workflows/, the agents to .claude/agents/, and keep the matrix and rules files with the brand. Each campaign then starts from a filled-in matrix, and each documented exception makes the next run slightly less eventful.

1. Confirm the approved master concept and the approved claims list; the workflow adapts, it does not invent.
2. Build the channel spec matrix: one row per asset with format, output type, copy limits, mandatories, and legal lines.
3. Write or update brand-check-rules.md as checkable rules tied to tokens, scale steps, and verbatim legal lines.
4. Run as a dynamic workflow: per-asset producer agents in concurrent waves, building HTML, email, HTML5, or copy-and-spec outputs.
5. Gate every asset through the brand-compliance agent; failures loop back with the violation named, two retries maximum.
6. Send the survivors and the unresolved cases to the human review board with the full ledger.
7. Record review-board decisions and escalate claims or format conflicts to the client rather than working around them.
8. Fold every approved exception back into the matrix and the rules file before the next campaign.