Wiki:Packs/Presentation Production
From WFM Labs
| Pack | |
|---|---|
| ID | CP-CNT-001
|
| Domain | CNT — Content |
| Version | 2.1 |
| Blocks | 1 instruction + 3 reference |
| Source | Presentation Production for WFM Data Visualization for WFM Executive Communication for WFM |
| Published | 18 August 2026 |
| Revised | 20 August 2026 |
A pack is a deployable set for a Claude project: one instruction block pasted into the project's custom instructions, plus reference files uploaded as project knowledge. Packs contain no installable skill — see Wiki:Packs for why.
This pack supports building on-brand decks quickly against a corporate template, with the model doing the thinking and a person doing the assembly.
What changed at 2.0
Version 1.x produced a PowerPoint file programmatically. Version 2.0 does not. It produces a build sheet — a slide-by-slide specification a person transcribes into PowerPoint in about ninety seconds a slide.
The reason is that every observed failure was in the generation step: masters not inherited, content drawn as free shapes that could never be branded, placeholder mismatches, layouts selected by an index that had moved between template versions. Meanwhile, with a corporate master loaded, creating a slide is new slide → pick layout → paste, and the branding is inherited natively and correctly by construction.
The hard part was never the mechanics. It is what goes on slide four. That is where a model earns its place, and it does not require producing the file.
The programmatic path is retained for the cases that warrant it — forty or more slides, recurring decks with fixed structure, or data-driven slides where figures change — and is covered in Block 3.
When to use it
- A corporate template with named layouts is available.
- The output must be a presentation rather than a document or a web page.
- The material originates in analysis or in an existing body of thinking, rather than in a design
brief.
Do not use it for internal working documents or pre-reads nobody else will edit. A self-contained HTML file renders identically everywhere, needs no template, and cannot inherit incorrectly.
The three phases
| Phase | When | Produces |
|---|---|---|
| A — Inventory | Once per template | A categorised layout inventory, 1–3 KB, permanent |
| B — Concept | Once per source idea | Portable concept blocks that survive moving between environments |
| C — Build | Per deck | A build sheet, transcribed in roughly twenty minutes |
Phases A and B are done once and reused indefinitely. Phase C is the only recurring work, and it is mostly transcription.
How to deploy
- Create a project. Name it for the work — for example exec decks — not for the method.
- Copy Block 1 into the project's custom instructions.
- Save Blocks 2–4 as the filenames in their headings and upload them as project knowledge.
- Complete Phase A against the corporate template and upload the resulting layout inventory as a fourth knowledge file.
Block 1 — Project instructions
[CONTEXT]
This project turns analysis and existing thinking into decks built on a corporate template.
The output is a BUILD SHEET — a slide-by-slide specification a person transcribes into
PowerPoint — not a generated file. Creating a slide from a named layout takes seconds and
inherits branding correctly by construction; generating a file and repairing it does not.
LAYOUT-INVENTORY.md in project knowledge lists every layout the template offers and when to
reach for each. It is the authority on what exists. Never recommend a layout that is not in
it, and never ask for the template's source decks to be uploaded.
[ROUTING]
| Task | Open |
|---|---|
| No layout inventory exists yet, or the template changed | layout-inventory.md |
| Deciding what object belongs on a slide | build-sheet.md, Form |
| Writing the deck | build-sheet.md |
| Pulling an idea out of an existing deck, paper or notes | concept-extraction.md |
| 40+ slides, or a recurring deck where only figures change | build-sheet.md, Generating instead |
[DISCIPLINES]
- Settle the argument before the design. Write the slide titles in order and read them alone.
If they do not argue, restructure before writing any slide content.
- Titles state the finding, not the topic.
- Cite layouts by their exact name from the inventory. A near-miss costs assembly time.
- Fit the layout's capacity. If content does not fit, the form is wrong, not the layout.
- Flag content that has no suitable layout rather than inventing one. Reaching for a blank
layout is a signal the template is being fought.
- One argument per slide. If it needs two sentences to make sense, it is two slides.
- Every figure carries its denominator and its date.
- Note assets by description, not by catalogue reference.
[OUTPUT]
Deliver slide titles in order first, for agreement. Then the build sheet: one block per slide,
fields in placeholder order, layout named exactly.
Refuse to write a build sheet before the titles are agreed. If asked for a chart whose claim
would be clearer as a table or a single figure, say so before writing it.
Source: Wiki:Packs/Presentation Production (CP-CNT-001) v2.1
Block 2 — layout-inventory.md
# Phase A — the layout inventory
**One-time, per template. The output is 1–3 KB and never needs regenerating unless the template
changes.**
---
## Step 1 — extract the raw layouts
```bash
python3 extract-brandkit.py template.pptx --masters <name> > raw-layouts.md
```
**Masters usually carry no name in PPTX** — only layouts are named. The extractor therefore derives
a *signature* for each master from the modal prefix of its layout names (`MB-…`, `Neo1-…`), which is
what actually identifies a sub-brand. Run once with `--masters 0` and it prints a table of every
master with its signature, layout count and first three layout names. Pick from that, then re-run.
Corporate templates usually hold several masters — one per sub-brand or practice area — and a
master typically carries 40–50 layouts. Run once with `--masters 0` to print the master names, pick
the one this audience needs, then re-run filtered.
The raw output gives every layout name with its placeholder map. That is accurate and unusable: a
list of fifty names tells a model nothing about *when* to reach for each.
## Step 2 — categorise it, once
This is the step that makes the difference, and it is done once by hand or with a model reading the
raw output.
Most corporate templates decompose into four groups:
| Group | Typical count | Purpose |
|---|---|---|
| **Covers** | 5–8 | Title slides. Variants differ by image treatment and colour weight |
| **Dividers** | 6–10 | Section breaks. Variants differ by pattern, image, and light or dark |
| **Content** | 25–35 | The working layouts. This is the group that matters |
| **Navigation and utility** | 3–6 | Agenda, table of contents, blank, title-only |
**Covers and dividers need almost no description** — one line each, noting light or dark and whether
it takes an image. Nobody agonises over a section break.
**Content layouts need a "reach for this when" line**, and that is the whole value of the exercise.
## Step 3 — write the inventory
One line per layout. Keep it short; this file loads on every build.
```
## Content
MB-Text layout 1 single body plain prose, one idea
MB-Text layout 2-col two bodies comparison, two positions
MB-Text layout 2-col, subheads two bodies + heads comparison where each side needs a label
MB-3 Column with Lines three bodies + rules three parallel items, visually separated
MB-4 column with callout four + emphasis four items where one is the point
MB-Data points figures + labels several numbers that matter. NOT a chart
MB-charts chart + text an actual chart with commentary
MB-Large Quote quote + attribution one sentence carrying the slide
MB-Case study structured narrative a worked example
MB-Timeline / Timeline 2 sequence dated or ordered progression
MB-Illustration and bullets art + list a list that needs a visual anchor
MB-Side Photo and text image + body narrative with a supporting image
MB-Info graphics structured visual a relationship or process, not a list
MB-Portal and 3 points art + three items three items with brand furniture
MB-Multi photo and text several images where images are the content
MB-Multi Image Display image grid gallery
MB-Title + Subhead Only heading only a statement slide, deliberately sparse
MB-Blank nothing escape hatch. Using it is a signal you are
fighting the template
```
**Record the exact layout names.** They are what the build sheet cites, and a near-miss costs the
person assembling more time than getting it right did.
## Step 4 — add the form-to-layout map
The bridge between *what the slide should be* (`FORM.md`) and *what to click*. Ten to fifteen rows
covers most decks.
```
one number that matters -> MB-Data points, or MB-Title + Subhead Only if truly one figure
two things compared -> MB-Text layout 2-col, subheads
three or four parallel items -> MB-3 Column with Lines / MB-4 column with callout
a ranking or a spread -> MB-charts
a sequence -> MB-Timeline
a worked example -> MB-Case study
a statement that must land -> MB-Large Quote
a list needing a visual -> MB-Illustration and bullets
a relationship or process -> MB-Info graphics
a section break -> the divider set
```
Written once, this is what lets a build sheet say *use `MB-Data points`* instead of *put the numbers
on a slide*.
## What the finished inventory contains
- The master name, exactly as it appears
- Covers, dividers, content, utility — grouped
- One "reach for this when" line per content layout
- The form-to-layout map
- Nothing else. No theme colours, no slide inventory, no placeholder indices
**Target 1–3 KB.** If it is much larger, the categorisation has not been done — the raw extract is
being carried instead of an inventory.
---
## The extractor
```python
#!/usr/bin/env python3
"""
extract-brandkit.py — build a compact, reusable brand kit from any corporate
PowerPoint template or asset library.
Reads one or more .pptx/.potx files and emits a markdown BRAND-KIT that a model
can use to generate on-brand decks, without ever ingesting the source slides.
Usage:
python3 extract-brandkit.py template.pptx icons.pptx > BRAND-KIT.md
python3 extract-brandkit.py corp.pptx --masters corporate > BRAND-KIT.md
python3 extract-brandkit.py assets.pptx --inventory > BRAND-KIT.md
Flags:
--masters a,b keep only these masters. Index (0,3) or signature substring (MB,Neo1).
Masters usually carry NO name in PPTX — the signature is derived from
the common prefix of the layout names, which is what identifies a
sub-brand. Run with --masters 0 first to print the signature table.
--inventory include the per-slide inventory even for template files
--max-slides N cap the inventory (default 400)
By default the slide inventory is emitted only for files with NO usable layouts —
asset libraries, which you copy from. Template files are built into, so their slide
lists are omitted. Multi-brand corporate kits carry one master per sub-brand; use
--masters to keep the one you need.
Requires: python-pptx (pip install python-pptx)
Output is typically 2-6 KB per source file. That is the whole point.
"""
import sys, os, re, zipfile
from collections import Counter
from xml.etree import ElementTree as ET
try:
from pptx import Presentation
from pptx.util import Emu
except ImportError:
sys.exit("pip install python-pptx")
A = '{http://schemas.openxmlformats.org/drawingml/2006/main}'
MAX_SLIDES = 400
WANT_INVENTORY = '--inventory' in sys.argv
if WANT_INVENTORY:
sys.argv.remove('--inventory')
MASTERS = None
if '--masters' in sys.argv:
i = sys.argv.index('--masters')
MASTERS = [m.strip().lower() for m in sys.argv[i+1].split(',')]
del sys.argv[i:i+2]
if '--max-slides' in sys.argv:
i = sys.argv.index('--max-slides')
MAX_SLIDES = int(sys.argv[i+1]); del sys.argv[i:i+2]
def master_sig(m):
"""Masters usually carry no name in PPTX — only layouts are named. Fall back to the
common prefix of the layout names, which is what actually identifies a sub-brand."""
nm = (getattr(m, 'name', '') or '').strip()
if nm:
return nm
names = [(l.name or '').strip() for l in m.slide_layouts if (l.name or '').strip()]
if not names:
return ''
# Most layouts in a sub-brand master share a prefix ("MB-", "Neo1-"), but not always
# all of them — so take the MODAL prefix, not the universal common one.
toks = [n.split('-', 1)[0].strip() for n in names if '-' in n and len(n.split('-', 1)[0]) <= 12]
if toks:
top, n_top = Counter(toks).most_common(1)[0]
if n_top >= max(2, len(names) // 4):
return top
pre = os.path.commonprefix(names)
cut = max(pre.rfind(c) for c in '-_ ')
if cut > 0:
return pre[:cut]
return names[0][:28]
def want_master(idx, sig):
"""--masters accepts indices (0,2) or signature substrings (MB,Neo1,corporate)."""
if MASTERS is None:
return True
s = (sig or '').lower()
return any(m == str(idx) or (m and m in s) for m in MASTERS)
FILES = [f for f in sys.argv[1:] if f.lower().endswith(('.pptx', '.potx'))]
if not FILES:
sys.exit("give me one or more .pptx / .potx files")
def theme_of(path):
"""Pull the colour scheme and font scheme straight out of theme1.xml."""
out = {'colors': {}, 'fonts': {}}
try:
with zipfile.ZipFile(path) as z:
names = [n for n in z.namelist() if re.match(r'ppt/theme/theme\d+\.xml$', n)]
if not names:
return out
root = ET.fromstring(z.read(sorted(names)[0]))
cs = root.find(f'.//{A}clrScheme')
if cs is not None:
for child in cs:
tag = child.tag.split('}')[1]
srgb = child.find(f'{A}srgbClr')
sysc = child.find(f'{A}sysClr')
if srgb is not None:
out['colors'][tag] = '#' + srgb.get('val', '').upper()
elif sysc is not None:
out['colors'][tag] = '#' + (sysc.get('lastClr') or '').upper()
fs = root.find(f'.//{A}fontScheme')
if fs is not None:
for which in ('majorFont', 'minorFont'):
el = fs.find(f'{A}{which}')
if el is not None:
lt = el.find(f'{A}latin')
if lt is not None:
out['fonts'][which] = lt.get('typeface', '')
except Exception as e:
out['error'] = str(e)
return out
def kind(shape):
try:
return str(shape.shape_type).split('(')[0].strip().replace('MSO_SHAPE_TYPE.', '')
except Exception:
return '?'
def first_text(shape_iter, limit=70):
for sh in shape_iter:
try:
if sh.has_text_frame:
t = sh.text_frame.text.strip()
if t:
return ' '.join(t.split())[:limit]
except Exception:
continue
return ''
# Auto-generated shape names are noise. Real asset names survive this filter.
_G = (r'rectangle|oval|ellipse|text\s*box|textbox|text\s*placeholder|content\s*placeholder'
r'|picture\s*placeholder|placeholder|picture|image|group|content|title|subtitle'
r'|freeform|straight\s*connector|connector|line|arrow[:\s]*\w*|shape|graphic|chart|table'
r'|slide\s*number|footer|date|object|diagram|smartart|autoshape|right\s*brace'
r'|isosceles\s*triangle|rounded\s*rectangle|flowchart|block\s*arc|frame|star')
GENERIC = re.compile(rf'^(?:{_G})(?:[\s:_-]*\d+)?$', re.I)
def alt_and_names(slide, cap=14):
"""Shape names and alt text — this is where icon/asset names actually live."""
found = []
for sh in slide.shapes:
nm = (sh.name or '').strip()
alt = ''
try:
alt = (sh._element._nvXxPr.cNvPr.get('descr') or '').strip()
except Exception:
pass
label = alt or nm
if label and not GENERIC.match(label):
found.append(label[:34])
if len(found) >= cap:
break
return found
print("# Brand kit\n")
print("Generated by `extract-brandkit.py`. Compact by design — this replaces the source")
print("decks as context. Do not paste the source decks themselves.\n")
for path in FILES:
base = os.path.basename(path)
try:
prs = Presentation(path)
except Exception as e:
print(f"\n---\n\n## {base}\n\n**Could not open:** {e}\n")
continue
W = prs.slide_width or 0
H = prs.slide_height or 0
ratio = f"{round(W/H, 3)}" if H else "?"
aspect = "16:9" if abs(W/H - 16/9) < .02 else ("4:3" if abs(W/H - 4/3) < .02 else ratio)
print(f"\n---\n\n## {base}")
print(f"\n`{len(prs.slides)} slides · {len(prs.slide_masters)} master(s) · "
f"{Emu(W).inches:.2f}×{Emu(H).inches:.2f}in · {aspect}`\n")
th = theme_of(path)
if th['colors']:
print("**Theme colours**\n")
order = ['dk1','lt1','dk2','lt2','accent1','accent2','accent3',
'accent4','accent5','accent6','hlink','folHlink']
cells = [f"`{k}` {th['colors'][k]}" for k in order if k in th['colors']]
print(' · '.join(cells) + "\n")
if th['fonts']:
print(f"**Fonts** — headings `{th['fonts'].get('majorFont','?')}` · "
f"body `{th['fonts'].get('minorFont','?')}`\n")
# ---- masters and layouts: the structural payload ----
has_layouts = False
n_masters = len(prs.slide_masters)
shown = 0
for mi, m in enumerate(prs.slide_masters):
if not len(m.slide_layouts):
continue
has_layouts = True
sig = master_sig(m)
if not want_master(mi, sig):
continue
shown += 1
label = f"Master {mi}" + (f" — `{sig}`" if sig else " — *(unnamed)*")
print(f"\n### {label} — {len(m.slide_layouts)} layouts\n")
print("| # | Layout name | Placeholders (idx:type) | Static art |")
print("|---|---|---|---|")
for li, l in enumerate(m.slide_layouts):
phs = []
for ph in l.placeholders:
try:
t = str(ph.placeholder_format.type).split('(')[0].strip()
t = t.replace('PP_PLACEHOLDER.', '')
phs.append(f"{ph.placeholder_format.idx}:{t}")
except Exception:
pass
art = sum(1 for s in l.shapes if not s.is_placeholder)
print(f"| {li} | `{l.name}` | {', '.join(phs) if phs else '—'} | {art} |")
if has_layouts and MASTERS is not None and shown < n_masters:
rows = []
for i, m in enumerate(prs.slide_masters):
sg = master_sig(m)
first = ', '.join((l.name or '?')[:26] for l in list(m.slide_layouts)[:3])
rows.append(f"| {i} | `{sg or '(unnamed)'}` | {len(m.slide_layouts)} | {first} |")
print(f"\n*{n_masters - shown} of {n_masters} masters omitted by `--masters`.*\n")
print("| # | Signature | Layouts | First three layout names |")
print("|---|---|---|---|")
print("\n".join(rows) + "\n")
if not has_layouts:
print("\n**No usable layouts** — this is an asset library, not a template.\n")
# ---- slide inventory: the asset payload ----
# A template is built INTO; its slide inventory is bulk with little value.
# An asset library is copied FROM; there the inventory is the whole point.
if has_layouts and not WANT_INVENTORY:
print(f"\n*Slide inventory omitted — this file has usable layouts, so build into them "
f"rather than copying from its {len(prs.slides)} slides. Pass `--inventory` to "
f"include it.*\n")
continue
n = min(len(prs.slides), MAX_SLIDES)
if n:
print(f"\n### Slide inventory — {n} slides\n")
print("| # | Layout | Heading | Contents | Named assets |")
print("|---|---|---|---|---|")
for si, s in enumerate(list(prs.slides)[:n], 1):
counts = {}
for sh in s.shapes:
k = kind(sh)
counts[k] = counts.get(k, 0) + 1
for attr, tag in (('has_chart', 'CHART'), ('has_table', 'TABLE')):
if any(getattr(sh, attr, False) for sh in s.shapes):
counts[tag] = counts.get(tag, 0) + 1
summary = ' '.join(f"{k}×{v}" for k, v in sorted(counts.items(),
key=lambda x: -x[1])[:5])
names = alt_and_names(s)
lay = ''
try:
lay = s.slide_layout.name
except Exception:
pass
print(f"| {si} | `{lay[:22]}` | {first_text(s.shapes)} | {summary} "
f"| {', '.join(names[:8])} |")
if len(prs.slides) > n:
print(f"\n*(truncated at {n} of {len(prs.slides)} — raise `--max-slides`)*")
print("\n---\n")
print("## How to use this\n")
print("- **Template files** (those with layouts) supply the master. Open one as the base "
"and add slides to its layouts **by name**. Never create a new master.")
print("- **Asset libraries** (those without layouts) supply things to copy. Reference them "
"as `file · slide N` and copy the shape across.")
print("- Match content to form using `FORM.md`, then form to layout using the tables above.")
```
Block 3 — build-sheet.md
# Phase C — the build sheet
**Per deck. The model produces this; a person transcribes it.**
---
## What a build sheet is
A slide-by-slide specification ordered to match the click order in PowerPoint, so the person
assembling is typing rather than deciding.
```
SLIDE 5 · MB-Data points
TITLE Occupancy is computed three different ways
POINT 1 Avaya / CMS (ACD + ACW + Hold) / (Staff − Aux)
POINT 2 NICE / IEX (Talk + Work) / (Talk + Work + (Ready × Concurrency))
POINT 3 Genesys / ICBM (tAgentOnAcdCall + tAgentInAcw) / (… + tAgentAvailable)
FOOTNOTE Three formulas. One word. One operation.
ASSET none
```
**Every field maps to a placeholder.** The layout is named exactly. Nothing requires a decision at
assembly time.
---
## Producing one
**1 · Settle the argument first.** List the findings as single sentences, cut to those that change a
decision, rank by surprise, and write the slide titles in order. **Read the titles alone.** If they
do not argue, restructure before writing any slide content.
**2 · Assign a form to each** — from `FORM.md`. One word: number, comparison, sequence, ranking,
statement, structure, table.
**3 · Assign a layout to each** — from the form-to-layout map in the inventory. Cite the exact
layout name.
**4 · Write the content into fields**, in placeholder order.
**5 · Note assets by description, not by reference.** *"a network or nodes icon"* is more useful than
a catalogue lookup, because finding it takes seconds and indexing an icon library does not repay
the effort.
---
## Rules for the content itself
- **Titles state the finding, not the topic.** Read alone they should form the argument.
- **One argument per slide.** If it needs two sentences to make sense, it is two slides.
- **Every figure carries its denominator and its date.**
- **Fit the layout's capacity.** A three-column layout takes three items, not five with two
squeezed. If the content does not fit, the form is wrong, not the layout.
- **Flag rather than invent.** Where no layout suits, say so. Reaching for the blank layout is a
signal the template is being fought.
---
## Sizing
Eight to twelve slides plus appendix for a thirty-minute discussion. Six to eight for a pre-read
that must stand alone.
If it will not fit, several slides are usually making the same argument. Merge them and the deck is
often shorter than it looked.
---
## Assembly
New slide → pick the named layout → paste each field → next.
Roughly **ninety seconds a slide**, so a twelve-slide deck is about twenty minutes with the thinking
already done. Nothing to verify afterwards: the branding is inherited by construction because the
slide was created from the layout rather than repaired into it.
---
## Generating instead — the exception
**Use the build sheet by default. Generate a file only when one of these holds.**
- **Forty or more slides**, where transcription time genuinely exceeds the cost of debugging
generation.
- **A recurring deck with fixed structure** — a monthly or quarterly review where only the figures
change.
- **Data-driven slides** where numbers are produced by analysis and retyping them would introduce
errors.
For a deck built once, generation is slower end to end once its failure rate is counted.
---
## Rules, if generating
- **Open the template as the base file.** Never instantiate an empty presentation — that creates its
own minimal master and orphans the branding entirely.
- **Select layouts by name, not index.** Index order is not stable across template revisions.
- **Never create a master or layout.**
- **Put text into placeholders**, addressed by placeholder index. Free-drawn text boxes inherit no
branding, cannot be reflowed, and defeat later correction.
- **Do not set fonts or colours literally.** Inherit from the placeholder or the theme.
- Delete the template's leftover slides at the end.
## Verify
```python
from pptx import Presentation
p = Presentation('output.pptx')
print(f'masters={len(p.slide_masters)} slides={len(p.slides)}')
for i, s in enumerate(p.slides, 1):
ph = sum(1 for sh in s.shapes if sh.is_placeholder)
free = len(s.shapes) - ph
flag = ' <-- CHECK' if ph == 0 else ''
print(f'{i:3d} | {s.slide_layout.name:30s} | ph={ph} free={free}{flag}')
```
**Expect the template's original master count — not one more** — every slide on a named layout, and
`ph > 0` throughout. `ph=0` everywhere means the content is free shapes and can never be branded;
regenerate rather than repair.
## Recovery, if a file arrives unbranded
In order, inside PowerPoint, no regeneration:
1. **Design → Themes → Browse for Themes…** → the template. Imports the master.
2. Select all slides → **Home → Layout** → branded layout → **Home → Reset**.
3. **View → Slide Master** → delete the empty generated master; its slides reassign.
4. Last resort: open the template and paste all slides in with **Use Destination Theme**.
Block 4 — concept-extraction.md
# Phase B — concept to portable content
**One-time per source idea. The output is text that survives being moved between environments.**
---
## The problem this solves
Ideas worth presenting usually already exist somewhere — a conference deck, an article, a set of
notes, a paper. They are trapped in a format that does not travel: image-rendered slides, a PDF, a
file on the wrong machine.
**A concept only needs to move as text.** Extract it once, hold it as blocks, and every future deck
built from it starts from the argument rather than from a blank page.
---
## What a concept block is
One idea, stated completely enough to build a slide from, and independent of any template.
```
## <Concept name>
CLAIM One sentence. What this asserts.
WHY Why it matters to the audience. Two or three lines at most.
EVIDENCE Figures, sources, the worked example. Everything quantitative.
FORM What shape this wants to be — one number, comparison, sequence, statement.
NOTES Caveats, what it is not, where it breaks.
```
**`FORM` is the field that pays for itself.** Deciding the shape while the idea is fresh means the
build step is a lookup rather than a judgement.
---
## Extracting from a source
Where the source is an image-rendered deck or a PDF, it must be read visually — there is no text
layer to pull. Extract in a separate session and write to a file, so hundreds of slides never enter
a working conversation.
Ask for, in this order of importance:
1. **Every framework, staged model or diagram**, reconstructed completely — every stage in order,
every axis labelled, every cell.
2. **Every number**, with what it refers to and any stated source.
3. **Anything verbatim that is well phrased.** Good sentences are hard to rewrite and easy to reuse.
4. The argument in sequence, in ten or fifteen lines.
5. What could not be read.
**Findings only. No interpretation.** The analytical pass is separate work and mixing them makes
both harder to trust later.
---
## Two things to check before reuse
**Sourcing.** A figure that passed unchallenged in one setting may not in another. Anything
load-bearing either carries a source or gets relabelled as an estimate with the reasoning shown.
Presenting an estimate as a finding is the one avoidable failure.
**Terminology drift.** Concepts developed over time accumulate variant names for the same object.
Settle on one before the material enters a new argument, or the inconsistency will be noticed by the
one person in the room who reads carefully.
---
## Where concepts live
Anywhere they can be retrieved as text from the environment where decks get built. A wiki, a shared
document, a knowledge base. The requirement is only that it is **text, addressable, and reachable
from both sides.**
Publishing has a second benefit worth naming: a concept written for a general audience is stripped
of organisational specifics by necessity, which is exactly what makes it reusable across audiences
later.
Usage notes
Sizing. Block 1 loads with every message and is deliberately short. Blocks 2–4 load on retrieval. With a categorised layout inventory the whole set is well under 20 KB.
The inventory is per template, not per deck. Produce it once, upload it, regenerate only when the template itself changes.
Categorisation is the step that matters. A raw extract of fifty layout names is accurate and unusable. The one-line "reach for this when" against each content layout is what makes a recommendation actionable.
Drift. Reference blocks derive from the source articles named in the infobox. A material change to any of them is a trigger to regenerate the blocks and increment the version.
Change history
| Version | Date | Change |
|---|---|---|
| 1.0 | 18 August 2026 | Initial publication. Instruction block plus three reference blocks, derived from Presentation Production for WFM. |
| 1.1 | 19 August 2026 | Extractor gains --masters and --inventory; the per-slide inventory omitted by default for template files. Adds the deployment workflow. Prompted by a multi-brand kit producing 175 KB where 3-6 KB was expected.
|
| 2.1 | 20 August 2026 | Extractor derives a master signature from the modal prefix of its layout names, because slide masters usually carry no name attribute in PPTX and --masters by name could not discriminate. --masters now prints a table of every master with its signature, layout count and first three layout names. The extractor is embedded in Block 2, so the pack is self-sufficient.
|
| 2.0 | 20 August 2026 | Reoriented from file generation to a build sheet. Every observed failure was in the generation step, while assembly from a named layout inherits branding by construction. Restructured into three phases — inventory, concept, build. Adds concept extraction as a first-class step, so existing decks and papers become reusable sources. Generation retained for 40+ slide, recurring and data-driven decks. |
