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

They are webinar deliverables rather than sources to ingest.
This commit is contained in:
meels
2026-07-28 19:00:02 +02:00
parent ef2e2bd14f
commit 1361dd76f9
5 changed files with 423 additions and 494 deletions

View File

@@ -0,0 +1,182 @@
#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 humanAI 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.*
0. **Entry speech + boot-up (the cold open).** A short spoken intro (who you are, what this is, ~3060s) — *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.
1. **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."
2. **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."
3. **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):**
1. **Record** the conversation (e.g., the Sebastian interview).
2. Claude **transcribes** it (Whisper) and separates *who said what* (speaker diarization).
3. Claude reads the raw transcript and **distills** it into a structured insight note: executive summary, key themes, tensions, memorable quotes, actionable takeaways.
4. 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.*
1. **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."
2. **Pick your #1 recurring annoyance** and let Claude propose a skill for it ("just complain").
3. **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*

617
raw/notes/Webinar script.md Normal file
View File

@@ -0,0 +1,617 @@
_ideas: disclamer,
it's, essentially, the same demo, just with extended set of tools.
your harnes is unique to you and adapdet to your own workflow_
# Intro
So... Let's start!
{Press start button}
---
I've always had a passion for building internal tools.
Tools that make one person's life at a company a little easier.
They cut stress here and there...
Maybe they only save five minutes a day.
No one would invest in that.
But for that one person, those could be the most stressful five minutes of their day.
Take them away, and they're happier...
...and more productive.
Back then, I'd burn whole weekends to help someone.
Myself included.
But today, things have changed...
---
We all know ChatGPT.
But what we know about it is differ from person to person.
Some says that "it just predicts the next token".
The others: "it is so capable that it will replace all jobs in nearest future"
Somehow both statements are right and wrong at the same time.
I've prepared a small journey for you.
This journey will show you how the same simple task could be done with AI as it evolved over time.
And how you can come from **Chat box** to your own **Agentic Operating System**
# Mail from boss
So, let's imagine that you are working in an office and it's a beginning of your work day.
You are dreaming for the next vacation while there is a new mail from your boss.
{Open and read email}
You've got yourself a new assignment!
But, before go full in on this, you remember that you've heard about AI that can help people a lot in their work.
So you deciding to give it a shot.
# Chat box
It's autumn of 2022. ChatGPT is on hype. Everyone talking about it. So it's your way to go.
You open the chatbox and typing.
"I've got this mail from my boss! what should i do? {paste mail text}"
{Chatbox gives answer}
Pretty good instructions, i would say.
AI knows about your environment and now about your task. So it can help you to compete it.
{Following AI instructions}
Task is complete. You are happy. Boss is happy.
Let's see what allowed AI to be so helpful for us.
{Open system prompt}
Each AI model has a system prompt that shapes it's behavior.
And this is exactly what we see here.
This is essentially an instruction on how to interact with our toy system.
And AI works like an advanced search engine.
It works great with
Now you just need to check on weather and do this routine till your next vacation.
AI just can't help you more. You've got the knowledge that you need. That's it.
Essentially, that is google on steroids or interactive instruction to your product, but nothing more.
Researchers of the time realized this fairly quickly.
There just should be a way to make AI to do something useful.
Allow AI to act.
# ReAct
in the same autumn of 2022. ReAct technique was released.
Let's imagine that you have received this task from your boss a bit later.
And now programmers of your company integrated ReAct technique into your AI chat.
So what this means for you?
AI can act now!
let's see how it would react on the same prompt.
{use the same prompt}
AI does the job for you now!
This opened the door to some possibilities.
AI can work with information from the real world, not only from instruction.
But this technique was highly experimental and hard to use.
It required a lot of effort to add new functionality to model.
AI models were glitching, hallucinating, writing answers themselves...
But the direction was set.
This was highly usable.
let's see what allowed us to teach ai to do something useful
{show system prompt}
# Tools
in summer of 2023 GPT-4 made tool definition as standard
models were trained with this definition in mind, so it became native for them.
programmers now could add functions to models the same way as they could do it in code
models could have a variety of tools for low price of adding them
so now it's even easier to integrate AI into everything
here i want to introduce a new term: Harness.
you've, probably, heard about it.
Harness is a set of tools and techniques that are built around AI model.
lot of SaaS startups working like this
just make a harness, connect to OpenAI api, take your profit
_todo: here i would need some examples of saas startups_
now, when we can integrate AI into more things, let's see how our work day is going
"check if there is new mail from Marcus and do what he wants"
{AI does something}
now AI has access to mail
and we don't even need to describe the task by ourselves
AI just reads it and does it
Imagine that that there is Jira ticket instead of mail
And you have task automation
"But what if AI has a question? What if the task is not clear?" - i hear you ask
{ask AI to write answer to the boss}
it can update and re-assign tickets in the same way
and the coolest thing is that, thanks to MCP servers, programmer needs less than an hour to add connection to any datasource
let's get back to our task
if we start a new session, AI would still know nothing about us.
Let's check it.
# Memory
{close the terminal, open a fresh one}
"do what Marcus asked"
{AI has no idea who Marcus is}
And... it's a stranger again.
Everything we built up in that conversation — gone.
Here's the uncomfortable truth about AI models: they never remember anything.
The model's entire world is the current conversation.
Close the window — and that world is erased.
Every session, you meet the same brilliant amnesiac.
For a chatbot, that's annoying.
For a coworker, that's a deal-breaker.
You wouldn't re-onboard a new employee from zero every single morning.
So the fix had to come. And it turned out to be almost funny in its simplicity.
A notebook.
{open the Memory level}
We give AI one more tool — a notebook it can write in.
And one standing rule: if you learn something worth keeping — write it down *before* you answer.
Let's watch it work.
"From now on: when Kyiv is below 20 degrees, the cube goes to the top shelf. Above 20 — bottom shelf."
{AI saves a note, then does the task}
Notice — before doing the job, it quietly made a note.
Now, the moment of truth.
{close the terminal — session destroyed — open a new one}
New session. Blank conversation. Yesterday this meant total amnesia.
"Check the weather at my place"
{AI checks the weather and moves the cube}
It knows.
No explanation needed. The knowledge survived the session.
Want to see the magic trick?
{show system prompt}
There is no magic.
When a session starts, the harness simply pastes the notebook into the system prompt.
And the notebook itself?
{show memory.md on disk}
A text file. Sitting on my computer.
A text file I never wrote. AI maintains it itself.
There's a second notebook too — about *me*.
{show user.md — "The user lives in Kyiv"}
So I don't even have to say "Kyiv" anymore. "Check the weather at my place" is enough.
This is the moment AI stops being a tool you operate...
...and starts being a teammate.
Because a teammate remembers agreements. Remembers your preferences. Remembers *you*.
But look closer at that notebook.
It's tiny. On purpose.
Everything in it gets loaded into every single session — needed or not.
Facts about you fit fine.
But whole procedures? Step-by-step workflows?
Write all of those down, and the notebook becomes a phone book the AI must re-read every morning.
What we need is memory that stays on the shelf...
...and comes down only at the exact moment it's needed.
That's the next stop.
# Skills
in autumn of 2025, the industry landed on an answer.
And once again, it's funny in its simplicity.
A folder with a text note in it.
They called it a skill.
Let me show you why this changes everything.
{open the Skills level — the shelf is empty}
Let's do our morning routine. But this time, I'll walk AI through it step by step.
"check the weather in Kyiv"
{AI checks the weather}
"the rule is: below 20 — top shelf, above 20 — bottom shelf. it's below right now, so move it to the top"
{AI moves the cube}
Job done. Nothing new so far.
But notice who did the thinking.
Me. I was the recipe.
The procedure lived in my head, and I dictated it, step by step.
Do this every morning — and *I'm* the bottleneck again.
So now, the one sentence that changes the game:
"save what we just did as a skill"
{AI writes the skill}
Let's look at what it created.
{show SKILL.md on disk}
A folder. Inside — one markdown note.
A name. A one-line description of *when* to use it.
And the steps we just walked through — written down as a recipe.
No code. Plain human language. My procedure, on paper.
Now watch.
{close the terminal, open a fresh one}
New session. Total amnesiac, remember?
"do the weather-based movement"
{AI loads the skill and runs it — weather, cube, done}
One line.
No briefing. No step-by-step. No me-being-the-recipe.
It found the skill on the shelf, read the recipe, and did the job.
And here's the clever part — the part the notebook couldn't do.
{show system prompt}
Look what's actually loaded: just the name and one line of description.
The full recipe stays on disk...
...until the exact moment it's needed.
That's why you can have ten skills. A hundred. Hundreds.
The shelf can be huge — the desk stays clean.
And remember: a skill is just a file.
You can read it. Fix it. Improve it.
You can send it to a colleague — and now *their* AI knows your procedure.
You can take it to a different AI tool tomorrow. It's plain text. It travels.
Your experience is no longer locked in your head — or in one chat window.
Memory made AI a teammate who knows *you*.
Skills make it a teammate with *experience* — one who knows how the job is done.
But one thing still bothers me.
Marcus said: "continuously — don't let it drift."
And every single run still starts the same way...
...with me. Typing.
The AI has the knowledge. It has the skill.
But I'm still the alarm clock.
What if we could remove even that?
# Process
it's 2026 now. and this is where we finally arrive.
{open the Process level}
This window looks like all the others.
But it's not a chat anymore. It's a *shell*.
And the AI behind it is not an assistant. It's a process manager.
Watch what happens when I give it — not a task...
...but a goal.
"keep the cube on the right shelf: below 20 — top, above 20 — bottom. continuously."
{AI spawns a process — "started process 1"}
Look at the answer.
It didn't do the task.
It started a *process*. With a process id. Like a real operating system would.
And now — the most important moment of the whole journey.
I take my hands off the keyboard.
{step away; heartbeat lines tick every few seconds}
Every few seconds — a heartbeat.
Check the weather. Compare. Decide. Hold.
Nobody is typing. It just... runs.
Let's make the world change.
{drag the weather Override slider across 20°}
{the cube moves by itself}
There.
The temperature crossed the line — and the cube moved.
No prompt. No click. No me.
And it stays manageable, like any process:
"what's running?"
{ps-style table of processes}
"stop process 1"
{process killed}
Spawn. List. Kill.
Where have you heard those words before?
That's how an operating system talks about its programs.
Now — the reveal. What actually happened when I typed that goal?
{show the prompt the shell wrote for the worker}
The AI wrote... a prompt.
For another AI.
It authored the worker's instructions — like a manager writing a job description — and launched it.
AI managing AI. And you? You just state the goal.
Remember what Marcus asked for? "Continuously. Don't let it drift."
Handled.
I haven't touched the keyboard in two minutes.
You can finally get back to dreaming about that vacation.
But... one thing still feels unfinished.
Look at this window. It's still a terminal.
I still had to *type* the goal. To talk to it the way a programmer talks to a shell.
Most people never will.
What if this whole routine could stop being a conversation at all...
...and become a tool? A small one. Made for exactly one person.
# OS
{open the OS app}
Look at this window.
No chat box. No blinking cursor. Nothing to type.
A status bar. One button: "Check temperature in Kyiv". One checkbox: "Do every 5 seconds".
That's the whole interface.
{click the button}
{AI checks the weather, the cube slides to the right shelf, the status bar shows its one-line report}
One click.
The agent checked the weather, applied Marcus's rule, placed the cube — and reported back in one line.
But wait. Where did the rule go? I never typed it.
It's baked in. This app was *built* around Marcus's instruction.
The prompt was written once — and disappeared behind a button.
{tick "Do every 5 seconds"}
And now it's not even a button anymore.
{drag the Override slider across 20° — the cube crosses on its own; the status bar updates}
It's an appliance. It just... works.
Notice what disappeared along the way.
The conversation.
There's still a full AI agent in there — same model, same tools, reasoning on every tick.
But you don't chat with it anymore.
You click it. You tick it. You close it.
You interact with it the way you interact with any other program on your computer.
The agent became... a program.
A tiny program that does exactly one job. For exactly one person. You.
Remember where we started tonight?
I told you I used to burn whole weekends building little tools like this.
Tools that save one person five stressful minutes a day.
This one took 10 minutes.
And I didn't write it — I *asked* for it.
That's the last step of the ladder.
The chat box didn't just get smarter.
It dissolved — into the operating system.
Into little tools you make for yourself.
---
And here's the secret of tonight's whole journey.
The model never changed.
Chat box, ReAct, tools, memory, skills, processes — even that button — behind every level, the *same* AI model.
What changed was everything around it.
The tools it can reach. The notebook it keeps. The skills on its shelf. The processes it runs. The buttons it hides behind.
That's the harness. And the harness is the whole difference...
...between a stranger in a chat box and an operating system that works while you don't.
And here's the part that matters for *you*:
nobody can sell you this off the shelf.
Because the harness is built from *your* mail, *your* rules, *your* procedures, *your* routine.
It grows out of the way you already work.
Your harness is unique to you.
You don't buy it. You build it — one small tool at a time.
We started this journey by pasting an email into a chat box.
We're ending it with a button that already knows what the email said.
From a chat box... to your own Agentic Operating System.
# Notes
- push yourself up the management chain
- terminal, MS office is skeuomorphism
Andrej Karpathy
This is a new paradigm for interacting with Claude that is significantly more "inline" with all the other human activity org-wide. Once you do all of the under the hood engineering work to make this "just work" (e.g. across tools, integrations, compute environments, memory, security, etc.), Claude basically joins the team in a seamless way - you can talk to it as you would talk to a person and it can help with a very large variety of workloads. Imo this is the 3rd major redesign of LLM UIUX. The first paradigm was that the LLM is a website you go to, the second was that it is an app you download to your computer. This third one is that it is a self-contained, persistent, asynchronous entity with org-wide tools and context, working alongside teams of humans. It really takes a while to wrap your head around it, but it works and it is awesome.