• A design system inspired by the NBG brand: 16:9 artboard, Aptos, a nine-colour teal-led palette.
• Nine slide templates (covers, dividers, content), logos and photography bundled with the skill.
• Guardrails written down once, applied to every deck.

• Claude authors the HTML; zero-dependency scripts embed the images, add the editor, verify, write the rebuild script, screenshot and export.
• A strict, browser-free gate that a deck must pass before it is delivered.
• The PDF and the PowerPoint file are made from the deck itself, so they look like the HTML.

• Every delivered deck carries a right-click editor: fix a word, resize a card, align a row, ask an AI assistant.
• Nothing to install: it works from a file on the desktop, in any modern browser.
• Edits stay inside the look: the skill's fonts and palette only.

Every deck shares one look. One palette, one type stack, one artboard, one logo lockup — enforced by the skill, not by the author's memory.

The verifier rejects a deck with a fake logo, a missing photo or an external image path.

From any content to a finished deck in minutes — a brief in chat, notes, a document, a spreadsheet, an existing deck or a Google Slides draft. Once the generator exists, every re-run is one command.

One self-contained file. It can be emailed, put on a share or opened from a USB stick; it renders identically everywhere because nothing points back to the machine that built it.

Recipients fix their own slides. A typo, a longer title, a card that should be teal, a row that needs aligning — done in place, saved as a copy, exported to PDF — without a regeneration.

• A drawn icon, diagram or chart is no longer a picture: its parts — paths, shapes, text, groups — move, resize, recolour, reorder, duplicate and reword in place.
• Path data is never rewritten; one reversible record per drawing.

• Text, Shape and SVG share one floating panel; the tab of the editor in use comes to the front by itself.
• Pin, hide, anchor or detach it — remembered per deck.

• Any deck as an editable .pptx (1.25): real text boxes with their fonts and weights, shapes, cropped pictures, SVG pictures — never slide screenshots.
• Checked against the deck in PowerPoint itself, slide by slide.

• Every deck ships with <deck>.rebuild.mjs: after a skill update it re-embeds the newer editing tools, keeps a backup, re-verifies and re-exports the PDF.
• --check only reports.

• Topic — what the deck is about.
• Audience — who reads it; this sets depth and tone.
• Slide count or depth — 8, 16, 20+.
• Whether the bundled design-system files may be changed (they normally are not).

• Language: English. gr and bi exist; anything else must come from you.
• Output: HTML. A PDF or a PowerPoint file is always exported from the finished HTML, never authored separately.
• Logo: shown, unless you ask to hide it.
• Cover first, dividers between sections, content slides in between.

• Hand over a PowerPoint made of slide pictures: the .pptx is converted element by element.
• Guess a missing input or substitute a fallback value.
• Put an API key, token or endpoint into a deck or into the skill.
• Reference an image by a path: every image is embedded, or the deck fails the gate.

• A move or resize is written in the part's parent coordinate system: the screen box is mapped back through the parent's transform.
• A rect or image without a transform gets plain x / y / width / height; a pure move of text, a use, a circle, an ellipse or a line changes x / y, cx / cy or x1…y2.
• Everything else — a path, a scaled text, a group — gets a matrix() prepended to its own transform. The d attribute stays as drawn.

• Fill, stroke, stroke width and opacity become presentation attributes, or the inline style property when the part already sets one — so the change wins over the stylesheet without touching it.
• Order is a real move in the drawing order inside the parent; Duplicate clones without ids and places the copy after the original.
• The text field replaces the one run of a <text>; labels with several runs are edited as source in the Tree tab.

• Every operation records the <svg> element's inner HTML as a single html edit — the same kind as a text edit — so it persists in the browser, lands in the saved copy, is discarded per slide and prints.
• Reset SVG drops that record. Sessions are exclusive: editing text, selecting a shape or preparing a print ends the SVG session first.
• SVG text is never contenteditable; the SVG as a whole is still a shape for Resize / move shape.

• Shift+click adds the smallest shape under the pointer, or removes it when it is already selected.
• Shift+drag on the slide draws a box: every top-level shape fully inside is added.
• Ctrl/Cmd+A selects every top-level shape of the slide; Ctrl/Cmd+click selects everything inside the shape under the pointer; a shape with nothing inside is picked alone, even a group member, and on the same spot again cycles outward.
• The menu offers Add to / Remove from selection / Select all shapes; the Outline tab does it with checkboxes.

• Order: bring to front / forward, send backward / to back (Ctrl/Cmd+] and [, Shift for front / back).
• Align left, centre, right, top, middle, bottom — relative to the selection's own box or to the slide.
• Distribute horizontally or vertically with equal gaps; the first and last stay put.
• Dragging moves all, handles scale all proportionally, every style control applies to all.

• Group (Ctrl/Cmd+G) / Ungroup (Ctrl/Cmd+Shift+G).
• A group is logical: members carry a data-nbg-group mark and always select, move, resize, align and order together.
• Groups persist in the browser, land in the saved copy and are removed by Discard edits.
• The page structure is never rebuilt: ordering is an inline z-index, grouping an attribute, so every earlier edit stays valid.

• Outline: the slide's shapes nested by containment — cards, text blocks, images — with kind icons, sizes, group badges, a text filter, checkboxes, All / None. Click a name to select it, Shift+click adds.
• Tree: the slide's HTML elements, synced both ways with the selection; double-click edits a text; hovering outlines the element on the slide.
• Under the tree, the selected element's editable source behind a draggable splitter. Apply records it like any other edit; scripts are stripped. For people who know what they are doing.

• ⧉ on the menu (structure and assistant included) or on the toolbar moves it into a window of its own: a Document Picture-in-Picture window in Chrome and Edge — always on top, no browser chrome, anywhere on the desktop, even off the browser — or a pop-up elsewhere.
• The panel keeps working on the deck from there; closing the window, ✕ or Esc brings it back.
• A detached panel is pinned: it idles rather than disappears when nothing is selected. Screenshots asked from a detached assistant use that window's permission.

• While the menu is detached, or open on a panel tab, a right-click on the slide opens a compact picker at the pointer instead of the full menu.
• It holds the same Select at this point hierarchy — front-most first, containers and shapes behind — plus Edit text.
• A click selects, Shift+click adds, Esc closes it. The big menu keeps its place and its tab.
• Ctrl/Cmd+Shift+O / H open Outline / Tree directly; Ctrl/Cmd+Shift+L the assistant.

• A prompt from the drop-down: Free request, Review the slide, Proofread the text, Tighten the copy, Speaker notes, Restyle the selection, Rewrite the selection's text, plus your own.
• A request box for extra instructions.

• Screenshot of the slide (tab capture; toolbars hidden, cropped to the slide).
• Slide source — its HTML plus the CSS rules it uses; embedded images travel as small placeholders, so photos cost no tokens.
• Selected element source.
• Clipboard image — paste, drop or Read clipboard.

• Show the answer in the panel, with Copy and Apply to selection.
• Replace the selected element: the reply is the element's replacement HTML — same tag, scripts stripped, recorded as a normal edit — with Undo.
• Right-click a row in Outline or Tree for an Ask about… popup on that element.

• Providers: Anthropic, Azure-hosted Anthropic (Microsoft Foundry), OpenAI-compatible, Azure OpenAI, DeepSeek.
• Endpoint, model or deployment, API key (kept in this browser, or for the tab only), Test.
• Settings are kept per provider; nothing is defaulted — a missing value blocks the request with a message.
• The page calls the endpoint directly; a provider that blocks browser calls needs a gateway.

• Every change is a record {{ path, original, … }} where path is the child-index path from the root — cheap, exact, and the reason the DOM is never restructured.
• Three kinds: html (text and selection-level formatting), style (block formatting, geometry, fill, border, z-index), group (the data-nbg-group attribute). An SVG session records the whole <svg> as one html record.
• Stored in localStorage under nbg-deck-edits:<path>#<title>; re-applied on load; a record whose original no longer matches is dropped.

• When the inlined script runs — after the deck's own scripts, before any runtime element and before stored edits — it takes an outerHTML snapshot.
• Save edited copy parses that snapshot with DOMParser, applies the records, and downloads the result: it loads exactly like the original and carries the menu.
• The print path uses the same print-layout shim as the CLI, then restores every class, style and attribute it touched.

• A "shape" is a positioned element, one with a background, border or shadow, or an image; otherwise the text block.
• Pointer deltas are divided by the slide's scale (rect.width / offsetWidth), so coordinates are artboard pixels.
• Ordering ranks siblings by effective layer and writes an inline z-index; a negative index makes the parent a stacking context with isolation: isolate.
• Rich contenteditable, not plaintext-only, because the latter forces pre-wrap and re-flows titles.

• Run order: author → embed → add menu → verify strict → rebuild script → screenshots → PDF / PowerPoint. Never deliver a deck that fails the gate.
• Every image a data: URI; the logo always the bundled lockup.
• Fit at 1366×768 and 1440×900; no element collisions; 32 px between groups, 72 px above the footer.
• PDF and PowerPoint only from the verified HTML, only through the exporters; the .pptx always compared.

• The skill holds no credentials. Assistant keys are the viewer's and live only in their browser — never in the skill, a deck or a saved copy.
• No fallback values: a missing input is a question, a missing setting a message. Exceptions are written into the project memory first.
• The agent never enters endpoints or keys for a recipient and never relies on the assistant for its own work.

• The look cannot be left from the editor: fonts limited to the design-system stacks, colours to the NBG-inspired palette. The Tree tab's source editor is the one deliberate exception, for experts.
• The editor changes text, formatting, geometry, order, groups and shape style. Images, new elements and structure are the skill's job — regenerate.
• PowerPoint is an export of the HTML deck, never a second source to edit and re-import; newsletters, GPT and NotebookLM artifacts of the original project are excluded unless asked for.