The argument in one line.
Most AI apps built in 2025 are just software 1.0 plumbing around tasks LLMs can now do natively, so builders must either stop, pivot, or build verifiable domain capabilities and genuinely new software 3.0 products that couldn't exist before frontier models.
Read if. Skip if.
- A developer or founder building AI applications who shipped something last year and suspects your approach may already be outdated by December 2025 capability shifts.
- Someone actively using Claude, Cursor, or similar agents who wants a framework to evaluate which of your side projects are actually worth finishing versus killing.
- A software builder skeptical that 'vibe coding' will stick around who needs concrete patterns to shift from UI-first SaaS toward agent-first infrastructure.
- You haven't actually tried building end-to-end with an AI agent yet — this assumes you've spent 5+ hours hands-on with Claude Code, Cursor, or equivalent.
- You're building non-software products or exploring AI at a purely theoretical level — this is tactical and assumes you ship code.
The full version, fast.
Andrej Karpathy's December inflection means models now reliably just work, retiring naive vibe coding and ushering in Software 3.0, where the LLM itself is the programmable computer and the prompt is the code. The shift forces a hard audit of what you build: apply the menu gen test by asking whether a single multimodal prompt with the right tool calls or MCP could replace your entire app, and if yes, the next model release will eat it. Build instead for four lanes: strategy brains that compound your understanding, agent-first infrastructure that strips human UI, verifiable niches the frontier labs ignore for reinforcement learning, and apps only possible because reasoning models exist. Kill the plumbing; skate where the puck is going.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →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.
Lines worth screenshotting.
- Software 3.0 means the LLM is the programmable computer, your prompt is the code, and the context window is your lever.
- A December 2025 inflection point made model output reliable enough that Karpathy stopped correcting it and started trusting it — a qualitative shift, not a benchmark number.
- Any app that can be replaced by a single multimodal prompt with a few tool calls should not be built as a standalone SaaS product.
- A huge percentage of apps currently being built are Software 1.0 plumbing wrapped around what a single Software 3.0 prompt already handles natively.
- Karpathy's menu-gen app — a full application built last year — is now solvable by dropping the menu image into ChatGPT with no app required.
- The test for whether to build something: could I accomplish this with one multimodal prompt and two MCP calls? If yes, stop or pivot.
- Agent-first infrastructure means building your product so that an AI agent can discover and use it via MCP or API, not just a human via UI.
- Verifiable niches are where AI output can be checked for correctness, which is where autonomous agents produce the most reliable value.
- If you have not built something end-to-end in Claude Code or Codex in the last 60 days, you are flying blind about current model capability.
- Vibe coding evolved into agentic engineering where you architect the system rather than write every line — the discipline changed, not the ambition.
- Killing your own side projects after applying the Software 3.0 test is not failure — it is pruning so resources flow to what the model cannot yet replace.
- Skating to where the puck is going means building for what the next model release will make possible, not what the current one requires.
Karpathy's Four Tests for What to Build With AI in 2026
Rob Shocks distills Andrej Karpathy's AI Ascent talk into four actionable frameworks — the single-prompt test, the verifiability moat, agentic engineering discipline, and the infinite upside principle.
- The credentials are the permission slip — coiners of vibe coding and former Tesla Autopilot lead — then the pattern interrupt: if you are still building like last year you are in trouble
- Around December, model output crossed a quality line — Karpathy stopped correcting and went on a vibe-coding bender
- If you have not built end-to-end with Claude Code or Codex in the last 60 days, you are forming opinions on outdated evidence
- Software 1.0 = hand-written rules, 2.0 = trained neural nets, 3.0 = the LLM is the computer and the prompt is the code
- The context window is your lever — what you put in it determines what quality of software comes out
- Old world: log in, click create, generate. New world: tell an agent the job and walk away
- The interface for software is no longer humans clicking — it is agents calling MCPs and APIs
- Karpathy's own app for turning menus into food photos now does nothing a single multimodal prompt cannot do
- A large percentage of current apps are Software 1.0 plumbing wrapped around what should be a single Software 3.0 prompt
- Ask: could I do this with one multimodal prompt plus the right tool calls? If yes, stop or pivot before the next model release does it for free
- Skate where the puck is going — the question is not what works today but what survives the next capability jump
- Models train well on code because it is deterministic and verifiable — that feedback loop is clean
- The opportunity is niches with some verifiability the frontier labs are not chasing: financial trading, supply-chain routing, CI agents, data cleaning
- Agentic engineering means specs, plans, context-window management, code review, and unit-through-smoke tests — not just prompting and hoping
- People who develop this discipline are 10x faster; people who stay at vibe-coding level hit a ceiling
Terms worth knowing.
- Software 3.0
- Andrej Karpathy's framing of the current AI era: where the large language model itself is the programmable computer, the prompt is the code, and the context window is the primary lever — replacing hand-written rules (1.0) and trained neural networks (2.0).
- Vibe coding
- A term coined by Andrej Karpathy describing a development style where a programmer leans on AI to generate most of the code, primarily guiding it with natural language rather than writing every line manually.
- December inflection
- Karpathy's reference to a moment around December 2025 when AI model output quality improved to the point where developers could trust and ship AI-generated code with minimal correction.
- Agentic engineering
- A development approach where engineers primarily direct, evaluate, and orchestrate AI agents rather than writing code themselves, shifting the job from implementation to system design and verification.
- Agent-first infrastructure
- Software architecture and tooling built specifically to support autonomous AI agents as the primary actors — emphasizing observability, sandboxing, and verification over traditional human-driven workflows.
- Verifiable niche
- A problem domain where an AI agent's output can be automatically checked for correctness — such as passing a test suite or producing a valid file — making it suitable for unsupervised agent work.
- Andrej Karpathy
- A prominent AI researcher and engineer who co-founded OpenAI and led Tesla Autopilot, now known for educational AI content and frameworks like Software 3.0 and the term 'vibe coding.'
- SaaS (Software as a Service)
- A distribution model where software is hosted online and accessed via subscription, rather than installed locally — the dominant model for web apps before the AI-agent era began shifting architectures.
- Context window
- The maximum amount of text (including instructions, history, and documents) that an AI model can consider at once when generating a response; the primary resource developers manage when building with LLMs.
Things they pointed at.
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.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
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.
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.
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.
Visual structure at a glance.
