The 15-Minute AI Intro — v2
**Total runtime:** ~22 min talk + 5 min Q&A
**Format:** Script (read aloud) + Q&A cheat sheet + Pocket cheat sheet
---
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.
> Then around 2020, something fundamentally changed. I'll get to that. But first, let's understand what we're moving away from."
---
🏛️ Section 2 — The Old Stack *(3 min)*
> "The old world has two layers. Hold these in your head — we'll come back to them.
> **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 know 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 fits in one sentence: **humans write the rules, machines execute them.**
> A few words you'll hear thrown around — let me ground them quickly:
> — **Auth** is just login. Proving who you are.
> — **CRUD** stands for Create, Read, Update, Delete. The four basic actions on data. About 90% of business apps ever built are essentially CRUD.
> — **Dashboard** is a screen that shows you data — charts, lists, numbers.
> — **RBAC** is Role-Based Access Control. Admin can delete, staff can only view.
> — A **legacy stack** is the old, proven tech you've been using for years — Laravel, PHP, MySQL, a server in a data center somewhere.
> That's the old world in a nutshell. Brilliant systems were built this way — but none of them could think. They could only follow."
---
⚡ Section 3 — The Shift *(5 min)*
> "Around 2020, large language models arrived. ChatGPT, Claude, Gemini. For the first time, machines could reason — not perfectly, but genuinely.
> 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 one.
> That second layer needed new pieces. Let me name the four big ones:
> **One — Vector databases.** A new way to store information. The old way stored data as rows. The new way stores data as *meaning*. Search for 'car' and the system finds 'vehicle,' 'automobile,' 'sedan' — because it understands they all mean similar things. The technology is called **embeddings**. The storage is called a **vector database**. Names you'll hear: Pinecone, Qdrant, Supabase, pgvector.
> **Two — RAG.** Stands for Retrieval Augmented Generation. Fancy name, simple idea: before the AI answers your question, the system *retrieves* the relevant documents from your knowledge base and hands them to the AI, saying 'answer using these.' This is what stops the AI from making things up. Used in every serious AI app today.
> **Three — MCP.** Stands for Model Context Protocol. A new open standard, very recent, that lets AI safely talk to your tools — your calendar, email, database, CRM. Think of it like USB. Before USB, every device needed its own connector. After USB, one standard. MCP is the USB cable between AI and the rest of your software.
> **Four — Agents.** AI that doesn't just answer questions, but actually *does* things. Books the meeting. Sends the email. Updates the database. Calls another system. An agent is AI taking action in a loop — receiving a goal, deciding what to do, doing it, checking the result, deciding the next step, until the goal is done."
---
🔄 Section 4 — Same Jobs, New Names *(3 min)*
> "Here's the cleanest way to understand what's happening underneath.
> Every job that the old stack did has a new name now. The job didn't disappear. The vendor changed.
> — **Running business logic** — handling logins, saving forms, processing payments. Used to be PHP and Laravel. Now it's TypeScript on Node.js. Same job. Different syntax.
> — **Describing what a webpage looks like** — that was HTML. Now people write React. Here's the joke: React still produces HTML. The browser only understands three things — HTML, CSS, JavaScript — always has, always will. React just writes the HTML for you instead of you typing it.
> — **Storing rows of data** — that was MySQL on Oracle. Now it's Postgres inside Supabase. Same SQL language. Different host.
> — **Serving the website** — 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. You don't see the servers.
> 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 Three Paths *(4 min)*
> "Now, when someone wants to actually do this in their business, they're choosing between three scenarios. Let me walk through them.
> **Path one — pure conventional, no AI.** The traditional Laravel and MySQL setup. User clicks → Laravel saves → returns a page. Same input, same output, every time. This is 90% of business software ever built. Honestly, in 2026, this path is dying for any customer-facing product. Fine for narrow internal tools. Not fine if you want to compete.
> **Path two — conventional plus AI bolted on.** This is the polyglot path. You keep your Laravel core for the boring-but-critical stuff — auth, payments, the database, business logic. You add a *separate* Node.js or Python service that handles the AI layer — LLM calls, agents, vector search, streaming. They talk to each other over HTTP. Your old code stays in place. Zero risk to existing customers. This is how 95% of Dubai's existing PHP shops will comply with the agentic mandate.
> **Path three — fully AI-native from scratch.** You're a new founder, no legacy. One stack, one language: Next.js, TypeScript, Supabase, Vercel, plus AI SDKs. The deterministic backend is still there — auth, payments, render — but written in TypeScript. The AI layer lives in the same codebase. No polyglot needed. Faster to build. Easier to hire for in 2026.
> **Now — which path is best?**
> There's no universal best. It depends entirely on where you're starting from.
> If you're a new founder with nothing built yet — go Path 3. Starting a new product on PHP in 2026 just to add AI later would be a strategic mistake.
> If you're an existing company with working production systems — go Path 2. Don't rewrite. Engineering managers fire people for proposing 18-month rewrites that deliver zero new business value.
> If you're stuck on Path 1 — start planning your move. Either toward Path 2 if you have legacy, or Path 3 if you're starting something new.
> One more nuance: Path 2 is often a *stepping stone*, not a final destination. Companies start polyglot to ship AI fast, then over three to five years gradually migrate the conventional layer to TypeScript too — eventually landing at Path 3. The migration is slow and deliberate. It only happens once the AI layer has proven itself."
---
🧠 Section 6 — The Trap to Avoid *(2 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 AI was present at *build time only*. Once shipped, the AI is gone. 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. The user is literally talking to AI when they use the app.
> So when someone says 'we use AI' — ask which one they mean. *Did AI help you build it? Or is AI living inside it, thinking, every time a customer uses it?* Those are very different things. One is a productivity boost. The other is a new kind of product."
---
💪 Section 7 — The Force Multiplier Truth *(2 min)*
> "Last big idea before I close.
> AI is a force multiplier. It is *not* an equalizer. This sounds like a contradiction, but it isn't.
> Here's the trap: people assume that if AI multiplies output, then a beginner using AI should reach expert level. That's wrong. Because **AI multiplies your judgment, not your output.**
> Output is the easy part now. AI gives everyone unlimited output. The new bottleneck is — can you tell good output from broken output? Can you steer the AI toward the right thing?
> Imagine an expert and a beginner both ask Claude to write the same code. Both get 200 lines back in 30 seconds.
> — The expert reads it, spots three subtle bugs in 30 seconds, fixes them, ships in the same morning.
> — The beginner can't tell good from bad. Ships the bugs. Gets hacked next week.
> Same AI. Same prompt. Wildly different outcomes.
> The math: if you're a 10, AI makes you 100. If you're a 1, AI makes you 10. The expert is still 10x ahead. AI lowers the floor — anyone can ship something now. But it raises the ceiling much more — experts can do things that were impossible before. **The gap between expert and beginner widens. It does not close.**
> The catch — what beginners *can* do — is learn faster than ever. AI is a brilliant tutor. It can explain anything, review your work, answer questions instantly. AI accelerates the learning journey. It just doesn't skip it."
---
🎯 Section 8 — The Three Things All True at Once *(1 min)*
> "Let me close with three things that are all true at once. 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.
> 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. Any questions?"
---
PART 2 — Q&A CHEAT SHEET
---
❓ "What if the AI vendor disappears?"
> "Fair concern. OpenAI, Anthropic, Vercel, Supabase are 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 in a day. 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 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. Far fewer engineers can debug an agent loop today. True. 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 1,000 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."
---
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 (login, save, pay, render — has to be)
- 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 three paths forward:**
1. Pure conventional → dying for customer products
2. Conventional + AI bolted on → existing companies pick this
3. Fully AI-native from scratch → new founders pick this
**The key sentences to remember:**
- *AI doesn't replace the backend. It rides on top of it.*
- *AI writing code ≠ AI running in software. Two universes.*
- *AI multiplies your judgment, not your output. The gap widens.*
**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. ~22 min talk + 5 min Q&A.*