anthropic-export-viewer

Create interactive data exploration experiences with drill-down, cross-filtering, correlation discovery, animated transitions, and responsive layouts. Use this skill whenever the user wants to explore, visualize, or interact with data — dashboards, charts, data stories, KPI monitors, heatmaps, comparison views, funnel or cohort breakdowns. Trigger when the user says "show me the data", "build a dashboard", "visualize trends", "find patterns", "compare metrics", or uploads CSV/JSON/Excel wanting insight. Also trigger for real-time displays, animated charts, interactive filtering, cross-filtering, sparklines, data tables with sorting/search, or any multi-view coordinated visualization. NOT for static one-off charts or pure statistical computation with no visual output.

Enforces a task-based coordination protocol for AI agents editing a shared repository. Every coding session MUST begin by opening a task, declaring target files and objectives, and checking for file locks held by other agents. The agent MUST announce completion and release locks when done. Trigger this skill whenever an AI agent is about to write, edit, refactor, delete, or move any file in a shared codebase. Also trigger on: "start coding", "open a task", "edit files", "begin work on", "implement", "fix bug in", "refactor", "modify", "update code", "coordinate agents", "lock file", "unlock file", "check locks", "task status", "agent coordination", "multi-agent editing", or any request that results in file modifications within a repository. If in doubt about whether another agent might be working on the same repo, trigger this skill. The cost of coordination is low; the cost of a merge conflict or overwritten work is high.

Review prose for low-substance writing ("slop") using a two-tier diagnostic. Tier 1: surface cues (vocabulary, sentence patterns, structure, decorative performance). Tier 2: substance failures (abstraction without specifics, invocation without application, intellectual dishonesty, unfalsifiability). Tier 2 dominates Tier 1. Trigger whenever the user asks to "check for slop", "review writing quality", "detect AI writing", "run anti-slop", "check my writing", "audit this text", "is this filler", "does this say anything", "this reads like AI", "too fluffy", "strip the slop", "make this real", or any variation of assessing whether writing does intellectual work versus performing the shape of thought. Also trigger for self-editing or reviewing Claude's own output for substance. If text is uploaded and the user asks whether it is substantive or worth reading, use this skill.

Analyze architectural implications of design choices across any domain — software, business, infrastructure, data, or process design. Produces a decision report with SVG visualizations (option-space maps, enables/blocks flows, composition matrices), a Markdown document, and interactive follow-up suggestions. Use this skill when the user asks about trade-offs, design decisions, "should I use X or Y", "pros and cons", "what does choosing X block or enable", "help me decide between", "decision matrix", "option analysis", "downstream effects", or any request to understand the consequence landscape of a choice. Also trigger when the user pastes technical context and asks what the options or trade-offs are. If the user wants structured analysis — not just a list of pros and cons — this is the skill.

Read, write, validate, trace, test-derive, translate, and explain Behavior Spec Language (BSL) specifications. Use this skill whenever the user mentions "BSL", "behavior spec", "behavioral specification", ".bsl", or asks to specify observable application behavior declaratively. Also trigger when the user asks to "write a spec for [feature]", "generate test cases from a spec", "trace a rule evaluation", "translate TypeScript to BSL" (or vice versa), "validate this spec", "lint this spec", "explain this spec", "review this spec", or any request involving declarative behavior specifications with rules, invariants, side effects, and state machines. If the user uploads a file with BSL-like syntax (SPEC header, INPUT/STATE/OUTPUT/RULES sections), use this skill even if they don't say "BSL" explicitly.

Map any content — articles, news, books (fiction and non-fiction), scriptures, legal filings, transcripts, technical documentation, academic papers — into a valid Claim Formalization Schema (CFS) v0.5.0 JSON instance. Use this skill whenever the user asks to "formalize", "extract claims from", "map to CFS", "analyze the argument structure of", "decompose the logic of", or otherwise convert textual content into structured claim graphs. Also trigger when the user uploads or pastes content and asks for "propositions", "claim extraction", "argument mapping", "logical decomposition", "epistemic analysis", or "narrative formalization". This skill handles all source kinds: journalism, technical_documentation, legal_filing, policy_paper, transcript, academic_paper, fiction, scripture, and other. Even if the user does not mention CFS by name, trigger this skill whenever structured claim extraction from text is requested.

Design and implement high-quality CLI user experiences in Rust using clap. Trigger this skill whenever the user is building a command-line tool, designing CLI arguments/subcommands, implementing error handling for a CLI, adding progress indicators, color output, shell completions, interactive prompts, help text, or any aspect of how a terminal program communicates with its human operator. Also trigger when the user asks to "review my CLI", "improve the UX of my CLI", "make my CLI more user-friendly", "add --help", "design subcommands", "add shell completions", "add color output", "handle errors nicely", or any phrasing about making a command-line program pleasant, discoverable, or robust for humans. If the user is writing a Rust CLI and the conversation touches argument structure, output formatting, error messages, or user interaction — use this skill. Even if the user just says "build me a CLI for X", this skill applies because every CLI needs good UX from the start.

Apply a structured JSON patch envelope to source code files. Supports Python, JavaScript, TypeScript, Rust, HTML, and CSS. Operations: rename, replace, delete, move symbols; add/remove imports; find/replace within scope; BLOCK/ANCHOR markers; decorator injection. Produces a deterministic EXECUTION_REPORT with per-op status, content hash, and a ULID-named working copy. Use when the user says: "apply code patch", "structured edit", "patch envelope", "rename function", "rename class", "move symbol", "delete function", "add import", "remove import", "replace the body of", "refactor this function", "reorganize imports", "restructure the code", "batch edit", "surgical code change", "swap these functions", "change the signature", "inject a decorator", "find and replace in this function", or provides a JSON object with "op" fields targeting source code. Also trigger for batch mutations with an audit trail, or any targeted, auditable source code changes without rewriting the whole file.

Inspect an entire codebase and produce a comprehensive REQUIREMENTS.md covering project overview, provenance, asset inventory, functional and non-functional requirements, data models, API contracts, configuration, testing, dependencies, build/deploy, and gaps/risks. Use this skill for: "document a codebase", "reverse-engineer requirements", "generate REQUIREMENTS.md", "audit a project", "codebase report", "map out what this repo does", "onboarding doc from code", "project handoff document", "full codebase analysis", "requirements extraction", "document everything in this repo", "write a spec from code", "technical documentation from source". If the user wants a single document that lets a new developer understand the full scope and behavior of a system — use this skill.

Analyze any concept and produce a structured multi-dimensional classification across decomposition status, substitutability, strategic posture, IP regime, epistemic accessibility, maturity, combinatorial profile, application landscape, and temporal dynamics. Frame-relative, correlation-aware, and honest about its own limitations.

Perform deep conceptual analysis of codebases — not structural extraction (class diagrams, call graphs) but intent inference, design-decision archaeology, and predictive modeling. Use this skill whenever the user asks to "analyze", "understand", "explain the architecture of", "map out", "reverse-engineer", or "onboard me to" a codebase or repository. Also trigger when the user asks questions like "how does this system think?", "what are the design decisions?", "where are the tensions/tech debt?", "what would break if I changed X?", or "give me the mental model for this codebase." Trigger even for partial analysis requests like "explain the data flow" or "what are the core concepts?" — the lenses can be applied individually. Do NOT trigger for simple file reading, syntax questions, single-function explanations, or bug fixes unless the user explicitly frames them as architectural/conceptual questions.

Surgical patch-based editing for Markdown documents. Use this skill whenever the user wants to edit, restructure, reorganize, or make targeted changes to a large Markdown document — especially specs, structured prose, technical documentation, or any document where rewriting the whole file would be wasteful or risky. Trigger on: "edit this document", "move this section", "restructure", "reorganize", "patch", "surgical edit", "merge these sections", "split this section", "deduplicate", "make precise changes", or any request to modify a Markdown file while preserving unchanged content. Also trigger when the user provides a document and a set of goals or feedback to incorporate. Generates a machine-applicable patch set — not a full rewrite. The source document is never modified; all changes target a working copy.

Inspect a codebase and produce a drift-risk map — a structured inventory of every coupling between source-of-truth artifacts and their dependents, scored by the risk of silent desynchronization. Use this skill whenever the user asks to audit, map, or analyze coupling, drift, consistency, synchronization, or contract alignment across a codebase. Also trigger when the user mentions "what breaks if I change X", "are my types/schemas/docs in sync", "find manual mirrors", "coupling audit", "contract drift", "schema drift", "consistency check across layers", or any request to understand how changes propagate (or fail to propagate) through a project. Trigger even when the user phrases it casually, e.g. "I keep finding stale docs" or "my SDK is out of date with the API spec" or "how tightly coupled is this repo". If the user wants to know where their codebase is fragile to silent breakage, use this skill.

Extract structured engineering drawing data from documents — PDFs, images, markdown reports, specs, datasheets — and produce EDIS JSON (Engineering Drawing Interchange Schema) for the eng-schematic-renderer skill. Trigger on "extract drawing data", "pull dimensions from", "parse engineering specs", "get geometry from this document", "extract parts and dimensions", "prepare data for a schematic", "read this drawing", "extract BOM", "pull tolerances", or any request to convert engineering documents into structured data. Also trigger when a user uploads a technical PDF or engineering report and asks to "visualize", "draw", "make a schematic", or "render the geometry" — run this extractor first, then hand off to eng-schematic-renderer. Even casual "what does this part look like" or "draw this pipe" on an engineering document should trigger this skill as step one.

Render engineering schematics — cross-sections, longitudinal sections, detail views, assembly drawings — from structured EDIS JSON data produced by the eng-drawing-extractor skill. Produces standards- compliant technical drawings as inline SVG (via Visualizer), interactive React artifacts, or downloadable SVG/PDF files. Trigger whenever the user asks to "render the schematic", "draw the cross- section", "visualize the assembly", "show me the pipe layout", "generate a technical drawing", "render the EDIS", "make a section view", or any variation of producing a visual engineering drawing from extracted data. Also trigger when the eng-drawing-extractor has produced an EDIS JSON and the user wants to see it. Even casual phrasing like "show me what this looks like" or "draw it" after an extraction should trigger this skill. If EDIS JSON is not available but the user wants a schematic from a document, trigger eng-drawing-extractor first, then this skill.

Produce standards-aware 2D engineering schematics and technical drawings as SVG files. Use whenever the user asks to draw, diagram, sketch, or illustrate any engineering concept needing dimensional accuracy, standard symbols, line weights, hatching, or annotation: cross-sections, P&IDs, electrical circuits, structural details, assembly views, hydraulic circuits, mechanical details, weld callouts, tolerance annotations, or any figure for an engineering report or standards submission. Also trigger when asked to "visualize" or "show" a mechanical, structural, civil, electrical, or process concept as a technical drawing (not infographic or UI). Trigger on casual phrasing: "draw the cross-section", "sketch the pipe layout", "show the interference fit", "diagram the circuit". If the output needs dimension lines, section hatching, or engineering symbols — use this skill.

Run structured AI experiments with iterative hypothesis-test-learn cycles, vision-based validation, and multi-agent evaluation via Anthropic API. Trigger on: "experiment with", "try different approaches", "which method works best", "compare techniques", "find the best way to", "A/B test", "run experiments", "optimize visually", "find the most realistic", "try multiple versions", "evolutionary approach", "explore the design space", "run trials", "benchmark approaches", or any request to systematically try N alternatives, measure outcomes, and converge on the best. Also trigger when the user wants to discover the best method through experimentation. Even "play around with different ways" or "figure out the best approach" should trigger this skill.

Evaluate feedback as claims before acting — prevents sycophantic compliance. Use this skill whenever the user provides feedback, corrections, disagreements, or evaluative input about Claude's prior output. Trigger on phrases like "that's wrong", "actually...", "you made an error", "my manager says...", "I disagree", "fix this", "this is incorrect", "no, it should be...", "you missed...", or any message that asserts Claude's previous response was wrong, incomplete, or should change. Also trigger when a third party's feedback is relayed ("my reviewer said...", "the team thinks..."). If the user's message is attempting to correct, revise, or challenge something Claude said, use this skill. Do NOT trigger on requests for new work, clarifying questions with no evaluative content, or subjective style preferences stated as preferences (not corrections).

Formalize any natural-language proposition, argument, policy document, spec, or contract into mathematical logic and then verify whether it covers all computable cases in its state space. Use this skill whenever the user asks to "formalize", "prove completeness of", "check all cases", "verify exhaustiveness", "find logical gaps", "model-check", or "turn into math" any document or proposition. Also trigger on phrases like "does this cover everything?", "are there edge cases?", "is this logically complete?", "formal verification", "case analysis", "decision matrix", or any request to convert prose into formal definitions and check whether the definitions leave unhandled scenarios. If the user uploads a document and asks whether it is "sound", "airtight", "exhaustive", or "covers all possibilities", use this skill. Even partial requests like "formalize section 3" or "what cases does this policy miss?" should trigger it.

Route all AI-agent-generated files, memory, session data, and outputs to Google Drive as the primary persistent storage backend. Trigger on: "save to Drive", "upload to Drive", "store in Drive", "find my file", "resume session", "load my memory", "where did we leave off", "sync to Drive", "persist this", "save my work", or any request to create a durable file. Also trigger when the user mentions "Google Drive", "Drive folder", "my Drive", or references a Drive URL. Trigger proactively when creating any output file — Drive is the default, not the ephemeral local filesystem. If the user says "save", "keep", "store", "remember", or "don't lose this", use this skill. Even "create a report" without specifying where triggers this skill because Drive is the configured default.

Create interactive data exploration experiences with drill-down, cross-filtering, correlation discovery, animated transitions, and responsive layouts. Use this skill whenever the user wants to explore, visualize, or interact with data — dashboards, charts, data stories, KPI monitors, heatmaps, comparison views, funnel or cohort breakdowns. Trigger when the user says "show me the data", "build a dashboard", "visualize trends", "find patterns", "compare metrics", or uploads CSV/JSON/Excel wanting insight. Also trigger for real-time displays, animated charts, interactive filtering, cross-filtering, sparklines, data tables with sorting/search, or any multi-view coordinated visualization. Trigger for AI-powered data analysis where the artifact calls the Anthropic API to interpret patterns or generate narratives. NOT for static one-off charts or pure statistical computation with no visual output.

Portfolio lifecycle management for divergent minds. Processes documents into a patchable knowledge graph of ideas, concepts, projects, and insights. Operations: ingest, extract, review, relate, triage, prune, diagnose, graph. Use when the user mentions: managing ideas, brain dump, idea backlog, "too many ideas", "what should I work on", portfolio review, "what's stale", "find patterns", "what's duplicated", consolidate, "extract ideas from this", "show the graph", mosaic, "process my notes", or uploads portfolio-state.json or documents for idea extraction. Also trigger on "I keep starting things and not finishing" or "I need to get my ideas out of my head".

Convert a raster logo image (PNG, JPG, BMP, WebP) into a high-fidelity SVG vector replica using computer vision, color quantization, and bitmap tracing. Use this skill whenever the user uploads a logo, icon, badge, emblem, wordmark, or any graphic and asks to vectorize it, trace it, convert it to SVG, recreate it as a vector, or make a scalable version. Also trigger when the user says 'turn this image into an SVG', 'make this logo a vector', 'trace this logo', 'SVG version of this', 'vectorize this', 'recreate as vector', 'I need this as an SVG', or anything involving raster-to-vector conversion of a graphic. The skill produces: (1) the SVG file, (2) the Python script that generated it, and (3) an overlay comparison image proving fidelity. Even if the user only says 'make an SVG from this image' without saying 'logo', use this skill — it works on any flat graphic.

Run multi-agent deliberation to decompose problems and converge on solution plans. Four AI agents (Decomposer, Strategist, Critic, Synthesizer) independently propose breakdowns, then iterate through adversarial rounds until convergence. Trigger on: "deliberate on", "multi-agent solve", "agent deliberation", "converge on a solution", "run deliberation", "agent debate", "adversarial planning", "multi-perspective breakdown", "structured problem solving", "break this problem down with agents", "think through X from multiple angles", "give me a real plan not just one take", or any request for multiple independent reasoning perspectives iterating toward a solution plan. Even "think hard about how to solve this" should trigger this skill.

Design sound naming conventions from scratch across all domains—software, system architecture, data models, skills/documentation, and abstract systems. Use this skill whenever the user asks to create, design, establish, or invent naming conventions, naming schemes, naming standards, identifier patterns, or taxonomy systems for any domain. Also use when the user mentions "naming guidelines," "namespace design," "identifier strategy," "labeling system," or "what should we call this thing" in a systematic context. Trigger proactively when a user is building a new system, API, documentation structure, or skill and mentions uncertainty about naming—this skill helps formalize and validate those choices before they scale.

Assess any software artifact — API, codebase, pipeline, system, component, or agentic workflow — for LLM output verification defects using PALS's Law (v1.5.4). Produces a structured audit report and actionable checklist. Applies the 9-class error taxonomy as assessment lens for code and API surfaces, and the 5 architectural corollaries for system-level evaluation. Trigger on "assess", "audit", "review", "evaluate", or "check" any software for LLM safety, verification coverage, or agentic readiness. Also trigger on "PALS assessment", "PALS audit", "PALS's Law", "verification boundary", "LLM output verification", "agentic safety", "hallucination risk", "AI-ready", "silent acceptance", "does this trust LLM output", or any request to evaluate a system's posture toward LLM output trust. Trigger even without the PALS name when the intent is checking whether a system handles LLM unreliability. NOT for evaluating models — for evaluating systems that consume LLM output.

Add print-optimized CSS and a print action button to any HTML or React artifact. Use this skill whenever the user asks to "make printable", "add print", "print version", "print-friendly", "print CSS", "print button", "export to PDF via print", "print layout", "page breaks", "print stylesheet", or any variation of making web content render correctly when sent to a printer or saved as PDF via the browser print dialog. Also trigger when the user creates an HTML/React artifact and mentions printing, paper, A4, Letter, or PDF export. Trigger even for casual phrasing like "I want to print this", "make it printable", "add a print button", or "this needs to look good on paper". If the output is an HTML or React artifact and printing is mentioned at all, use this skill.

Apply the Problem-Space Exploration Framework to transform solution-centric descriptions (app specs, product briefs, feature requests) into rigorous problem-centric analyses. Use this skill whenever the user explicitly requests a problem-space analysis, invokes the framework by name ("problem-space exploration", "PSE framework", "problem-space framework"), or asks to "run the problem-space exploration framework" on a given input. Also trigger when the user says "explore the problem space", "problem-centric analysis", "contamination guard", "problem class declaration", or references specific framework phases (Phase 0–7) by name. Do NOT trigger on general product critique, brainstorming, or spec review unless the user explicitly names this framework.

Synthesize a product briefing from technical specs, market analyses, competitive landscapes, and strategic documents. Output is stakeholder-ready — zero math, zero theory, pure product language. Trigger on: "product brief", "product document", "make this non-technical", "pitch document", "one-pager", "market brief", "what does this actually do", "explain to a business audience", "strip the math out", "product narrative", "go-to-market doc", "positioning document", "executive brief", "investor deck narrative", "partnership brief", "sales enablement doc", "combine these into a product view", "present the product not the theory", or any request to translate formal/technical work into a product-oriented deliverable. Also trigger when multiple technical documents are in context and the user says "make this readable." Default to triggering when intent is ambiguous.

Prevent unreconciled redaction — structural and content decay from multiple revision rounds. Use whenever revising, editing, restructuring, or incorporating feedback into any document or article, especially multi-round feedback merges, adding sections, or any edit touching more than one section. Trigger on "incorporate this feedback", "merge these edits", "revise based on comments", "clean up this draft", "the structure is off", "something reads weird about the flow", or documents with changelogs like "incorporated feedback from rounds 1–N", visible style seams, or redundant treatments of the same concept. If the task substantively modifies an existing document's content or structure, use this skill. Skip for pure copy-editing (typos, grammar only).

Build a source-grounded knowledge base on any subject BEFORE solving, building, or experimenting. Searches for formal information — papers, standards, RFCs, specs, datasets — evaluates source authority via a 5-tier hierarchy, extracts claims with full provenance, identifies gaps and contradictions, and outputs a condensed .md KB. Trigger on: "research this first", "build a knowledge base", "what does the literature say", "gather formal sources", "find papers on", "state of the art", "ground this in evidence", "survey the field", "literature review", "prior art search", "what do we actually know about", "evidence base for", or any request to gather verified information before work begins. Also trigger when combining a problem with "research", "sources", "papers", or "formal". Should run BEFORE experiment-lab, multi-agent-deliberation, or implementation.

Decide whether a task requires code execution + file/command operations (Execution Path), an inline rendered widget/artefact (Artefact Path), or a direct streamed text response (Text Path). Use this skill at the START of every non-trivial response where the right output modality is not immediately obvious. Trigger on any task that involves: producing files, running computations, transforming data, building UIs, making API calls, writing scripts, creating documents - OR on analysis/explanation/design/ advice tasks where it is unclear whether artefacts are needed. Also trigger when the user says things like "create", "build", "generate", "make me", "run", "process", "convert", "fix", "analyse", "explain", "plan", "compare", "show me", or "write". Do NOT skip this skill just because the request feels "simple" - under-routing is the primary failure mode.

Design and produce high-quality, standards-compliant schemas for any domain. Trigger this skill whenever the user asks to "design a schema", "model a domain", "create a data model", "define types", "write interfaces", "build a contract", "create a JSON Schema", "write Zod schemas", "define Protobuf messages", "design a database schema", or any variation of defining the structural contract for entities, fields, types, relationships, and constraints. Also trigger when the user uploads an existing schema and asks for a review, audit, refactor, migration, or evolution plan. Trigger when the user describes a system, product, or feature and wants its data model formalized. Even if the user says something casual like "what should my data look like" or "help me think through the structure", this skill applies. If a schema or data model is being created, evaluated, or evolved — use this skill.

Analyze whether a solution generalizes across a problem class or is ad hoc. Produces a verdict (full / conditional / fragile / ad-hoc) via dependency extraction, parameterization testing, counterexample search, and invariant characterization. Trigger on "does this generalize?", "is this a general solution?", "will this work for all cases?", "is this ad hoc?", "can we extend this?", "is this a one-off?", "what class of problems does this solve?", "when does this break?", "what assumptions does this depend on?", "is this robust?", "does this always work?", "can I reuse this approach?", or any request to assess whether a solution extends beyond its original instance. If the user has a solution and wants to know its scope, use this skill.

Apply the Solution-Space Convergence Framework to transform a completed problem-space analysis (typically output from the Problem-Space Exploration skill) into a justified, auditable solution specification. Use this skill whenever the user explicitly requests a solution-space analysis, invokes the framework by name ("solution-space convergence", "SSC framework", "convergence framework"), or asks to "run SSC" on a given problem analysis. Also trigger when the user says "converge on a solution", "generate and select solution candidates", "run a trade study", "build a concept-selection matrix", "design rationale capture", or references specific framework phases (C0–C7) by name. Do NOT trigger on generic architecture discussion, coding tasks, or ad-hoc trade-off conversation unless the user explicitly names this framework. Requires a prior problem-space analysis as input; if none exists, redirect to the problem-space-exploration skill first.

Analyze any document or business asset and produce a single, fully realized, high-leverage contribution via cross-domain synthesis. Trigger when the user asks "what's the most original contribution you can make?", "what would produce a step-change?", "what's your novel contribution?", "highest leverage addition?", "what single thing would make this dramatically better?", "add the most value you can", "surprise me with something original", "what am I missing?", "what insight would transform this?", "find the gap only you could fill", or provides a document with "make this significantly better" without specifying how. Covers docs, specs, papers, strategies, plans, proposals, memos. Do NOT trigger for editing, proofreading, summarization, or when the user specifies exactly what to add.

Write, review, or improve technical how-to guides — the goal-oriented, step-by-step kind aimed at practitioners who already have baseline knowledge. Use this skill whenever the user asks to "write a how-to", "create a tutorial", "document how to do X", "write a guide for X", "step-by-step instructions for X", "help me write technical documentation", "draft setup instructions", "write an onboarding guide", "create a runbook", "write a migration guide", "document this process", or any request to produce instructional technical content. Also trigger when the user asks to review, critique, restructure, or improve an existing how-to guide, or when they paste a draft how-to and ask for feedback. If the user mentions "Diátaxis", "documentation quadrants", or "how-to vs tutorial vs reference", use this skill. Covers Markdown, HTML, and docx output. Does NOT cover pure API reference docs (use reference-doc patterns instead) or conceptual explainers (those are the "explanation" quadrant, not "how-to").

Transform any document (news, paper, math proof, physics, medical study, legal ruling) into a production-ready animation script — scenes, visuals, narration, style — that a renderer or video pipeline can execute into a complete explainer for young adults. Trigger on: "explain visually", "make an animation of", "video script for", "turn this into an explainer", "animate this", "visual breakdown", "storyboard this", "scene-by-scene", "animation script", "explainer video", "explain like I'm 18", "make this accessible", "visual summary", "animated summary". Also trigger when a user uploads any document and wants it turned into something a general audience can watch and understand. Even partial requests like "script the first 3 minutes" or "storyboard the key insight" should trigger it.