ai literacy / devrel enablement

Run a Live AI Product Demo
like a Founding DevRel Lead

Press S for presenter view · T to switch themes · ← → to navigate

OpenDesign DevRelgithub.com/nexu-io/open-design · 30 min session

agenda

Five things on the agenda

01Why now · Live demos beat recorded ones in AI evaluations~5min

02Workflow map · What a presenter view actually needs to show~6min

03Pilot & risk control · Scripting a session that can't go silent~8min

04Live demo · Running this exact deck in presenter mode~8min

05ROI + rollout plan + Q&A~3min

// part 01 · why now

Buyers stopped trusting canned demos —
they want their own prompt, live.

✅ What buyers expect

A prompt from the room, not a rehearsed script — proof the tool works on a problem they picked, not one we curated.

❌ What kills a demo

Pre-recorded video, no source visible, and no good answer when someone asks "what if I asked it something else?"

💡 The difference

A recorded demo is rehearsed proof. A live one needs you to "know the next line just by glancing at the slide" while the model works.

Let me open with something that might be a little uncomfortable — a recorded product demo and a live one are two completely different disciplines.

Look at the left card. "What buyers expect" now means a prompt pulled from the room, not a pre-loaded example — because a curated demo no longer proves the tool works on a real problem.

The middle card is the trap: a pre-recorded video, no source shown, and the moment someone in the room asks "what if I typed something different," the whole pitch stalls because there's nothing live to fall back on.

The right card is the core idea for the next 25 minutes — presenting live well means you can glance at the slide and know exactly what to say next, while the agent is still generating the file in front of everyone. That's not memorization, and it's not improvisation either — it's a properly designed presenter system.

That's what the rest of this session is about.

// part 02 · workflow map

A live-demo presenter view needs four panels

①

Current slide, large

Takes up over half the view, so you always know exactly what the audience is looking at.

②

Next slide preview

Lets you prep the transition line in advance instead of blanking on "what comes after this."

③

Live script panel

Large type, high contrast, scrollable — this is what the presenter is actually reading mid-demo.

④

Timer + slide count

How long you've talked and how many slides remain — the whole session's pacing runs on this.

A presenter view for a live AI demo needs four panels. I'll rank them by importance.

Panel one, the current slide, large. This has to take over half the view, because it's your sync anchor with the audience — whatever they're looking at has to be exactly what's in your head too.

Panel two, the next slide preview. A lot of people skip this one, so let me explain: the moment a live demo actually stalls isn't mid-sentence, it's the two seconds after you advance the slide. If you already know what's coming, the transition line writes itself.

Panel three, the live script — today's centerpiece, and the next part is entirely about it. One hard requirement up front: large type, high contrast, scrollable. You're only glancing at it out of the corner of your eye while the model generates on screen — small text means you can't read it in time.

Panel four, the timer and slide count. Knowing how long you've talked and how many slides remain is what keeps a live-generation demo from running over.

All four panels are non-negotiable, and this deck ships all four — press S and try it yourself.

// part 03 · pilot & risk control

Pilot format & 3 risk controls

01

Not a rehearsed script — a glance-and-go cue sheet

Bold the core point, isolate transition lines, list the numbers and names — so you can catch the thread with one glance while the model works.

02

150–300 words per slide, never more

Under 150 and the cue isn't enough; over 300 and there's no time to read it live. Pace each slide at 2–3 minutes.

03

Write it spoken, not written

"Therefore" becomes "so"; "the aforementioned approach" becomes "this approach." Read it aloud once — if it sounds stiff, rewrite it.

Now the part that determines whether the pilot is repeatable — how the live script gets written. Three rules.

First, the script is not a script. The moment you read verbatim from notes, the room can tell, and the "this is live" credibility disappears instantly.

Its real job is a glance-and-go cue sheet — bold the core points, isolate the transition lines, list the exact numbers and names. That way you catch the thread with one glance, but what comes out of your mouth is still your own words while the model generates on screen.

Second, keep each slide to 150–300 words. That's the range that survived a dozen live sessions. Under 150 and you stall mid-sentence; over 300 and you can't scan it in time. At 2–3 minutes per slide, that word count is exactly right.

Third, write it the way you'd actually say it. This is where most people trip up — write "therefore" and it comes out "so"; write "the aforementioned approach" and it comes out "this approach." Read it aloud once before the session; if it's stiff, rewrite it.

Put those three together and a live AI demo stops being a high-wire act.

// part 04-05 · roi + rollout

The numbers that get this funded

# Get OpenDesign (macOS / Windows · Apache-2.0)
open https://github.com/nexu-io/open-design

# 60K+ Stars · 300+ Contributors · 217+ Plugins · 129 Design Systems
# Cost per live session: $0 in API fees when run BYOK on the presenter's own key

# Keyboard shortcuts for this deck (presenter-mode demo)
S  → open presenter view
T  → switch theme (5 presets)
← → → navigate slides
R  → reset timer
    

Rollout: 1 pilot session this week → 4 DevRel reps trained next sprint → weekly cadence.

Last part — the numbers and rollout plan, so you can run this yourselves without figuring it out from scratch.

OpenDesign is Apache-2.0, no sign-up, BYOK — which matters for ROI, since a live demo session costs nothing beyond the presenter's own API key. Community context: 60K+ stars, 300+ contributors, 217+ Plugins, 129 Design Systems — this is not a tool the prospect has never heard of.

The shortcuts are listed here — the exact ones I use live: S for presenter view, T to switch themes, arrows to navigate, R to reset the timer. Five themes ship by default — tokyo-night, dracula, catppuccin-mocha, nord, corporate-clean — covering a dark technical room and a bright executive briefing alike.

The one non-negotiable step — every slide's <aside class="notes"> gets an honest 150–300 word live script. That's the actual deliverable of this whole method. AI can draft it, but you read it aloud yourself before the session to confirm it sounds like you talking.

Rollout plan: one pilot session this week, four DevRel reps trained on the format next sprint, then a weekly cadence against the pipeline. That's the ask. Thanks everyone — questions, go.

Run a Live AI Product Demolike a Founding DevRel Lead