---
name: "skill-visual-production"
type: skill
description: 'Produce on-brand visual assets from a brief — social and ad creative, page and email graphics, product imagery layouts, decks and documents. Use this whenever Pixel needs to make the actual visual deliverables for any venture, working against the domain''s design system. Carries a deck production sequence: decks start from an approved narrative outline from skill-deck-narrative, never a cold brief; each slide is assigned an archetype and weight tier from convention-deck and checked for rhythm across the run before rendering; template-fill from the venture''s .potx is preferred over from-scratch generation; the build hands off to skill-deck-parity. Produces; does not implement in code (that is Forge). Reads the design system so output is on-system. Also carries a sequence for explanatory visuals and motion: diagrams, animated diagrams, illustrations and film, with film built as a scene manifest of per-scene clips so a change re-renders one scene, not the whole comp.'
license: CC BY-NC-SA 4.0
---

# skill-visual-production

Pixel's production skill. Makes the deliverable assets from a `skill-creative-brief`, in Figma, against the domain's design system. Two deliverable classes have their own sequence below, each superseding the generic loop for its own work: decks, and explanatory visuals and motion (diagrams, animated diagrams, illustrations, film).

## Behaviour

Trigger: an approved brief needs assets produced.

Loop:

1. Read the brief and the domain's design system (tokens, components, art direction).
2. Produce the assets in Figma using the system's parts — social and ad creative, email and page graphics, product layouts, decks, one-pagers — at the right formats and sizes (the Figma MCP and the `agent:claude` route handle Figma-dependent work).
3. Keep everything on-system; produce variants where testing or sizing requires.
4. Export and hand assets to Reach (for campaigns) or Forge (for the build); flag any reusable element back to `skill-brand-system`.

## Deck production

Decks were covered by the loop above only generically ("decks and documents"), with no deck-specific procedure — so production fell through to the pptx skill's generic defaults and produced flat hierarchy and uniform layouts. The pptx skill is a *format and mechanics* skill; left unconstrained it renders the template default (APP-558, APP-556). This sequence is the constraint, and it supersedes the generic loop for any deck.

Decks are also the exception to the in-Figma default above: they are built as `.pptx` or HTML, not as Figma frames. The design system still governs — via `convention-deck` and the venture's `.potx` — but the tool is not Figma.

1. **Take an approved narrative outline as input — never a cold brief.** The input is an outline from `skill-deck-narrative` that Aled has approved: structure named, action titles written, archetypes tagged. A request to "make a deck about X" is **not** an input to this skill — route it to `skill-deck-narrative` and wait for the gate. Two-stage always: narrative first, render second. Starting from a cold brief is the failure this sequence exists to prevent, and it stays a failure however clear the brief is.

2. **Resolve the archetypes and re-check rhythm across the run, before rendering.** The outline arrives tagged with an archetype and weight tier per line from `convention-deck`. Production's job is not to re-tag from scratch but to **resolve** each tag against the actual content now attached to it — a line tagged big-number that turns out to carry three figures is a comparison, and that changes the deck's rhythm. So re-run `convention-deck`'s rhythm rules across the resolved sequence: opens and closes on Tier 1, a Tier 1 breather every 4–6 slides, no two consecutive slides on one archetype, no run of three at one tier, no more than two consecutive Tier 3. Fix rhythm here, while it is still a re-tag; after rendering it is a rebuild. A resolution that changes the argument, rather than its packaging, goes back to `skill-deck-narrative` — it is not production's to decide.

3. **Prefer template-fill over from-scratch generation.** Where the venture has a `.potx` whose masters carry the archetypes, fill it. Template-fill beats generation because it makes the house system the path of least resistance rather than something production has to hold in mind slide by slide, and because the master carries a resolved type face that will not silently substitute on someone else's machine (`convention-deck`). **Where no `.potx` exists** — which is currently every venture — build against `convention-deck` directly and **raise a `human`/Pixel ticket to build the template** for that venture. Raise it once per venture, not once per deck; check for an open one first.

4. **Render.** Use the pptx skill for its mechanics — that is what it is good at, and its built-in QA (overflow, overlap, contrast) is worth having. Its design defaults are not; `convention-deck` overrides them. For a deliverable whose destination is web or PDF rather than a live presentation, **consider an HTML deck instead**: it gives finer design control than pptxgenjs, which matters most for the things `convention-deck` is strict about — the type scale, hairline structure, and negative space. Choose the format on the destination, not on habit.

5. **Hand off to `skill-deck-parity`.** The deck goes to Prism's deck-QA pass with the approved outline named on the ticket, which that pass needs to review against. The pptx skill's own QA is mechanical only and does not substitute for it — a generic deck passes mechanical QA clean, which is the whole reason the parity pass exists.

## Explanatory visuals and motion

The second deliverable class with its own sequence, on the same footing as deck production and superseding the generic loop for its own work: explanatory diagrams, animated diagrams, conceptual illustrations and film. It says *how* the work is made. It does not say which of the four a job needs, or what good looks like — `convention-visual-explanation` holds the format choice and the bar per format, and the venture's instance in `convention-brand` holds the look. Read both before step 1: this sequence will not tell you that a hero must be conceptual, or what a score must do. (APP-2597; run end to end in the Mr Pritchard session 2026-10-21/22.)

1. **Write the brief with its objectives first, and check the work against them at the end.** Objectives-first is the Owner's standing preference, and the closing check is part of the sequence rather than a courtesy: a piece that met every bar and missed the objective is a reject, and the brief is the only place that can be caught.

2. **Offer three concepts per piece, of different metaphor types, and let the Owner pick before anything is drawn.** Three treatments of one metaphor is one concept. The pick is a gate — drawing ahead of it is the failure this step exists to prevent, and it stays a failure however strong the first idea looks.

3. **Produce stills through the toolkit chain, and check at two sizes.** SVG scene, then tone render, then stipple. Check the result at full size *and* at a 400px thumbnail against the reference, because a stippled print that reads at full size can collapse to grey mush at feed size, and the thumbnail is where most of the audience meets it.

4. **Build film as a scene manifest, never as one comp.** Owner, 2026-10-22: *"going forward, maybe we should split things into chapters and scenes so that we can edit and create changes to these rather than use up time and tokens re-rendering the full comp each time."* So:

   - **Script in the narrative order, storyboard it, and gate it.** The Owner approves the storyboard before anything renders. (Reported from the session: storyboard v1 rejected, v2 approved.)
   - **Look-test before volume.** A 5-second test of the style, approved, before any scene is rendered at length.
   - **Write the manifest.** Chapters, and scenes within them. Each scene carries a **scene ID**, its in and out times, its camera, its on-screen text and its sound events. The manifest is the film's source of truth and the rendered clips are derivatives of it — which is the right way round, and the opposite of a comp, where the render is the only record of the decisions in it.
   - **Pin the hand-off frames between scenes.** Each scene's closing camera and composition is the next scene's opening one, fixed in the manifest. Pinned hand-offs are what make a scene independently re-renderable, and the same property is what lets scenes render in parallel. (Reported: a 60-second film built in three parallel sections, in about four hours.)
   - **Render one clip per scene.**
   - **Assemble.** Join the clips, check every join frame by frame, and mix **one continuous soundtrack** from the scenes' combined event timelines. The score is mixed across the whole film rather than per scene, because sound is the one thing the manifest must not fragment (`convention-visual-explanation`: one continuous score that follows the picture, and a register change mid-film is a named failure). Finish with a contact sheet.
   - **Take notes by scene ID.** A note names the scene it changes and costs that scene's re-render plus a re-assembly, not the comp. A note that cannot be attributed to a scene ID is a note on the manifest, which is a storyboard question and goes back to the gate rather than into a render.

5. **Free in-house first; metered tools only on a costed proposal the Owner has agreed.** FLORA image generation, ElevenLabs voice or music, and anything else that bills, are proposed with a cost and used only once he has agreed the spend. Zero spend is the default, not the fallback.

6. **State the known limits up front, every time.** Free text-to-speech voices were rejected by the Owner as "atrocious", so do not plan a film around one. Code-drawn human figures are weak — prefer an object metaphor or a silhouette cutout. Sound made in code is verified **by measurement only** until the Owner has listened to it, so a soundtrack is never reported as approved on the strength of its own analysis.

   **A session that cannot open its own outputs says so before it generates.** The sound limit above is the special case of a general one, and the Guardrails' rule it rests on — *never report a soundtrack as approved on measurement alone; only the Owner's ear approves sound* — generalises past sound to any output the session cannot itself open. Where the session's egress blocks the host the generated media is served from, the run's status and its metadata are readable and the image, the frame or the clip is not. So: say it up front, in the same message that proposes the run and before anything generates, that the output will not be viewable from here. Then hold every dependent step — a retouch, an upscale, a recut — for the Owner's eyes, and advance none of them on a `completed` run status: a run status is evidence that a job finished, never evidence of what it produced. Opening `media.flora.ai` and `app.flora.ai` under the session's Network access is the Owner's config change to make, not this skill's; while it stays closed, this step is the whole of what stops a run reporting on status alone, and the two are not substitutes. (`APP-2861`.)

7. **Deliver as files for review.** Outputs go to the Owner to review, and nothing publishes in his name.

   **An explanatory visual takes the same parity gate as a deck, and it takes it before the Owner sees it (`APP-3093`).** Step 5 routes a produced deck to Prism's parity pass and step 7 routes everything else straight to the Owner, so the one output class with a named bar in `convention-visual-explanation` — a diagram, an animated diagram, an illustration, a film cut — is also the one with no reader between the render and his review. The asymmetry earns a gate rather than a reminder because the defects are the kind a bar catches and taste does not: a format chosen below its own bar, a figure with no source, on-screen text past the kinds-of-text guide, an annotation that does not say what the shot shows, a motion or sound bar missed, a palette or sign-off off the venture's `convention-brand` instance. Each one is cheap to catch on a contact sheet and expensive to catch in review, because the Owner's catch costs a full re-render and a round of his attention. So an explanatory visual goes to the visual-explanation lens first, scene by scene against the scene manifest where it is a film so a failed scene re-renders alone, and reaches the Owner only on a clean pass or with the failed scenes named. **The lens artefact itself is named here and not authored**, and `agent-prism`'s composition line is left alone until it exists, because a pointer at an artefact that was never created can never become fresh and no age test retires it. (Worked case, **reported** by `operator-mrp` from the Mr P visual kit run, 2026-11-13: the Owner was the only quality check on the whole run and caught a figure head flipping at side-on angles, a four-decisions figure with no source, too much on-screen text, annotations that did not say what the shot showed, and a music change in register. Every one of the five is a bar this canon already states, and each catch cost a render and a round of his attention — the explanatory-visual path reached the Owner with no lens between.)

**Subject-preserving generation.** Where the job is to put a named subject — a person, a product, a logo — into generated or retouched media, the subject's own photograph is the input, and never a reference model's. Reference-first prompting returns the reference's face on the subject's body, which is the failure reported in `APP-2862`; the Owner is reported there to have said it recurs — *"you keep using the reference image"* — and that is a report, not a count taken here. So:

- **The subject's own photograph is input one.** A reference image is for light, framing, grade or pose only, and the prompt names it as that. Where the only image to hand is a reference, the step is blocked on the Owner for the subject's photograph rather than run with a stand-in.
- **Wire inputs as edges, not as saved parameters.** An image saved into a node's parameters is a value the node is holding; an edge is what the graph resolves when the run fires. A subject photograph that arrives as a saved parameter with no edge is silently absent from the generation, and the result is indistinguishable from a prompt-only run.
- **Show the edit target back and have it confirmed before any retouch.** Name the image to be edited — its node and its frame — and get the Owner's confirmation that it is the right one, before the edit runs. A retouch applied to the wrong node is not recoverable by a second retouch; it is a second wrong image.
- **Run dependent nodes in one call.** Where one node's input is another's output, fire the chain in a single run call and let the graph resolve the order. Fired separately, the downstream node runs against whatever its input held at that moment, which is usually nothing.

Subject-preserving work on a metered tool is still the costed proposal of step 5: the Owner agrees the spend before anything runs.

**Toolkit dependency, unresolved.** The step-3 chain and the step-4 renderer were built in-session in a temporary workspace, and APP-2597 names an OPS ticket filed alongside it to keep them in a repo. That ticket could not be resolved from the Pulse queue on 2026-10-23. So this sequence is written to stand without the toolkit: every step above is a procedure rather than a tool invocation, and a run that finds no toolkit rebuilds the chain for the job and says so on the hand-off rather than waiting on a repo. Where the repo does land, point this section at it.

## Reads

The approved brief, the domain's design system, `convention-brand`, the Figma library. For decks: the approved outline from `skill-deck-narrative`, `convention-deck` (archetypes, grid, type scale, rhythm rules, anti-patterns, template pointers), and `convention-aesthetic`. For explanatory visuals and motion: `convention-visual-explanation` (which format for which job, and the bar per format), the venture's instance in `convention-brand` for the look, and `convention-aesthetic`.

## Guardrails

On-system always — reuse tokens and components rather than improvising one-offs. Produce assets, never write or merge repo code (hand to Forge). Keep source files tidy and reusable. Propose-only to canon.

For decks: **never start from a cold brief** — an approved `skill-deck-narrative` outline is the only input, and rendering ahead of the gate is never production's call. Never invent an archetype outside `convention-deck`'s ten; a slide that fits none goes back to the outline. Never change the argument while resolving tags — packaging is production's, the argument is not. Never let a type face substitute silently; record any substitution on the hand-off. Never ship or send a deck — it goes to `skill-deck-parity`, and Aled is the gate.

For explanatory visuals and motion: **never draw ahead of the concept pick, and never render ahead of the storyboard gate** — both are the Owner's, and a strong first concept is not a reason to skip either. Never spend on a metered tool without a costed proposal he has agreed. Never build a film as one comp where a scene manifest will do, and never take a note on a film that is not attributed to a scene ID. Never report a soundtrack as approved on measurement alone — only the Owner's ear approves sound. Nothing publishes in his name.
