---
name: "skill-deck-narrative"
type: skill
description: Assembles a deck from an approved, format-agnostic narrative outline handed over by skill-message-outline, which carries the framework and the reason for it, the headings as claims, and each line's takeaway and named evidence. Three passes — Receive, Execute, Evaluate. It chooses no structure and refuses to start without an approved narrative, naming the field that is missing. Keeps the deck-side work — the slide split and slide-count scaling from convention-deck-narrative, archetype and weight tier tagging from convention-deck, the rhythm and the brevity and repetition passes, the gate on Aled approving the outline before any design starts, the Pixel build and the pptx hand-off, and the structural review of a built or supplied deck. Ownership stays with Pixel; read by Reach and Sonar with voice supplied per domain. Surfaced by APP-557 and APP-562; refocused by APP-2333.
license: CC BY-NC-SA 4.0
---

# deck-narrative

The argument before the artwork. Decks have been laid out slide by slide with no arc, because nothing in canon forced a story spine before layout — this skill is that force. It picks the structure the deck's purpose calls for, turns it into an action-title outline, and can read an existing deck back to tell you which structure it is following and where it breaks. The structures themselves live in `convention-deck-narrative`; this skill is the behaviour that selects, applies, and checks them.

## Trigger

Three ways in:

* **Before any deck outline is drafted** — for `skill-visual-production`, the pptx skill, or any deck at all. This is the standing case, and it is not optional: deck production takes an approved outline as input and refuses a cold "make a deck about X" (APP-558).
* **On a supplied or already-built deck** whose structure is in question — a client's deck, a draft that is not landing, a deck someone else made.
* **Called by `skill-deck-parity`**, which delegates the structure question here rather than re-deriving it.

## Behaviour

Three passes. Pass 1 and 2 run together when authoring; Pass 3 runs alone when reviewing.

### Input — required before Pass 1

**One input: an approved narrative outline**, handed over by `skill-message-outline`. The skill does not start without it, and it does not write one for itself. The outline carries the framework and the one-line reason it was chosen, the altitude, the headings written as claims, each line's takeaway and its named evidence, the decision line where one is needed, the most obvious objection placed beside the claim it threatens, and any bad news with its owner and plan.

Where the outline is missing, or a field in it is empty, **name the missing field and stop.** Do not infer the framework, do not assume the altitude, do not supply the evidence. This is deliberately the same refusal shape `skill-message-outline` uses on a missing brief: one shape across the chain means a gap is reported the same way wherever in the chain it is found, and a deck skill that papered over a gap the narrative skill would have named is how the chain leaks. The reason the gap is handed back named rather than filled in here is that a guessed audience produces a deck that is structurally sound and aimed at nobody, which is worse than an obviously unfinished one because it survives review.

**Audience, occasion and the takeaway are no longer gathered here.** They belong to the message brief upstream, and they reach this skill already settled, carried inside the approved outline — the altitude is the reader's, and the deck's length and occasion are what the outline's ratios are scaled against in Pass 1. Asking for them again at deck time is how the argument gets re-decided per format, which is the arrangement this refocus exists to end.

### Pass 1 — Receive (approved narrative to deck frame)

1. **Verify the outline's framework line is present and stated.** The approved outline carries, at its top, the framework and the one-line reason it was chosen. If that line is absent the outline is not approved output from `skill-message-outline`; name it as the missing field and stop.
2. **Confirm the outline is complete at line level** — every heading written as a claim, and every line carrying its takeaway and its named evidence. A heading that reads as a topic, or a line whose evidence is unnamed, is reported back to the narrative as the finding. It is not repaired here, and a deck is not built over it.
3. **Map the outline's steps onto deck sections** in the outline's order, and **set the slide count** from `convention-deck-narrative`'s slide-count baseline and its scaling rule — the 12-slide proportional anchor, scaled by holding the ratios and the section order, never by dropping a section.
4. **Carry the framework line verbatim onto the top of the deck outline.** Pass 3 and `skill-deck-parity` both read it, and copying it rather than restating it is what keeps **one** structure judgement across the chain. A restated line is a second judgement, and two judgements of the same structure is the condition this skill and `skill-deck-parity` already agree must not exist.

**This pass chooses nothing.** It receives a structure that has already been chosen and approved upstream, and frames it for a deck. Where the outline serves a purpose the deck cannot carry — a length its ratios will not scale to, a step with no slide form, an altitude the occasion will not hold — **that is reported back to the narrative**, never reselected here. A deck skill that reselects has re-decided the argument at format time, which is the exact failure the upstream split exists to prevent.

### Pass 2 — Execute (structure to action-title outline)

1. **Read the approved outline** — the framework it names, its steps in order, and each line's takeaway and named evidence — **and the deck-side slide split for the structure it names** in `convention-deck-narrative`: section order and job, slide split, opening and closing instruction, proof placement. The outline settles the argument and is not reopened here; the deck-side entry settles only how that argument lands as slides.
2. **Lay out the sections** in the entry's order at the entry's ratios, scaled to the deck's actual length. Never drop a section to fit; a dropped section is what every entry's *common failure* describes.
3. **Write every slide's title as an action title.** This is universal — it applies to all eleven structures, and it is the discipline the whole outline is judged on. An action title states the slide's claim ("Hiring is the risk to Q4"), never its topic ("Q4 Update"). The test is that **reading the titles top to bottom, and nothing else, must carry the whole argument.** If the titles read as a table of contents, the deck has a layout and no argument. **And every outline line carries its takeaway and its evidence, not only its title (APP-2254).** The action title states the claim; beside it the outline names the **key takeaway** — what the audience should leave that slide with — and the **supporting evidence** that earns it: the specific figure, quote, screenshot or source, named, never "data TBC". An outline of titles, archetypes and tiers alone cannot be checked against the built slides, which is how a deck comes back with the right spine and unsupported bodies; the takeaway and the named evidence are what make Pass 3's outline-to-build comparison a real check rather than a second reading of the titles. Where a line has no evidence, **that is the finding**: either the claim is cut, or the evidence is commissioned before the gate.
4. **Apply the opening and closing instructions literally.** They are where most structures are won or lost, and they are the most likely things to be quietly rationalised away — the agenda slide in particular grows back unless it is refused by name.
5. **Place the proof where the entry says.** Proof placement is a structural decision, not what is left over after the argument is laid out.
6. **Tag every outline line with an archetype and weight tier** from `convention-deck`. This is what sets rhythm at the narrative stage, where fixing it is free, rather than discovering at render time that ten slides all weigh the same (APP-556, APP-557).
7. **Check the tagged outline against `convention-deck`'s rhythm rules** before the gate — opens and closes on Tier 1, a breather every 4–6, no two consecutive slides on one archetype, no run of three at one tier. A rhythm failure at this stage is a re-tag; at render stage it is a rebuild.
8. **Source voice from the domain, not from here.** `convention-deck-narrative` sets the order; the domain's own convention sets the register — `convention-mrp-voice` for Mr P, the venture's brand voice elsewhere. Structure and voice compose without touching. This is the `workflow-content-engine` pattern: one structure skill, voice supplied per domain.
9. **Run a brevity and repetition pass over the whole outline before the gate (APP-2254).** Read the outline end to end as one argument and cut. No figure, claim or phrase is carried on more than one slide unless the repeat is a deliberate, stated recap. Body copy on each slide is **one line**, and a line that needs two is an idea that needs splitting or cutting (`convention-deck`, *One idea per slide*). Report what was cut and the slide count before and after. This is the pass that was missing when a 23-slide draft carried one spend figure on three slides and one timing figure on three more, and an ad-hoc expert review was what found it and cut the deck to 15 — a structural failure caught by someone outside the process is a gap in the process.
10. **Re-run step 7 after any change to the deck's length — never only before the first gate (APP-2254).** The rhythm rules are checked against a slide count, so a cut or an addition invalidates the check that already passed; and a cut is exactly when the breathers go, because a section break is the cheapest-looking slide to drop. After any re-length, re-check `convention-deck`'s rhythm rules, and in particular that a Tier 1 breather still falls every 4–6 slides and that **every section still has its own break**, then state the re-check with the new count. The 15-slide cut above kept one section-break slide for six sections and nothing flagged it.

### The gate — outline approved before any design

**No design work starts until Aled approves the outline. Two-stage, always: narrative first, render second.** The outline goes to him with the structure named, the reason for it, the action titles, and the archetype tags. Approval of that outline is what `skill-visual-production` takes as its input.

The gate is here rather than at render because an outline is cheap to argue with and a rendered deck is not — once slides exist, the conversation becomes about the slides, and a structural objection arrives too late to act on without discarding work. Rendering ahead of approval is the failure this skill exists to prevent, and it stays a failure however finished the thinking feels.

### Pass 3 — Evaluate (read-only)

A structural review of an existing deck. Same shape and same discipline as `skill-review-pr` and `skill-design-parity`: read-only, plain language, never a rewrite.

1. **Ask the structure question the right way round.** Where an approved narrative arrived with the deck, the question is **conformance, not detection**: read the framework line carried onto the deck outline in Pass 1 step 4, and check the built deck against the outline it was built from — the steps in the outline's order, each heading's claim still the slide's claim, nothing dropped, nothing reordered. The structure was settled upstream and is not re-derived here. Where **no** approved narrative arrived — a client's deck, a supplied draft, anything made before the narrative moved upstream — **detect the structure**, if any, from section order and the opening/closing pattern, using each entry's *detection signal* in `convention-deck-narrative`, and where the deck names its own structure, verify rather than accept it. Detection stays in this skill for that case and that case alone; and on a deck that should have had an approved narrative and has none, **that absence is itself the first finding**.
2. **Check the stated or inferred purpose against the structure actually used**, and flag any mismatch. Three-Act on a 12-slide business deck and ABT at deck level are the two named mismatches; both are reselections rather than fixes, and a reselection is `skill-message-outline`'s to make.
3. **Check the structure is carried to the end**, using that entry's *evaluation signals* and its *common failure* by name. A structure abandoned at slide 8 is the normal way this breaks — the opening is deliberate and the close is whatever was left.
4. **Check the built deck against the approved outline and against named criteria.** Where an approved outline exists: do the action titles still read as the argument, did each line's **takeaway** survive, is its **named evidence** actually on the slide, and did sections survive production intact? And on any deck, outline or not, name these four criteria and give the verdict on each rather than improvising the judgement — **repetition** (any figure, claim or phrase on more than one slide without a stated recap), **brevity** (any slide whose body copy runs past one line), **section rhythm** (a Tier 1 breather every 4–6 slides and a break for every section, per `convention-deck`), and **evidence** (any claim carrying none). These are **named criteria and not a score**: the verdict format below deliberately reuses the `skill-review-pr` / `skill-design-parity` shape rather than inventing one, and naming what was checked is what makes "is this succinct enough?" answerable without a rubric this skill would otherwise have to maintain.
5. **Write the verdict** in the format below.

## Verdict format

Reuses the `skill-review-pr` / `skill-design-parity` verdict shape rather than inventing one — same two modes, same plain-language bar, same review-only boundary. What it does **not** inherit is their PR-head-SHA dedup key: those passes are bound to a pull request and this one is not. Where Pass 3 runs inside a Linear deck ticket, dedup on the rendered deck's build identity as `skill-deck-parity` defines it; where it runs ad hoc on a supplied deck, there is nothing to dedup against.

* **Structurally sound** — a plain statement of the structure detected, that it fits the stated purpose, and that it is carried to the end. Name what was checked so the review is visibly real. Note anything the structure does not cover.
* **Breaks to fix** — the specific gaps, each with: the structure detected, where it breaks (the slide or section), how it departs from the entry, and the **specific fix**. Not a rewrite — this skill reports; the author fixes.

Every verdict states four things: **structure detected, fit to purpose, where it breaks, specific fix.** Plain language throughout — Aled acts on it without opening the deck.

## Reads

`convention-deck-narrative` (the structure definitions, the selection table, the detection and evaluation signals), `convention-deck` (the archetypes and weight tiers for tagging, and the rhythm rules), `convention-audit` (for A1 consulting decks — the Finding → Theme → Opportunity → Initiative ladder, carried by the What / So What / Now What structure), and the domain's voice convention.

## Ownership and who reads it

**Owned by Pixel** (`P1-XEL`), sitting upstream of `skill-visual-production` and feeding the pptx build (APP-562, which supersedes APP-557's open Reach-vs-Sonar question).

The reason it is one skill rather than one per role: the *behaviour* — pick a structure, apply it, check it — is identical whether the deck is a Reach campaign pitch or a Sonar consulting brief. What differs is the structure selected and the voice it is written in, and both are already parameterised — the structure by purpose via `convention-deck-narrative`, the voice by domain. **Reach** (`R3-ACH`) and **Sonar** (`SO-N4R`) read this skill rather than owning variants of it; Sonar's consulting decks additionally carry the audit ladder through the What / So What / Now What entry. This is the `workflow-content-engine` pattern, and splitting the skill by role would duplicate the loop to vary two inputs that are already inputs.

## Relationship to skill-deck-parity

They share a boundary and must not both hold it. **This skill's Pass 3 owns the structure question** — which structure, does it fit the purpose, is it carried through — and runs on any deck, including ones we did not make. **`skill-deck-parity` owns the design question** — archetype variety, weight rhythm, hierarchy, brand — and runs as Prism's gate on a deck we produced. Where deck-parity needs the structure verdict, it **calls this pass and reports the result**; it never re-derives it. One structure judgement, one source.

## Guardrails

- **Never render ahead of the gate.** No design work, no slides, no template fill until Aled approves the outline. Two-stage always.
- **Never start without an approved narrative.** Name the missing field and stop. Audience, occasion and the takeaway belong to the message brief upstream and arrive inside the outline; never gather them here, and never assume them.
- **Action titles are not optional.** Titles that read as topics are the defect, not a style preference.
- **Never drop a section to fit a length.** Scale by ratio; a dropped section is the structure's named failure.
- **Never select a narrative.** The narrative arrives approved from `skill-message-outline`; a deck with no approved narrative is refused, naming what is missing. A deck whose purpose fits no framework is a capture to the Pulse queue against `convention-comms-frameworks`, never an improvised structure here.
- **Pass 3 is read-only.** It detects, judges, and names the fix. It never rewrites the deck, and it never advances or ships anything.
- **Structure here, voice there.** Never restate a domain's voice rules in an outline.
- Propose-only to canon: friction with a structure's definition is a `FRICTION:` capture naming `convention-deck-narrative`, never an in-place edit.

## Setup

Invoked ad hoc by Pixel, Reach, or Sonar before any deck outline; called by `skill-visual-production` as its required input; called by `skill-deck-parity` for the structure verdict. No schedule — this fires on a deck, not on a clock.

Owned by **Pixel** (`P1-XEL`).

On finish, run skill-ops-retro capture on this run's friction: **search the Pulse queue first and add the evidence to a same-root note if one exists, otherwise file a new FRICTION note** for the drain pass to assess, in capture step 3's literal shape — team Apps, project os.Claude, `FRICTION:` title, labels `task` + `work:configuration` + `PUL-5E`, Backlog, unassigned — filing the friction, never the run report.
