| name | frontend-slides |
| description | Create stunning, animation-rich browser-native HTML presentations. Use only when the user explicitly wants an HTML/web presentation or animated interactive browser deck. Do not use for `.ppt`, `.pptx`, PowerPoint, Google Slides, native deck creation, native deck editing, deck templates, or PPTX conversion/export requests; use the `pptx` skill for those. |
| tools | ["run_skill_python_script"] |
| sandbox_scripts | [{"name":"export-pptx","path":"scripts/export-pptx.py","sha256":"31f678d80b6e0d8472490709cbc75b5f98b7dacfb37037a02ed57e915e2ff7e8","timeout_seconds":300,"outputs":["out/tool_artifacts.json"]}] |
Frontend Slides
Create zero-dependency, animation-rich HTML presentations that run entirely in the browser.
Core Principles
- Zero Dependencies — Single HTML files with inline CSS/JS. No npm, no build tools.
- Show, Don't Tell — Generate visual previews, not abstract choices. People discover what they want by seeing it.
- Distinctive Design — No generic "AI slop." Every presentation must feel custom-crafted.
- Progressive Disclosure — Read lightweight style indexes first. For bold templates, use small preview cards for style previews and load the full
design.md only after the user picks that template.
- Fixed 16:9 Stage (NON-NEGOTIABLE) — Every deck uses a 1920×1080 slide canvas scaled as a whole to the viewport. Slides must stay 16:9 on every screen, including phones. Do not reflow slide content to fit the device.
Design Aesthetics
You tend to converge toward generic, "on distribution" outputs. In frontend design, this creates what users call the "AI slop" aesthetic. Avoid this: make creative, distinctive frontends that surprise and delight.
Focus on:
- Typography: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics.
- Color & Theme: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. Draw from IDE themes and cultural aesthetics for inspiration.
- Motion: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions.
- Backgrounds: Create atmosphere and depth rather than defaulting to solid colors. Layer CSS gradients, use geometric patterns, or add contextual effects that match the overall aesthetic.
Avoid generic AI-generated aesthetics:
- Overused font families (Inter, Roboto, Arial, system fonts)
- Cliched color schemes (particularly purple gradients on white backgrounds)
- Predictable layouts and presentation patterns
- Cookie-cutter design that lacks context-specific character
Interpret creatively and make unexpected choices that feel genuinely designed for the context. Vary between light and dark themes, different fonts, different aesthetics. You still tend to converge on common choices (Space Grotesk, for example) across generations. Avoid this: it is critical that you think outside the box!
Fixed Stage Rules
These invariants apply to EVERY slide in EVERY presentation:
- Every deck has a viewport wrapper that fills the browser window.
- Every slide is authored inside a fixed 1920×1080 stage.
- The stage scales uniformly to fit the viewport. It may letterbox/pillarbox; it must not re-layout content.
- Do not use responsive breakpoints to rearrange slide content for phones.
- Use fixed internal slide measurements at the 1920×1080 design size.
- Slide visibility must be controlled by
.active / .visible using visibility, opacity, and pointer-events from viewport-base.css. Do not use display: none / display: block for slide switching; later layout classes such as .slide-content { display: flex; } can override them and make every slide visible at once.
- Use
clamp() only for non-slide UI outside the stage, or for small fallback previews where a full stage is impractical.
- Include
prefers-reduced-motion support
- Never negate CSS functions directly (
-clamp(), -min(), -max() are silently ignored) — use calc(-1 * clamp(...)) instead
When generating, read viewport-base.css and include its full contents in every presentation.
Content Density Modes
Ask the user whether this is primarily a reading deck or a speaking deck, then design around that answer:
| Density mode | Best for | Design behavior |
|---|
| Low density / speaker-led | Public talks, keynote-style sharing, live explanation | One idea per slide, large type, strong visual hierarchy, generous negative space, 1-3 bullets max, more slides if needed |
| High density / reading-first | Reports, handouts, async review, detailed internal docs | More self-contained slides, structured grids/tables/annotations, 4-8 bullets or 4-6 cards when readable, tighter but still intentional spacing |
Baseline limits still apply: no scrolling, no overflow, no overlapping panels, and no text below comfortable reading size. If content exceeds the selected density mode, split it into more slides instead of shrinking until it becomes cramped.
Phase 0: Detect Mode
Determine what the user wants:
- Mode A: New HTML Presentation — Create a browser-native HTML presentation from scratch. Go to Phase 1.
- Mode B: PowerPoint/PPTX/Google Slides/native deck request — Stop and route to the
pptx skill. Do not use frontend-slides for .ppt, .pptx, PowerPoint, Google Slides, native deck creation, native deck editing, templates, or conversion requests.
- Mode C: HTML Enhancement — Improve an existing HTML presentation. Read it, understand it, enhance. Follow Mode C modification rules below.
HelpUDoc Interaction Contract
Use workflow_action(action="request_user_interaction") for every decision gate in this skill. A UI form only exists when a structured workflow/Interaction tool emits an interrupt; prose like "select from the form above" is not enough.
Active HelpUDoc gates:
presentation_context — Ask exactly one initial question in workflow_action(action="request_user_interaction"): Low density / speaker-led or High density / reading-first.style_preview_selection — After generating the three HTML previews in .frontend-slides/slide-previews/, ask the user to choose a style with workflow_action(action="request_user_interaction") and presentation="style_preview".
Infer purpose, audience, length, content readiness, asset treatment, and slide outline from the user's request and supplied material. Do not pause for outline approval. Show the inferred outline only when it helps explain the draft or when the user asks to review it. If the request contains no usable topic or source material, ask one concise blocking content question; otherwise proceed.
Do not ask for outline_confirmation, style_path_selection, or mood_or_preset_selection in new runs. Those older gate IDs may exist in legacy traces, but the current workflow has only the two active decisions above.
After style preview selection, do not call the presentation complete until the final HTML deck exists. The final deck must use the fixed 1920×1080 stage architecture from viewport-base.css and html-template.md.
PowerPoint/PPTX/native deck work belongs to the pptx skill. Do not select or load frontend-slides because the user asks for .pptx, PowerPoint, Google Slides, native deck output, native deck editing, a deck template, or PPT conversion. The legacy scripts/export-pptx.py helper is only for finalizing an already-created HTML deck while this skill is already active; it is not a routing reason for new PPTX-related requests.
Mode C: Modification Rules
When enhancing existing presentations, fixed-stage fitting is the biggest risk:
- Before adding content: Count existing elements, check against density limits
- Adding images: Fit them inside the 1920×1080 slide canvas. If slide already has max content, split into two slides
- Adding text: Max 4-6 bullets per slide. Exceeds limits? Split into continuation slides
- After ANY modification, verify: the slide stage remains 16:9, no text overflows its card, no panels overlap, and screenshots look correct at 1280×720 plus one phone viewport
- Proactively reorganize: If modifications will cause overflow, automatically split content and inform the user. Don't wait to be asked
When adding images to existing slides: Move image to a new slide or reduce other content first. Never add images without checking if existing content already fills the 1920×1080 slide stage.
Phase 1: Infer Context and Ask Deck Mode (New Presentations)
Infer the purpose, audience, narrative, slide count, content readiness, and asset plan from the user's request and any supplied files. Use sensible defaults instead of asking the user to configure the workflow.
Ask exactly one structured question:
- "Low density / speaker-led" — Big ideas, fewer words, more visual breathing room
- "High density / reading-first" — More self-contained detail for async reading
Do not ask about inline editing during Phase 1. Users should not have to choose editing behavior before seeing a draft. Inline editing is a post-draft affordance: include it by default unless the user explicitly asks for a locked/export-only file.
Remember the user's density choice. It affects slide count, typography scale, amount of text per slide, layout density, and whether to favor cinematic presenter slides or self-contained reading slides.
If the user already stated the mode, do not ask again. If the request contains no usable topic, brief, notes, or source file, ask for the missing content because generation is otherwise impossible.
Step 1.2: Image Evaluation (if images provided)
If user selected "No images" → skip to Phase 2.
If user provides an image folder:
- Scan — List all image files (.png, .jpg, .svg, .webp, etc.)
- Inspect each image — Use the agent's available image-understanding capability. If image reading is unavailable, use filenames/metadata and ask the user to clarify only when needed
- Evaluate — For each: what it shows, USABLE or NOT USABLE (with reason), what concept it represents, dominant colors
- Co-design the outline — Curated images inform slide structure alongside text. This is NOT "plan slides then add images" — design around both from the start (e.g., 3 screenshots → 3 feature slides, 1 logo → title/closing slide)
- Draft the outline — Build the slide structure from the text and curated images without a mandatory approval stop. Revise it later if the user requests changes.
Logo in previews: If a usable logo was identified, embed it (base64) into each style preview in Phase 2 — the user sees their brand styled three different ways.
Phase 2: Style Discovery
This is the "show, don't tell" phase. Most people can't articulate design preferences in words.
Step 2.0: Generate 3 Style Previews Directly
Based on purpose, audience, mood, and content density, generate 3 distinct single-slide HTML previews showing typography, colors, animation, and overall aesthetic.
Do not ask the user whether they want options or a preset picker. The default discovery experience is always visual comparison.
If the user already gave a vibe, use it. If they did not, infer the likely mood from the occasion, audience, content, and stakes. Keep the options diverse enough that the user can react visually instead of needing to articulate taste up front.
If the user explicitly names a preset or bold template, honor that as one option and generate the remaining preview slots around it.
Read STYLE_PRESETS.md for safe preset candidates. If bold-template-pack/selection-index.json exists, read that compact index too, but do not read any design.md files yet.
| Mood | Suggested Presets |
|---|
| Impressed/Confident | Bold Signal, Electric Studio, Dark Botanical |
| Excited/Energized | Creative Voltage, Neon Cyber, Split Pastel |
| Calm/Focused | Notebook Tabs, Paper & Ink, Swiss Modern |
| Inspired/Moved | Dark Botanical, Vintage Editorial, Pastel Geometry |
Preview mix rules:
- Generate 3 previews by default: 1 safe preset from
STYLE_PRESETS.md, at least 1 bold template from bold-template-pack/selection-index.json, and 1 wildcard.
- The wildcard may be either a second bold template or a self-generated custom design. Choose whichever creates the strongest, most useful contrast for the user's occasion, audience, mood, and content.
- Do not force every expressive option to come from the template library. If the brief has a sharper, more specific design opportunity than the available templates, use the wildcard slot to design freely.
- For conservative or high-stakes decks, make the safe preset especially restrained; choose a calm, higher-formality bold template; make the wildcard either another restrained template or a custom design that feels authoritative rather than decorative.
- For expressive decks, keep the safe preset as a readable fallback; choose one strong bold template; make the wildcard adventurous, context-specific, and clearly different from both other previews.
- If bold template matches feel weak, use the wildcard as a custom design or fall back to another safe preset instead of forcing a template.
Custom wildcard design rules:
- Follow the Design Aesthetics section above: no generic "AI slop", no default font/color/layout choices, no purple-gradient-on-white clichés, no cookie-cutter dashboard/card look.
- Match the user's stated occasion, audience, mood/vibe, and content density. The custom design should feel authored for this deck, not merely "stylish."
- Make a deliberate visual thesis: distinctive typography, a committed palette, a recognizable layout system, and one strong atmospheric or graphic device.
- Keep it feasible for a full deck. The preview must imply a design system that can expand into section, content, quote, comparison, and closing slides.
- Use fixed 1920×1080 stage rules and pass the same preview authenticity checks as every other option.
- Never render "custom", "wildcard", "AI-generated", or design-process labels on the slide itself.
Bold template selection rules:
- Match user purpose and mood against
mood, tone, best_for, avoid_for, formality, density, and scheme.
- Treat
best_for examples as soft signals, not strict industry filters.
- Keep the three previews genuinely different from each other.
- After choosing bold template candidate(s), read only those candidate(s)'
preview.md files from the preview_md paths in the selection index.
- Use
preview.md only for title-slide previews. Do not read full design.md files until the user picks the final template.
- Do not read or copy
template.html unless the selected final design.md is missing a critical implementation detail.
Preview authenticity rules (NON-NEGOTIABLE):
- Every style preview must look like a real first slide from the user's deck, not a diagnostic card.
- Never render internal workflow text on a slide: no
preview, generated from, preview.md, template, preset, style option, Option A/B/C, file names, paths, or source-doc labels.
- Never render template names or slug names on the slide itself. Template/style names belong only in the message to the user.
- Never render user requirement notes as slide content, such as "sharp and provocative", "safe option", "bold option", "for internal sharing", or "audience: ...", unless the user explicitly wants that exact phrase to appear in the deck.
- If the slide needs chrome, use real deck chrome only: the deck title, section title, date, author, company, page number, or a genuine content phrase from the user's material.
- Before opening previews, inspect the visible text and revise if any internal metadata appears.
Save previews to .frontend-slides/slide-previews/ (style-a.html, style-b.html, style-c.html). Each should be self-contained and compact, showing one animated title slide.
Open each preview automatically for the user.
Step 2.1: User Picks
Ask (header: "Style"):
Which style preview do you prefer? Options: Style A: [Name] / Style B: [Name] / Style C: [Name] / Mix elements
If "Mix elements", ask for specifics.
Phase 3: Generate Presentation
Generate the full presentation using content from Phase 1 (text, or text + curated images) and style from Phase 2.
If images were provided, the slide outline already incorporates them from Step 1.2. If not, CSS-generated visuals (gradients, shapes, patterns) provide visual interest — this is a fully supported first-class path.
Apply the user's density choice throughout the deck:
- Low density / speaker-led: Use more slides with fewer ideas per slide. Favor large headings, short phrases, visual metaphors, section beats, quote/statement slides, and presenter-friendly pacing.
- High density / reading-first: Make slides more self-contained. Use structured grids, comparison tables, annotated diagrams, captions, and concise explanatory copy. Keep hierarchy strong so it feels designed, not like a document pasted onto slides.
If the user's stated needs are mixed, choose the closer of the two modes instead of inventing a middle option: live audience persuasion defaults low-density; async circulation or detailed review defaults high-density.
Never let high density become visual clutter. If a high-density slide starts to overflow, split it or redesign it into a clearer structure.
If the user selected a bold template from bold-template-pack, read that one template's full design.md before generating. Do not read the other bold templates. Treat design.md as the design recipe:
- Preserve its fonts, palette, decorative vocabulary, spacing rhythm, and presentation grammar.
- Generate the final deck as a fixed 1920×1080 stage scaled uniformly to the viewport, regardless of whether the source template originally used
deck-stage.js or viewport-fluid CSS.
- Treat viewport-fluid values in
design.md as design proportions to translate into 1920×1080 stage coordinates. Do not keep them as live viewport reflow rules in the final deck.
- Keep the output as a single self-contained Frontend Slides HTML file.
- Do not copy demo slide content or mimic the source template too literally.
- Use
template.html only as a last-resort implementation reference for the selected template.
- After generating, verify both content overflow and panel overlap in rendered browser screenshots.
scrollHeight checks alone are not enough because grid panels can visually cover each other.
If the user selected a self-generated custom wildcard, treat that preview's CSS and layout as the design recipe:
- Preserve its fonts, palette, decorative vocabulary, spacing rhythm, grid logic, and presentation grammar.
- Expand the same visual system across the full deck. Do not switch to a preset or bold template after the user has chosen the custom direction.
- Design any missing slide layouts from that system rather than importing patterns from another style.
- Keep the output fixed-stage, single-file, and visually verified like every other deck.
Before generating, read these supporting files:
Key requirements:
- Single self-contained HTML file, all CSS/JS inline
- Include the FULL contents of viewport-base.css in the
<style> block
- Use fonts from Fontshare or Google Fonts — never system fonts
- Add detailed comments explaining each section
- Every section needs a clear
/* === SECTION NAME === */ comment block
Phase 4: Native Deck Requests
When a request involves .ppt, .pptx, PowerPoint, Google Slides, native deck output, native deck editing, templates, or PPT conversion, stop using this skill and route to pptx.
The old PPT extraction helper may remain in the folder for compatibility with existing HTML-deck workflows, but it must not be used as the primary path for PPTX-related user requests.
Phase 5: Delivery
- Clean up — Delete
.frontend-slides/slide-previews/ if it exists
- Open — Use
open [filename].html to launch in browser
- Summarize — Tell the user:
- File location, style name, slide count
- Navigation: Arrow keys, Space, swipe/tap if enabled
- How to customize:
:root CSS variables for colors, font link for typography, .reveal class for animations
- Inline text editing is available: Hover top-left corner or press E to enter edit mode, click any text to edit, Ctrl+S to save
- Offer the natural post-draft actions: ask for revisions, edit text directly in the browser, or export/share
Phase 6: Share & Export (Optional)
After delivery, ask the user: "Would you like to export or share this HTML presentation? I can export it as PDF or deploy it to a live URL."
Options:
- Export to PDF — Universal file for email, Slack, print
- Deploy to URL — Shareable link that works on any device
- No thanks
If the user declines, stop here. If they choose one or both, proceed below.
6A: Legacy HTML-to-PPTX Export
Use this only when frontend-slides is already active for an existing HTML deck and the user explicitly asks to export that current HTML deck to PPTX. For all other .pptx, PowerPoint, Google Slides, native deck, template, editing, or conversion requests, route to the pptx skill instead. This legacy exporter is screenshot-backed.
This captures each slide as a 1920×1080 screenshot and places each screenshot full-bleed into a widescreen PowerPoint slide. The result is visually faithful and opens in PowerPoint, Keynote, and Google Slides, but it produces image-backed slides, not deeply editable PowerPoint shapes.
-
Run the export script:
python scripts/export-pptx.py <path-to-html> [output.pptx]
If no output path is given, the PPTX is saved next to the HTML file.
-
What happens behind the scenes:
- A headless browser opens the presentation at 1920×1080.
- It screenshots each
.slide.
python-pptx creates a widescreen deck with one full-slide image per slide.
-
Deliver the PPTX — Tell the user:
- The file location and slide count
- That the deck is visually faithful but image-backed
- That PowerPoint editing should happen in the HTML source for best results, then re-export
⚠ PPTX export gotchas:
- Slides must use
class="slide". The exporter counts .slide elements.
- First browser capture can be slow. Playwright/Chromium may install on first use.
- Fonts and local assets must load through the local server. Use relative asset paths next to the HTML when possible.
- Editable PPTX is a separate quality tier. This exporter prioritizes fidelity, not converting CSS into editable Office shapes.
6B: Deploy to a Live URL (Vercel)
This deploys the presentation to Vercel — a free hosting platform. The link works on any device (phones, tablets, laptops) and stays live until the user takes it down.
If the user has never deployed before, guide them step by step:
-
Check if Vercel CLI is installed — Run npx vercel --version. If not found, install Node.js first (brew install node on macOS, or download from https://nodejs.org).
-
Check if user is logged in — Run npx vercel whoami.
- If NOT logged in, explain: "Vercel is a free hosting service. You need an account to deploy. Let me walk you through it:"
- Step 1: Ask user to go to https://vercel.com/signup in their browser
- Step 2: They can sign up with GitHub, Google, email — whatever is easiest
- Step 3: Once signed up, run
vercel login and follow the prompts (it opens a browser window to authorize)
- Step 4: Confirm login with
vercel whoami
- Wait for the user to confirm they're logged in before proceeding.
-
Deploy — Run the deploy script:
bash scripts/deploy.sh <path-to-presentation>
The script accepts either a folder (with index.html) or a single HTML file.
-
Share the URL — Tell the user:
- The live URL (from the script output)
- That it works on any device — they can text it, Slack it, email it
- To take it down later: visit https://vercel.com/dashboard and delete the project
- The Vercel free tier is generous — they won't be charged
⚠ Deployment gotchas:
- Local images/videos must travel with the HTML. The deploy script auto-detects files referenced via
src="..." in the HTML and bundles them. But if the presentation references files via CSS background-image or unusual paths, those may be missed. Before deploying, verify: open the deployed URL and check that all images load. If any are broken, the safest fix is to put the HTML and all its assets into a single folder and deploy the folder instead of a standalone HTML file.
- Prefer folder deployments when the presentation has many assets. If the presentation lives in a folder with images alongside it (e.g.,
my-deck/index.html + my-deck/logo.png), deploy the folder directly: bash scripts/deploy.sh ./my-deck/. This is more reliable than deploying a single HTML file because the entire folder contents are uploaded as-is.
- Filenames with spaces work but can cause issues. The script handles spaces in filenames, but Vercel URLs encode spaces as
%20. If possible, avoid spaces in image filenames. If the user's images have spaces, the script handles it — but if images still break, renaming files to use hyphens instead of spaces is the fix.
- Redeploying updates the same URL. Running the deploy script again on the same presentation overwrites the previous deployment. The URL stays the same — no need to share a new link.
6C: Export to PDF
This captures each slide as a screenshot and combines them into a PDF. Perfect for email attachments, embedding in documents, or printing.
Note: Animations and interactivity are not preserved — the PDF is a static snapshot. This is normal and expected; mention it to the user so they're not surprised.
-
Run the export script:
bash scripts/export-pdf.sh <path-to-html> [output.pdf]
If no output path is given, the PDF is saved next to the HTML file.
-
What happens behind the scenes (explain briefly to the user):
- A headless browser opens the presentation at 1920×1080 (standard widescreen)
- It screenshots each slide one by one
- All screenshots are combined into a single PDF
- The script needs Playwright (a browser automation tool) — it will install automatically if missing
-
If Playwright installation fails:
- The most common issue is Chromium not downloading. Run:
npx playwright install chromium
- If that fails too, it may be a network/firewall issue. Ask the user to try on a different network.
-
Deliver the PDF — The script auto-opens it. Tell the user:
- The file location and size
- That it works everywhere — email, Slack, Notion, Google Docs, print
- Animations are replaced by their final visual state (still looks great, just static)
⚠ PDF export gotchas:
Supporting Files
