# I didn't make these slides. I spoke them.

> [See the demo](https://combabulating.com/spoken_slides/demo.mp4)

## Damn, I got a presentation next week

You open a blank presentation. White slide, placeholder title. You stare at it.
Nothing. Doesn’t feel very productive.
So you close it and start writing instead. The argument, the story, the thing you actually want to say. That flows. That feels right. You can almost hear yourself saying it out loud.
And you haven't started the slides yet. There’s still time, you’ll do it later..

## What if I didn’t?

Well, later is now. The slides still don't exist, do they?
You have the argument. You know what you want to say. Now you're supposed to take that and break it apart. Freeze it into moments, shrink it into bullets, repeat yourself in text so it fits on a rectangle. Go looking for nice photos then fight fonts and colors for another 2 hours because ’slides have to be professional’.

Why? Are you hiding behind your slides? Are they presenting or are you?
I'm not making the anti-slides case yet. I want to show you something first.

## What I built (instead of slides)

Picture this, you walk on stage, behind you is an empty slide, you talk, like you normally would, you start presenting and your background reacts, the slide starts building itself. NOT a transcript, building itself live semantically, understanding your meaning, highlighting your data, organizing, structuring so it supports you not duplicates you.
**Next slide**
And what if it listened to your commands, you can navigate your slides like a conversation, ’next slide’, ’slide 4’, ‘returning’, you talk, it listens and reacts.

This is what I built.
It sounds too good to be true. Because it is, so let me rephrase, this is what I *tried* to build, and to some extent succeeded.
My demo works, it can do all the things I listed earlier, but with some catches - talk too fast, it lags behind you, talk too slow, it jumps to conclusions too quickly, talk not so clearly, well, it gets messy.

Despite its shortcomings, I think if we look at it as a glance into a future where it will actually work consistently, we can discover something.

## Geeking out

But first, beauty is in the details, so if you are not technical, feel free to skip this paragraph. I will dive a bit deeper into the specifics of the system, how it works, and what tradeoffs I had to make.

The prototype is a tiny macOS app in SwiftUI. Left side: 16:9 slide preview, a strip of generated slides, a mic button. Right side: transcript, raw model responses, queue status. Closer to a debugger for a live conversation than a presentation tool really.

Speech goes through Apple's new SpeechAnalyzer. Why? Fast, on-device, accurate, gives partial chunks and corrects itself on the run. Perfect.
However, partial text is great for showing "yes, it hears me.” Not so great for building slides, it keeps changing under your feet. So, naturally it was up to me to decide when to send a request (unless I wanted to send 45 requests for 60 seconds - which I did do and wasn’t very cheap).

The app has a small parser: terminal punctuation, command phrases like "next slide", word count, pauses. Using these and some set heuristics it gets 85% the way there, certainly good enough for a demo. Then, each chunk goes into a serial queue. One model call at a time. Concurrent calls get weird fast.

I used GPT-oss via OpenRouter, cost was a factor in this decision, but even more so, was it’s sheer speed. Hundreds of tokens per second, if all fell right it actually felt real-time enough to not be any lag between it and a fast speaker.

Updates are non-destructive on purpose. Append a subtitle, add bullets, the model never rewrites. Wrong layout? Start a new slide. This is more psychological than technical, we don’t notice mistakes as often if they don’t start flickering before our eyes. This way, new slide, new ideas, chances are when you look, it looks right, not rewriting itself on the fly to cover up.

Then, there’s navigation, the small local parser detects some navigation words so it can send the command right away (works about 50% of the time), model interprets and sends back the event.

Lastly, there’s the renderer. It’s practically a toy. SwiftUI draws templates directly from a local struct. Fast both for the app to show and the model to work with. 

This is all the magic.

### Where it falls apart

Now you might be thinking ‘wow, amazing, now ship it in Lantr’. Yeah…about that.

Latency is the biggest failure. Recognizer stabilizes, chunking decides, model call goes out, response parses, UI updates. Each step is fine, individually. Even together, until you start speaking fast, or your network glitches for one second. One. And it’s enough to break the magic. The moment you pivoted and it didn’t, you navigated and it didn’t, it's uncanny and frankly a bit embarrassing. 

The opposite is just as bad. Pause for drama, breathe mid-thought and bam: the app decides you're done. A slide appears for a sentence you hadn't finished yet. My strangest realization was: this doesn't only need intelligence. It needs manners.

Speech recognition leaks directly into quality. A missed negation, a dropped noun, a command phrase heard inside normal speech. The agent acts on whatever text it receives. And it may not even be the recognizer’s fault: loud environments, weird accents, weird words, you name it. There are now two probabilistic systems in a chain.

The non-destructive rule helps trust but hurts flexibility. Live thinking is messy. Sometimes the right slide would merge two, rename the title, reorder the bullets. This prototype can't. Append or start over.

And the visual layer is a demo, not a product. This proves the loop can feel magical for a few seconds. It doesn't prove it's ready for a real keynote.

## So, what now?

By now you may be impressed, or you may feel I oversold it. Either way, the same question sits on the table: what does it really mean?
Is this the future of presentations?
I think the past answers that better than I can.

### Stories were always spoken

Stories predate writing by thousands of years. They were spoken around fires, memorized, performed. Writing came later, as a record, not the source. Slides came even later, as a support, not the point.

Somewhere along the way, the support became the thing. The record became the presentation. We started building first and speaking second.
This experiment accidentally ran it in reverse. Is that a return to something, or just a broken prototype? Probably both.

### The following of a broken experiment

A challenge towards the fixed format of the last 40 years. When and why have we decided that a slide is the right atomic unit? What could a mix of this technology, live slides and frozen slides, look like? I don’t know yet.

But one thing is certain.

## Curtains pull

I walk on stage, I look at the frozen text behind me, it doesn’t aid, it doesn’t match what I have in mind now. I take the remote, point it at the projector and turn it off. And I speak.
Presentations have not changed, yet. Maybe they should.