The bait, then the rug-pull.
Open on a defocused bokeh of Rob at his ring-lit desk and a single sentence designed to stop the scroll: Karpathy — the man who coined vibe coding — just told you that everything you built last year is wrong. The promise is delivered in the next twenty-four seconds: four frameworks, the actual playbook, and a brutal little test that will probably kill at least one app sitting in your side-project folder.
What the video promised.
stated at 00:24“In the next few minutes, I'm gonna walk you through what he actually said about 2026, what it means for what you should be building and how you should be building, and the four frameworks that I think every AI builder needs to have in their head right now.”delivered at 13:32
Where the time goes.
01 · Cold open — Karpathy's bad news
Rob frames Karpathy's credentials (OpenAI, Tesla Autopilot, coined 'vibe coding') and lands the pattern interrupt: if you're still building like last year, you're in trouble.
02 · Promise + sponsor handshake
Sponsor tag for monday.com, then the explicit promise: what Karpathy said about 2026, what to build, and the four frameworks every AI builder needs. Teases the 'Strategy Agent' that will return as a tool recommendation later.
03 · The December inflection
Karpathy's first big claim: around December, models crossed a quality line — output 'just worked', he stopped correcting, and went on a vibe-coding bender. Implication: if you haven't built end-to-end with Claude Code / Codex / Cursor in the last 60 days, you are flying blind. Homework: build something this weekend.
04 · Software 3.0 explained
Karpathy's evolution: Software 1.0 = handwritten rules. Software 2.0 = trained neural nets on big data. Software 3.0 = the LLM itself is the programmable computer, the prompt is the code, the context window is your lever.
05 · From SaaS to agent calls
Rob uses his own product Levercast as a worked example. Old world: log in, click create, generate post. New world: tell an agent 'use the Levercast MCP, here's an idea' and walk away. The interface for software is no longer humans clicking — it's agents calling.
06 · The MenuGen test
Karpathy's own MenuGen app — built last year to turn restaurant menus into food photos — now does nothing ChatGPT/Nano Banana can't do natively in one prompt. He demonstrates by dropping the menu directly into a multimodal model. The lesson: a huge percentage of apps shipping right now are Software 1.0 plumbing wrapped around what should be a single Software 3.0 prompt.
07 · The single-prompt test (stop or pivot)
The diagnostic Karpathy gives every builder: take what you're building and ask, could I do this with a single multimodal prompt + the right tool calls or an MCP? If yes — you're plumbing that's about to get eaten by the next model release. Stop or pivot. Rob caps it with the Gretzky 'skate where the puck is going' quote.
08 · Sponsor: monday.com vibe
Sponsor read for monday.com's new natural-language app builder, framed (not unreasonably) as a real-world Software 3.0 surface: build bespoke apps on top of your existing monday workflows, OKRs, and data. CTA: free start, link in description.
09 · Verifiability is the moat
Karpathy's next pillar: models are great at code because code is deterministic and verifiable — that's clean feedback the model can train on. Most of the world isn't. So the opportunity is finding niches with SOME verifiability that the frontier labs aren't chasing: financial trading, supply-chain/routing optimization, CI and migration agents, data cleaning and labeling. Your domain expertise is the moat.
10 · Vibe coding is retired — meet agentic engineering
Karpathy explicitly retires 'vibe coding' (great as a floor — anyone can build now — but a ceiling without quality). The new term: agentic engineering. Specs, plans, context-window management, code review, unit-through-end-to-end smoke tests, CI blockers. People who get good at this are 10x faster. Rob pushes back on the X-bro claim of '10–20 agents at once' — he can keep 3–4 in his head, max, because he's working on production systems.
11 · Self-promo + Build 1: tools for understanding, not speed
Short ad for switchdimension.com course/community, then framework #1 of four: build tools that increase your understanding, not just your speed. Worked example: Rob's 'Strategy Agent' — a folder of markdown strategy docs that an agent reads to keep him focused, redirect him when he's chasing the wrong thing, and ground every new doc in real company context.
12 · Build 2: agent-first infrastructure
Everything we've built is for humans — docs, dashboards, install flows, DNS. The next-gen win is stripping the human UI layer: would an agent know how to use this directly with no human translation? Concrete signal already happening: llm.txt files on e-commerce sites so agents can quickly figure out 'is this API trustworthy, how does it work' instead of wading through marketing copy.
13 · Build 3: verifiable domain capability
Big labs cover the big surfaces; they will not reinforcement-learn every sub-niche. There are millions of them. The play: pick one, build a verifiable RL environment around it, fine-tune, own that capability. Rob's encouragement: don't dismiss this as inaccessible — you can build anything now, take the handbrake off.
14 · Build 4: apps that only exist because of Software 3.0
The big one. Not a faster spreadsheet, not a prettier UI on top of an existing workflow — genuinely new things that couldn't exist before reasoning + multimodal models, like the LLM-as-knowledge-base pattern Karpathy demoed. Rob shares that this week he went into his own side-project folder and killed three projects that failed the MenuGen test and the Software 3.0 test. Better to kill them now than watch them die in three months. Teases one or two survivors that hit all four criteria.
15 · Engagement question + CTA stack
Genuine ask: what's the app YOU built that probably shouldn't exist anymore? Then the CTA cluster — subscribe, teases a follow-up on agent-first infrastructure, points to switchdimension.com course/community, links Karpathy's full original talk, and points to more videos on the channel.
Visual structure at a glance.
Named ideas worth stealing.
Software 1.0 / 2.0 / 3.0 (Karpathy)
- Software 1.0 — handwritten rules / explicit code
- Software 2.0 — neural networks trained on large datasets
- Software 3.0 — the LLM IS the programmable computer; prompts are the code; context window is the lever
Karpathy's three-era model for how software is written. The shift to 3.0 is the unlock — most current SaaS is 1.0 plumbing around what 3.0 already does natively.
The MenuGen Test / Single-Prompt Test
Take what you're building and ask: could I do this with a single multimodal prompt + the right tool calls or an MCP? If yes, you're building plumbing that's about to be eaten by the next model release. Stop or pivot.
Four Frameworks Every AI Builder Needs (Rob's distillation of Karpathy)
- Build tools that enhance your understanding, not just your speed (e.g. a Strategy Agent)
- Build agent-first infrastructure (strip human UI; expose llm.txt / MCPs / APIs)
- Build verifiable domain capability (pick a niche, RL it, own it)
- Build apps that ONLY exist because of Software 3.0 (no spreadsheet-with-AI)
Rob's four-pillar takeaway from Karpathy's talk — what to actually go build now.
Verifiable Workflows for Big Business Wins
- Financial trading
- Supply-chain and routing optimization
- Continuous integration & migration agents
- Data cleaning and labeling
Karpathy's example list of underserved domains with enough verifiability to train against — niches the frontier labs are not focusing on.
Four Practices of Agentic Engineering
- CI as a hard gate
- Automated security review
- Code review as a first-class step
- Human comprehension artefact (specs, plans, docs)
On-screen card listing the four practices Rob says professional builders are now doing (his version of Karpathy's agentic-engineering pillar). Replaces 'vibe coding' as the professional discipline.
Lines you could clip.
“Vibe coding raised the floor. Pretty much anyone can build now. But what professionals are doing now is agentic engineering.”
“If the answer is yes, you're building plumbing that's about to get eaten by the next model release. Stop or pivot.”
“A huge percentage of the apps people are building right now shouldn't exist. They're orchestrating things the model can already do natively.”
“I went to my own side project folder this week and I killed at least three projects after watching Karpathy's talk.”
“Software 3.0 is where the LLM itself becomes the programmable computer, the interpreter, and your code basically is the prompt.”
“We can now build anything. Take your handbrake off and go and do it.”
How they spent the runtime.
- 04:57–06:00 · monday.com (vibe natural-language app builder)
Things they pointed at.
How they asked for the click.
“Hit me up in the comments, and I'm asking this seriously — what is the app you've built that probably shouldn't exist anymore? If this was useful, subscribe. Check out the Switch Dimension course and community.”
Stacked CTA — engagement question first (clever: drives comments by asking for confessions), then subscribe, then teases the next video (agent-first infrastructure deep-dive), then product link, then external link to Karpathy's original talk. The engagement-question opener is the strongest move because it lowers the ask and produces algorithm-friendly comment threads.
Word for word.
Steal this playbook.
Frame every product decision through Karpathy's lens: am I shipping plumbing the next model release will eat — or am I shipping something that only exists because of Software 3.0?
- Build the Strategy Agent first. Before you ship anything else in MCN+, JoeFlow, or Mod Producer, stand up a 'brain' — a markdown folder + agent that knows your offer architecture, your audience, and your kill criteria. Use it to reject your own ideas.
- Run the MenuGen test on every project in the repo. JoeFlow, Reels Editor, ModBoard, ClipLab — for each, ask 'can ChatGPT/Claude do this with one prompt + an MCP?' If yes, the moat has to come from somewhere else (data, network, distribution, brand) or it dies.
- Lean into verifiability. Your moat as a creator-tools builder is domain expertise (direct response, video production, transcription pipelines). Pick the niches with measurable outputs (transcript quality, conversion on a sales page, retention on a clip) and build RL-style feedback loops there.
- Ship an agent-first version of every Modern Creator product. Add llm.txt + an MCP to every Mod app — JoeFlow MCP, ModBoard MCP, Mod Producer MCP. Agents are a distribution channel.
- Use the kill-three-projects confession as a content pattern. A creator publicly killing his own work is a high-trust, high-comment move — it lowers the ask before any pitch. Joe should do this once a quarter on Killing Excuses.
- Steal the four-frameworks listicle structure. 'X just told us Y — here are the four things' is a clean carousel/short/email spine you can run quarterly on every AI announcement that matters.
- Use the 'softer hook' format: credentials in line one, bad-news pattern interrupt in line two. It's the cleanest 24-second open in the category — Joe should rebuild Killing Excuses cold opens this way.
If you're building anything with AI right now.
Pick one project this weekend. Run it through one question: could a single multimodal prompt plus an MCP do what your app does? If yes — stop or pivot. If no — you may have something worth doubling down on.
- Spend a real weekend coding end-to-end with Claude Code, Codex, or Cursor in agent mode. Don't watch tutorials — build something rough. Karpathy's claim is that if you haven't done this in the last 60 days, your mental model is already wrong.
- Open your own side-project folder. List every app you've started. For each one, ask honestly: does this exist only because models couldn't do it natively six months ago? If yes — kill it now, before you spend three more months on it.
- Pick a domain you know better than 95% of people. Could be supply-chain ops in your industry, a niche of medical billing, a corner of finance, a job-specific workflow. That domain expertise is the moat AI labs can't replicate.
- If you're building anything user-facing, add an llm.txt and consider exposing an MCP. The next wave of distribution is not humans finding your homepage — it's agents finding your API.
- Stop calling what you do 'vibe coding'. Start treating it like engineering — specs, plans, tests, code review. The people moving 10x faster are the ones who added discipline back, not who removed it.
- If a project survives the MenuGen test AND requires reasoning + multimodal + verifiability — go all in. Those are the apps worth your year.
