The 15-Minute AI Intro
**Total runtime:** ~20 min talk + 5 min Q&A
**Format:** Script (read aloud) + Cheat Sheet (glance only)
---
PART 1 — THE SCRIPT (read this aloud)
---
🎬 Section 1 — The Setup *(2 min)*
> "Let me give you a 15-minute picture of where software has been, where it is now, and why it matters.
> For the last 30 years — basically since the internet became a thing — we depended on companies like Google, Microsoft, Oracle, and thousands of smaller ones to build man-made processes and automations. Everything you've ever used at work — your email, your accounting software, your bank's website, your hospital records, the airline booking system — all of it was built on an architecture of HTML, PHP, Java, Python, SQL.
> That whole world has one thing in common: **no reasoning**. The machine doesn't think. A human writes the rules, the machine just follows them. Every time. Forever. The same way."
---
🏛️ Section 2 — The Old Stack *(3 min)*
> "Let me break that old world into two layers, because we'll come back to this.
> **Layer one — storage.** How we kept data. SQL databases, Oracle, Excel sheets, CSV files. Rows and columns. Structured. Like a giant filing cabinet — neat, predictable, but only useful if you knew exactly which drawer to open.
> **Layer two — logic and code.** How we made things happen. Java, Python, HTML, PHP. A developer would sit down and write: 'IF the user clicks here, THEN show this. IF the form has this field empty, THEN show an error.' Pure rules. Pure instructions.
> The pattern of the entire old world is one sentence: **humans write the rules, machines execute them.**
> That's the whole game from 1995 to roughly 2020. Brilliant systems were built this way — but none of them could think. They could only follow."
---
⚡ Section 3 — The Shift *(4 min)*
> "Around 2020, something fundamentally changed. For the first time, we got machines that could reason — not perfectly, but genuinely. Large Language Models. LLMs. Things like ChatGPT, Claude, Gemini.
> Now here's the part most people get wrong. They think AI replaced the old stack. It did not. The old stack is still there. Every bank, every airline, every hospital still runs on databases and rule-based code. That part hasn't gone anywhere and it won't, because it can't — you cannot run payroll on a system that 'thinks creatively.' You need it to do the same exact thing every single time.
> What changed is that we now have a **second layer** — a thinking layer — that sits on top of the old layer.
> And that second layer needed new pieces. Let me name them quickly:
> **Vector databases** — a new way to store information. The old way stored data as rows. The new way stores data as *meaning*. So instead of searching for the exact word 'car,' the system can find 'vehicle,' 'automobile,' 'sedan' — because it understands they mean similar things. The technology is called embeddings, the storage is called a vector database. Pinecone, Qdrant, pgvector, Supabase — those are the names floating around.
> **RAG** — Retrieval Augmented Generation. A fancy way of saying: before the AI answers, go fetch the right documents from the vector database and hand them to the AI so it gives an accurate answer instead of making things up.
> **MCP** — Model Context Protocol. A new standard, very recent, that lets AI safely talk to your tools — your calendar, your email, your database. Think of it as the USB cable between AI and the rest of your software.
> **Agents** — AI that doesn't just answer questions, but actually *does* things. Books your meeting, sends the email, updates the database, calls another system. That's an agent."
---
🔄 Section 4 — Same Jobs, New Names *(4 min)*
> "Here's the part I want you to really hear, because it's the cleanest way to understand what's happening.
> Every job that the old stack did — there's a new name for it now. The job didn't disappear. The vendor changed.
> **The job of running business logic** — handling logins, saving forms, processing payments. That used to be PHP and Laravel. Now it's TypeScript running on Node.js. Same job. Different syntax.
> **The job of describing what a webpage looks like** — that was HTML. Now people write React, JSX. But here's the joke: React still produces HTML. The browser still only understands three things — HTML, CSS, JavaScript. Always has. React just writes the HTML for you instead of you typing it. The old job is still happening, just hidden behind a new wrapper.
> **The job of storing rows of data** — that was MySQL on Oracle. Now it's Postgres inside Supabase. Same SQL language. Different host. Same job.
> **The job of serving the website to your browser** — that was Apache or Nginx running on a server somebody had to manage. Now it's Vercel's edge network — invisible, automatic, scales by itself. Same job. Hidden from you.
> So when you hear someone say 'I'm building an AI-native app,' what they actually have is: a normal deterministic backend — written in TypeScript instead of PHP, running on Vercel instead of a VPS — and **on top of that**, they bolt on the LLM, the vector database, the agents.
> **The AI doesn't replace the backend. It rides on top of it.**
> That's the single most important sentence in this whole conversation. The conventional layer doesn't go away. It gets new names, new vendors, and a thinking layer bolted on top."
---
🧠 Section 5 — The Trap to Avoid *(3 min)*
> "Now there's one confusion I want to clear up, because almost everyone falls into it.
> **AI writing code is not the same as AI running inside software.** These are two completely different universes.
> When a developer uses Cursor or Claude Code or Copilot to write a Laravel app — the AI was just a typing tool. A super-fast autocomplete. The software it produced is still ordinary deterministic code. It runs the same way every time. The user of that app gets zero AI. They get a normal screen with normal buttons.
> Compare that to a real AI-native product — where the LLM is called *at runtime*, every time a user does something. The AI is part of the product itself. That's a totally different category.
> So when someone says 'we use AI' — ask which one they mean. Did AI help them build it? Or is AI living inside it, thinking, every time a customer uses it? Those are very different things.
> AI is also not an equalizer — it's a force multiplier. It accelerates whatever expertise you already have. If you know what good code looks like, AI makes you 10x faster. If you don't, AI just helps you ship bugs faster. Same with any field — law, medicine, design, marketing. AI multiplies you. It doesn't replace you."
---
🎯 Section 6 — Why This Matters Right Now *(2 min)*
> "Three things are true at once, and you need to hold all three:
> **One — how code gets written has changed.** Anyone writing code by hand from scratch in 2026 is slow. AI is the new default for writing software.
> **Two — how software runs at runtime has not changed for most things.** Login, save, query, transfer, render — that's still deterministic logic. It always will be. AI runs as a feature inside the software, not as the software itself.
> **Three — what kind of software is worth building has changed.** More chatbots, more agents, more AI-native products, fewer dashboards-with-forms. The demand curve is bending hard toward AI-native.
> So: the way code is written has changed. The runtime physics of software has not. The market mix of what's worth building has changed. All three are true at once.
> That's the whole picture in 15 minutes. Any questions?"
---
PART 2 — Q&A CHEAT SHEET
---
❓ "What if the AI vendor disappears?"
> "Fair concern. OpenAI, Anthropic, Vercel, Supabase are all young companies. People remember when Parse shut down and took everyone's apps with it. The answer is: don't lock yourself to one vendor. Build with abstraction layers so you can swap providers. The mature companies are already doing this."
---
❓ "What if the AI gives wrong answers to my customers?"
> "This is the real risk. A traditional app either works or shows an error. An AI app can confidently lie — we call it hallucination. That's why we use RAG — retrieval — to ground the AI in your actual documents. And for anything high-stakes, you keep a human in the loop. AI proposes, human approves."
---
❓ "What if I can't find anyone to maintain it?"
> "There are 5 million PHP developers on Earth. There are far fewer engineers who can debug an agent loop. True today. But the talent pool is growing fast — every developer is being pulled into AI right now. Two years from now this won't be a question."
---
❓ "What if the cost explodes?"
> "Real concern. LLM tokens cost money per call — unlike a traditional app that costs the same whether 1 or 1000 users hit it. The fix is design discipline: cache aggressively, route simple queries to cheaper models, only call the expensive model when you need it. Costs are also dropping about 10x per year."
---
❓ "What if the AI part is just hype?"
> "They've watched blockchain, metaverse, NFTs come and go. Fair to be skeptical. The difference: AI already has hundreds of millions of daily paying users solving real problems — writing, coding, research, customer support. It's not waiting for adoption. Adoption already happened. The question now is just: what gets built on top of it."
---
PART 3 — POCKET CHEAT SHEET
---
**Old world (1995–2020):**
- Storage: SQL, Oracle, Excel, CSV
- Code: HTML, PHP, Java, Python
- Pattern: humans write rules → machines execute
- No reasoning. Ever.
**New world (2020–now):**
- Old layer is still there (it has to be — login, save, pay, render)
- New thinking layer bolted on top
- New pieces: LLMs, vector databases, RAG, MCP, agents
**The mapping (same job, new vendor):**
| Old | New |
|---|---|
| PHP / Laravel | TypeScript / Node.js |
| HTML | React (still produces HTML) |
| MySQL | Postgres / Supabase |
| Apache / Nginx | Vercel edge |
| VPS server | Serverless / managed |
**The one sentence to remember:**
> *AI doesn't replace the backend. It rides on top of it.*
**The trap to avoid:**
> *AI writing code ≠ AI running in software. Two different universes.*
**The three things all true at once:**
1. How code is written → changed
2. How software runs → mostly unchanged
3. What's worth building → changing fast
---
*End of course. Total ~22 min including Q&A.*