08:38Mark Kashef · Tutorial
I'm Done Paying Twice for AI
A walkthrough of swapping a metered API key for a headless Codex/Claude subscription so internal tools stop billing per click.
August 19thThe 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.
READ IF YOU ARE…
- 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.
SKIP IF…
- 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.
Free for members
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.
00:00 – 00:24
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.
00:24 – 00:57
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.
00:57 – 01:37
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.
01:37 – 02:17
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.
02:17 – 03:17
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.
03:17 – 04:25
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.
04:25 – 04:57
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.
04:57 – 06:00
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.
06:00 – 07:10
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.
07:10 – 08:52
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.
08:52 – 09:40
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.
09:40 – 10:57
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.
10:57 – 12:00
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.
12:00 – 13:32
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.
13:32 – 14:07
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
Builder's framework
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.
01Cold open — Karpathy's bad news
- 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
03The December inflection
- 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
04Software 3.0 explained
- 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
05From SaaS to agent calls
- 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
06The MenuGen test
- 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
07The single-prompt test (stop or pivot)
- 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
09Verifiability is the moat
- 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
10Vibe coding is retired — meet agentic engineering
- 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.
01:40toolClaude Code
01:40toolCodex
01:40toolCursor (agent mode)
02:20productLevercast (Rob's own AI social-media post tool)
04:00productMenuGen (Karpathy's example app)
04:17toolChatGPT
04:17toolNano Banana
05:22productmonday.com vibe
09:00toolClaude Cowork
10:15toolllm.txt convention
00:24linkAndrej Karpathy's full AI Ascent talk
Lines you could clip.
07:50
“Vibe coding raised the floor. Pretty much anyone can build now. But what professionals are doing now is agentic engineering.”
04:50
“If the answer is yes, you're building plumbing that's about to get eaten by the next model release. Stop or pivot.”
04:33
“A huge percentage of the apps people are building right now shouldn't exist. They're orchestrating things the model can already do natively.”
12:46
“I went to my own side project folder this week and I killed at least three projects after watching Karpathy's talk.”
01:57
“Software 3.0 is where the LLM itself becomes the programmable computer, the interpreter, and your code basically is the prompt.”
12:00
“We can now build anything. Take your handbrake off and go and do it.”
Word for word.
Read-along
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.
metaphoranalogystory
So Andrzej Karpathy, he's the guy who literally helped build modern AI, who was at OpenAI, who got Tesla autopilot working, and who coined the term vibe coding. He just told us if you're still building apps the way you were last year, he's got bad news for us. So he just gave a brilliant talk.
I've spent hours breaking it down to help you understand how it may affect what you build as a developer, founder, or software company. Thanks to monday.com for sponsoring this video. More on them later.
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. I'm Rob from Switch Dimension, and if you're trying to build with AI in 2026 and beyond, this might be the most important video you watch this month, so stick with me.
in the last couple of months. Highly recommend you do something similar yourself.
So one of the first things that stood out to me was Karpathy's point about the December inflection. So what Karpathy is saying is round about December, the model's output started to actually just work.
He stopped correcting it. He started just trusting the model, and he basically went on this vibe coding bender. He said he has a ton of side projects that he's built up, and we all have that problem.
Multiple different projects we're working on the same time because now we can build anything. So essentially, if you haven't sat down in the last sixty days and seriously tried to build something end to end with clog code codex cursor in agent mode, you are really according to Karpathy. So go do that this weekend.
Seriously, build something. So I think Karpathi's biggest takeaway in this talk was the idea of software three point o, and we've heard that so many different times before.
But this is a slightly different angle I don't think many have seen. So Karpathi's breakdown of the software evolution is software one point zero is handwritten rules.
So basically, writing out code. Software two point o was training neural networks via large data sets, and software three point zero is where the large language model itself becomes the programmable computer, the interpreter, and your code basically is the prompt and .
So that's Karpathi's high level take on it. How does this affect us practically as builders? So in traditional SaaS, this is Levercast, an app I built.
It uses AI to help you post to all your social media platforms. So I would just click create, drop in my thoughts, generate a post with an existing style guide, and then it takes the pain out of the first draft for my social media posts across the various different channels that I work on.
So that's a traditional SaaS app with a little bit of AI sprinkled in on top. So here's the big shift and here's what's changing. We're going to be increasingly using our agents to do more work first.
We're gonna be living in claw code, codex cursor, whatever is your agent of choice. In this new world, what people will increasingly be doing is basically just telling their AI agents to carry out a task. So instead of me going and logging in to Leverkast and going through all the workflow, I might just say, hey.
I've got an idea for a post. I could drop it in and say, hey. Use the Leverkast MCP to carry this out.
Or not even. I could actually use a skill that's prebuilt in that will actually do all of this for me. I go off to do something else or I have this working on a schedule and then bang, all my posts are published.
So besides that being a cheap plug for my own software, really what we're getting at here is a change in how we need to think about building things. As a builder, you really need to think about the current capabilities of multimodal models and even think ahead a few months to what's coming next and how that might affect the software you're building or you've already built.
Do you need to have an MCP, an API, or some kind of agentic workflow in front of it so that an agent can discover it quickly? So Karpathy's example of this was back last year, he built this quick app that basically allowed you to turn your menus into magic. It's the idea that you could take any menu and looking at this menu here, might not know exactly what the food is or what it might look like.
By dumping in this menu into his app, it basically was able to create AI representations of what the food was and what it looked like. So last year, this was an entire application that he built that somebody could use.
This year, he could solve the same problem with just Chatchi BT or Nano Banana. So you can see the entire menu gen workflow replaced by me just dropping in that original menu, and here you can see an overlay of the dishes on the starters. So his big point here is the menu gen app that he built a year ago doesn't really need to exist anymore, and here's why that's really uncomfortable.
A huge percentage of the apps people are building right now shouldn't exist either. They're basically orchestrating things the model can already do natively that's only just appeared in the last couple of months.
Their software one point zero plumbing wrapped around what should just be a single software three point zero prompt. Anyway, you get the point. So here's the test.
Take what you're building and ask, could I do this with a single multimodal prompt and the right tool calls or an MCP or two? If the answer is yes, by the next model release. Stop or pivot.
For you Americans or Canadians who love hockey, we don't even have ice in Ireland. This is where I insert a quote about you're , not where it is right now. So if you watch this channel at all, you're going to be no stranger to vibe coding apps.
And I wanted to talk today about monday.com's vibe because basically I think it's different. It's a natural language app builder baked directly into the monday.com platform.
So, yeah, of course, there's tons of different app builders out there, but I think what's really different about this, you're actually building your application on top of your monday.com infrastructure and context.
And as we talk about in this video, the context and the understanding is really important. You've got your workflows, your intakes, your OKRs, everything that's important to your company is managed in there.
But often there's this last mile problem where you want to solve something like, you know, I wish I had the perfect form for pulling that in or, uh, we need a clean page that represents our OKRs. So with monday.com's new vibe, you can use natural language to create bespoke interfaces with inputs and outputs that write back to your monday.com data, like a sales forecasting app, a campaign health tracker, a time tracker app.
So it's pretty much living in Monday where you and your staff works. This really is a super tool. Viewers can get started for free.
Check out the link in the description down below. So already, Karpathy has given us some real gold. Let's move on to his next point.
And this is all about verifiability and building a moat as we go forward. So Karpathy went on to explain why a lot of Frontier models fall down and how there's an advantage in that.
The reason models are so good at code is because it's deterministic and it's verifiable, and that's great feedback for the model. Unfortunately, a lot of the world isn't as verifiable as code.
So Carpathi suggests, what are the domains that the large frontier labs are not focusing on right now that's have some level of verifiability? Financial trading, supply chain, and routing optimization, continuous integration and migration agents, data cleaning, labeling.
You all have domain expertise in some niche part of any workflow or company. What are the things that you can build in that space that take advantage of the things Carpathi is talking about in this conversation? So thankfully, in this talk, he basically retires the term vibe coding and replaces it.
So vibe coding is great. It raised the floor. Pretty much anyone can build now.
We all needed that. It pretty much democratizes building. But But he says what professionals are doing now is agentic engineering, and that's the kind of stuff I teach a lot in my channel and on my course.
This means things like using specs, plans, managing your context window, doing proper review, making sure that we have unit level smoke tests to end tests, and blockers in place in continuous integration so that we're not pushing bad code. Karpathi says he's seeing people who are getting good at this go 10 x faster. If you're on x at all, you'll see that, oh, people running 10 to 20 agents at the same time.
Personally, I kinda think that's nonsense. I'm really good at this. I've been doing it for two years, and the most I can keep in my head at any time is maybe three to four agents running at the same time.
I give them a little bit of work. I check what they're working on. I have to review the code.
These are production databases, production systems I'm working on. I'm not just gonna push up whatever the agent was working on.
So if you're feeling behind and you're working with agents, but you don't feel like you're working with 10 or building entire, uh, empires in a single prompt, then don't worry. But the thing is we really need to think about how we get to that point because what Karpathy is talking about is we need to build again for where that puck is going.
So we get to that point where not unlike in December when things just worked, I think we'll get to a point where our our agentic harnesses just work, and we can run 10 to 20 agents at the same time if we choose. We're not there yet, but we're on that path. By the way, if you're interested in building agentic harnesses and production systems like that so you can build apps really quickly, you can join my course and community at switchdimension.com.
It's currently closed to new members right now, but I have a new course dropping in the coming weeks. If you want to be part of that cohort, just drop your name and email into the wait list. Okay.
So let's wrap this all up into the four things you should build. So the first thing he suggests you build are tools that enhance your understanding, not just your speed.
So here's what I do myself, and here's a really easy way for you to get started with this. Here, I've got Claude Cowork, but it doesn't matter what tool you use. I could do this in Claude code.
You could do this in cursor. You can do it wherever you want. Essentially, what you need is a folder and an initial prompt.
That prompt to your agent is where you tell it about your company, your app, your domain space, your life, whatever else it is, and ask it to create a set of strategy documents around that application business, whatever the domain space is. So in my case, I have a company called Switch Dimension that helps people learn how to build with AI, and I got it to produce a whole lot of strategy documents around that through various conversations.
And they're just simply stored as markdown in a folder. So my big problem is I want to build everything and take every opportunity. I just have a quick conversation with my strategy agent, which now has an understanding of where I'm going, and it keeps me on track.
It gives me focus. It says you're going in the wrong direction if you work on that. Here's what you should be focusing on.
Here's the opportunities. And every time I ask it to generate a doc or create new content, it does that with real context and understanding of my Switch Dimension world.
This kind of a brain is the single most powerful thing I've built in the last couple of months. Highly recommend you do something similar yourself. So the next thing you should build is agent first infrastructure.
Everything we've built is pretty much built for humans. That's documents, dashboards, install flows, DNS settings. The entire Internet is built really for humans.
So the real win in this next generation is stripping away all of the human UI. Would an agent know how to use this directly without any kind of human translation in between? We're seeing this on websites in ecommerce where LLM dot TXT files are there so that when agents arrive on a website, can quickly figure out how to use it rather than reading through all the emotional marketing that's directed at humans.
It wants to just know how the API works, how can work with your product, is it trustworthy as fast as possible, build for that. Number three, we talked about verifiable domain capabilities. So a lot of the big labs are covering the large domain areas, but they're not going to have the time or be specifically focused on reinforcement learning for all these little sub niches.
There are millions of them in every part of our life and business. Can you build a reinforcement learning environment around this, fine tune it, and own that capability? So don't dismiss this as an opportunity for you.
We can now build anything. That's exciting. and go and do it.
And number four, the big one. Let's build apps that only exist now because of software three point zero. So that is not a faster spreadsheet, a faster UI interface on top of a workflow.
We need completely new things like that large language model knowledge base Karpathi was talking about. That literally, we couldn't exist because there was no code that could actually do it. There's so many new things we can build now that we're still thinking about apps and the old way of doing things.
There's a whole new approach now with these reasoning models that we can apply. Let's be honest, AI will change the jobs market. It will change how we work.
If we think positively about what we can build now, the reframing of data, the compilation across all these modalities, We've got large language models now that actually push and progress other areas of science and medicine. We have a really exciting time ahead of us. On a personal note, I went to my own side project folder this week, and I killed at least three project after watching Karpathy's talk.
Both of them failed the menu gen test and the software three point o test. They were basically software one point zero plumbing for things the next model release is probably gonna do natively. This, of course, is painful, but it's better just for me to kill them now than to shift them and watch them die in three months time.
But saying that, there are one or two apps that I am doubling down on that hits all four of the criteria up above. I'll be sharing more on that soon. So 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? I want to see how many of us are in the same boat.
No judgment. I'm in it too. If this was useful, subscribe.
I'm doing a follow-up on building agent first infrastructure that goes way deep into the practical side. And if you want the actual playbooks I use building with agents, go and check out the Switch Dimension Lose Neller and community. They are linked below.
I've also linked to Karpathy's full talk down below. I'm supposed to link one of my own videos, so you go there and watch one of those next, but I highly recommend checking it out. And I've also got a ton of other videos on this topic on the channel.
The Hook
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.
01:50model
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.
Steal forany framing video, sales page, or pitch where you want to make a 'this is a paradigm shift' argument feel earned
04:00concept
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.
Steal forkilling your own side projects honestly; pitching consulting clients on whether to keep or kill a feature; framing a thought-leadership post
09:35list
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.
Steal fora list-style short, a newsletter spine, a course module map, a personal kill-or-keep checklist
06:32list
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.
Steal forvertical AI startup ideation; client briefs in agencies; deciding which side project to take seriously
07:50list
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.
Steal forengineering team standards; AI-builder course module; LinkedIn carousel on 'what good looks like in 2026'
How they asked for the click.
VERBAL ASK
13:32subscribe
“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.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
