Files

meels 1361dd76f9 chore: move the webinar script and plan into raw/notes

They are webinar deliverables rather than sources to ingest.

2026-07-28 19:00:02 +02:00

17 KiB

Raw Permalink Blame History

#webinar #ai #plan

Webinar Plan — From Chat Box to Your Own OS

How regular people (non-engineers) can benefit from using Claude Desktop as their daily assistant — and how it stops being an app you open and becomes an operating system fine-tuned for you.

Audience: Business professionals / knowledge workers (managers, marketers, consultants, HR, analysts) Format: Short inspire talk — ~30 min + Q&A Goal: Move the audience along one perspective shift — from "a chat box I open" → "a teammate that works for me" → "a personal operating system fine-tuned to how I work." No coding required. Language: English Structure: The Evolution of LLMs is the spine of the entire talk. We tease the destination up front, then walk the timeline from 2023 forward. Every step adds one capability (with an animation showing what it now lets you do) and moves the human–AI relationship one rung — ending at a personal OS. Mindset shift, Claude Desktop, and the demo all hang off steps of the journey.

The through-line: an app you open (a stranger) → a doer → it's yours → a real teammate → it knows you → an always-on OS → your own OS, fine-tuned to you.

Animation note: Each evolution step gets a short animation showing the new capability. Not building these now — [ANIMATION] marks where they go.

The Arc at a Glance

#	Segment	Time	Purpose
1	Cold open — the teaser	3 min	Where everyone lives (2023) → flash-forward to the destination → "but let's see how we get there"
2	The Journey: Evolution of LLMs (the spine)	~16 min	Six stations; each adds a capability `[ANIMATION]` and moves the relationship one rung
3	Arrival — Insights Collector demo	5 min	Today's reality: the teased destination, in full
4	Next — an OS fine-tuned to you	2 min	Lift beyond today: it learns you; the "market of one"
5	Do this tonight	3 min	Walk in a week what took the industry three years
6	Close	1 min	Callback + the irreversible-gap line
—	Q&A	—	—

Total content: ~30 min.

1. Cold open — the teaser (3 min)

Tease the whole journey: start where everyone already is, flash-forward to where we're going, then pull back.

Entry speech + boot-up (the cold open). A short spoken intro (who you are, what this is, ~30–60s) — then "power on the operating system." Run the boot-sequence slide (mockups/start-boot.html): power button → CRT flash → themed Linux boot log whose modules foreshadow the entire talk (chatbox.ko → react_agent → tool-calls → skills-curator → reached target Your-Own-OS) → the title reveals. This is the title moment and locks in the game/OS frame from second one.
Start in 2023 — the chat box. The familiar starting point: ask a question, get an answer. No memory, no tools, one-shot. [screenshot or tiny live Q&A] — "This is an app you open. It's where almost everyone still lives."
Flash-forward to the destination. Cut to the Insights Collector output — [screenshots of the structured interview-conclusions notes]. "This talk was researched and organized by an AI working next to me — not something I opened and asked, but a system that runs the way I work. I didn't write a word of this."
The pull-back hook. "But I'm getting ahead of myself. How do we get from an app you open... to a personal operating system that works like you do? Let me take you on the three-year journey — and by the end you'll know exactly how to walk it yourself." (Reassure: "No engineering. A laptop and your real work is all you need.")

2. The Journey: Evolution of LLMs — the spine (~16 min)

Retell the technical timeline (from the git-skills talk) as "what could it do for you?" Each station: capability → animation → the rung of the relationship.

Station	Capability unlocked	`[ANIMATION]` shows	Relationship rung
2023 — Answer machine	Ask → answer	(established in opener)	An app you open · a stranger
Late 2023 — It learned to act	ReAct / tools: take an action, see the result, adjust	The loop: question → tool → result → better answer	Stranger → doer
2024 — It reads your world	RAG / connectors: it reads your docs, email, data	Pointing Claude at your files & inbox	Generic → yours
Late 2025 — The great simplification	One capable assistant, huge variety, on your computer	Many task types, one assistant	Toy contraptions → real teammate
2025 → Skills = memory	Reusable skills + your personal data; remembers who you are	Skill folders + "who I am" docs feeding in	Teammate → knows you
Now (2026) — It runs around you	Proactive, scheduled, always on	A morning brief appearing overnight	Tool I open → an always-on OS

Beat-by-beat:

2023 — Answer machine (~1 min, recap from opener). A smart stranger you meet fresh every time. Great knowledge, but forgets you and can't do anything.
Late 2023 — It learned to act (~3 min). It can take an action, see what happened, and adjust — the "agent loop." Look things up, use a calculator, call a service. [ANIMATION: the loop]
2024 — It reads your world (~3 min). It reads your documents and data, not just its training. Now the answers are about your work, not the average of the internet. [ANIMATION: pointing at your files]
Late 2025 — The great simplification (~3 min). Engineers over-built for a while; turns out one capable assistant with a few simple abilities handles enormous variety. Claude Desktop enters here as the concrete embodiment — the assistant that lives on your computer, reads local files, connects to Gmail/Calendar/Drive. [ANIMATION: one assistant, many tasks]
2025 → Skills = memory (~3 min). It holds reusable skills (a folder + a plain-text note — no code; Claude can build them; portable to other tools) alongside your context docs (the "who I am" files). It stops being stateless and starts sounding like you. [ANIMATION: skills + context feeding in]
Now (2026) — It runs around you (~3 min). Proactive, scheduled — a brief waiting for you in the morning. You stop opening it; it runs in the background of your day. This is where the mindset shift crystallizes into the OS metaphor: intern → teammate; a tool I open → an operating system running for me; a clever prompt → context about who I am. Winners keep judgment and agency; losers offload it. "It's an investment, not a cost" — one hour → ~3 hrs/week saved. [ANIMATION: overnight brief]

Transition to the demo: "We've arrived at today. You now understand every capability behind the thing I teased at the start. Let me show you the whole of it."

3. Arrival — Insights Collector demo (5 min) ⭐

The teaser pays off — today's reality, now that they understand every capability behind it.

Callback: "Remember those notes from the first minute? Here's how they were made."

The universal problem: hours of meetings, calls, webinars, and podcasts you never mine for value.

The pipeline (shown simply):

Record the conversation (e.g., the Sebastian interview).
Claude transcribes it (Whisper) and separates who said what (speaker diarization).
Claude reads the raw transcript and distills it into a structured insight note: executive summary, key themes, tensions, memorable quotes, actionable takeaways.
All notes live together in a searchable knowledge base (Obsidian) — a skill + your data.

Show the real artifact in depth: the Sebastian interview conclusions note. "I recorded a 56-minute chat and got this."

Meta-punchline: "Three of the biggest ideas in this talk — the evolution timeline, the mindset shift, the irreversible gap — came straight out of these notes. The assistant did the research; I did the judgment."

(optional) Ask across everything: "what did everyone agree on about non-engineers using AI?" — it synthesizes across notes. (Sebastian: "you can put your whole life into a RAG.")

Land it on them: "Every meeting and interview you sit in could be a searchable, structured asset instead of a vague memory. This isn't an app you opened — it's a system running the way you work."

4. Next — an OS fine-tuned to you (2 min)

Lift beyond today. This is what makes "fine-tuned for you" literal — and the reason to start now.

Say the gloss out loud first (don't assume they know the term): "Fine-tuned just means shaped around you — it takes in your voice, your goals, your data and adjusts until it works the way you work, not the way the average person does. Think of breaking in a pair of boots until they fit only your feet."

Today you fine-tune it by hand: your context docs, your skills, your data shape it into yours.
Next it fine-tunes itself — by watching how you work. Allie's example: Claude observes her hiring calls for months, notices she keeps favoring higher-risk / higher-payoff candidates, and updates its own decision framework to match her judgment. Not a memory trick — the system actually adapts to you.
The "market of one": every person ends up with their own AI OS; tools and even websites render themselves for you (Nike shows Allie the dark-green shoe because it knows her).
The point: it stops being a product everyone shares and becomes an operating system fine-tuned to exactly one person — you. Side effect: real human relationships get more valuable, because everything else is mediated by proxies.

5. Do this tonight (3 min)

The industry took three years to walk this path. You can walk it in a week.

One hour. Let Claude interview you and build your 3 foundation docs — who you are · your goals · your role/business. Say "ask me questions before you start."
Pick your #1 recurring annoyance and let Claude propose a skill for it ("just complain").
Use Claude Desktop, not just the chat box — point it at one real file this week.

6. Close (1 min)

Callback to the journey: "We started with a chat box you open and ended with an operating system fine-tuned to you. The whole industry took three years. You just watched the map."
The gap, in one sentence: the person who sets up their OS this week won't just be more productive — they'll have less fear of every new release, because each new capability slots into a system they already understand and that already knows them.
Final line: "You don't need to be an engineer. You need a laptop, one hour, and your real work. Start building your OS tonight." → Q&A.

Open follow-ups (decide before building slides)

HR-contacts search as a fast second demo at the "reads your world" (2024) station — "you already have the right candidates/clients in your contacts, you just can't see them." Ready dataset exists (HR Contacts.md). Trade-off: adds wow but tightens timing and leans recruiter-specific.
"Become your own boss" thread (Ideas for webinar.md) — could color the "real teammate" station for an entrepreneur-leaning crowd.
"Connections are everything" (Sebastian) — pairs naturally with the "market of one" beat (§4: human relationships get more valuable). Could be a closing note or a Q&A talking point.
Animations — one per station. Update: likely become the interactive mini-games below rather than pre-rendered clips — see Visual system & interactive concept.

Visual system & interactive concept (production track)

Mockups: working design mockups live in [[mockups/README|mockups/]] — intro, style-directions, demo-slides, and the interactive mini-games (the four levels). Double-click any to open in a browser.

Decisions so far

Build: Web / WebGL (Three.js + GLSL shaders); auto-playing animations, browser full-screen; can render to video as a fallback.
Aesthetic: TRON-flavored. Leaning toward a hybrid of Cyber-terminal (C) + Holo-HUD (D) — Holo-HUD as the world/frame that carries the "game / levels" metaphor (level rail 0X / 07, glass panels, corner brackets, gauges), Cyber-terminal for every interaction moment (chat, commands, the demo). Pure-C and pure-D remain viable; final call pending.
The per-station animations become the interactive mini-games below (upgrade from pre-rendered placeholders).

Phase 2 — live terminal via OpenRouter

Wire the on-screen terminal to a real model through OpenRouter (OpenAI-compatible, token streaming). The typewriter becomes real streaming.
Key handling: a tiny local proxy holds the API key (avoids exposing it in the browser + dodges CORS). Page → localhost proxy → OpenRouter.
Stage safety: on-rails prompts (keypress-triggered) with cached fallback responses; low temperature; deterministic stubs where an exact outcome matters. Never a naked live call.
Bonus: fire the same prompt at an old vs new model live — direct proof of the "evolution" spine.
Scope caveat: OpenRouter covers the chat/reasoning only. The full Insights Collector pipeline (Whisper transcribe + speaker diarization + file writes) is real tooling — pre-bake or record that part.

Big idea — one mini-game per concept (interactive "levels")

Each evolution rung = a self-contained HTML page that behaves like that generation of AI. Shared stage: a weather-in-Kyiv widget + a playing field with a movable block. Same user request every time — "move the block down if Kyiv is below 20°C" — solved differently as capability grows:

Level 1 · Chatbox — no tools, no live data. It can only talk: asks you for the weather, then tells you to move the block manually. (System prompt hard-constrains a modern model to 2023 behavior so it doesn't cheat.)
Level 2 · ReAct — the model emits a text protocol (Thought → Action → Observation). The page parses it, fetches the weather, feeds the observation back, the model decides, the page moves the block. Glow/pulse effects wrap each ReAct message to teach the loop.
Level 3 · Tool calls — same scenario via native function-calling (get_weather, move_block as tool schemas). Show the structured tool_calls JSON to contrast with ReAct's text parsing.
Level 4 · Skills — the punchline. Instead of re-explaining the task each time, save a skill ("weather-based-movement"). After a page refresh, just say "do a weather-based movement" — the model loads the skill and executes. Demonstrates two-stage loading: short description always in context → full body loaded on demand.

Note: the mini-game order (chatbox → ReAct → tools → skills) is a tool/skill-centric sub-progression; may refine or align the middle stations of the evolution spine.

In-browser skill system (feasible)

A skill = a small record: name, short description (the trigger), long body (the steps + which tools it uses). Faithful to "a skill is a folder + a note."
On load: inject only skill descriptions into the system prompt (progressive disclosure). Model calls load_skill(name) → harness injects the full body → model executes. save_skill(name, description, body) creates new ones.
Storage: localStorage / IndexedDB for pure-browser; or write real SKILL.md files via the local proxy (more faithful and more impressive — "it just created a file").
Effectively a tiny agent harness in the browser — a meta-demonstration of the whole talk.

Engineering caveats (shared)

Constrain each level with a system prompt so a capable model acts its age.
Tool-calling levels need a tools-capable model — pin exact model IDs against current OpenRouter docs at build time.
Prefer a deterministic weather stub (fixed value) on stage; real weather API optional.
Build shared components once (widget, field, block, message log, effects); per level, swap only the "brain" wiring.
Reliability: cached fallbacks, low temperature, no naked live calls.

Source material map

Evolution timeline (the spine) → Скиллы на базе git — новая память AI-агентов.md (Parts 1 & 3), simplified per station.
Mindset shift, OS framing, foundation docs, "just complain," the gap, self-learning / market-of-one (§4) → In 1 Year, the Gap Between AI Users and Everyone Else Will Be Irreversible.md.
Insights Collector demo artifacts, "RAG your whole life," ownership, connections (§4) → sebastian interview - conclusions and insights.md + the other processed notes in this folder.
Demo dataset → HR Contacts.md.

Plan created 2026-07-07 · reframed destination: teammate → personal OS fine-tuned for you

17 KiB Raw Permalink Blame History Unescape Escape