How to Learn to Code in 2026: Ryan Carson's Complete Guide

Ryan Carson spent roughly 25% of his entire life in the coding education business. He built Treehouse, an online school that taught over a million students how to write software from scratch. Before that, he ran in-person workshops with 30 people in a room, led by instructors like Cal Henderson (the creator of Slack teaching a PHP class, if you can believe it).

That world is gone.

Not because people stopped wanting to build things. If anything, the desire has exploded. But the how has fundamentally shifted. When Carson joined us on The Neuron: AI Explained this week, alongside co-host Corey Noles, the conversation kept circling back to a simple realization: the old learning loop (read → type → break → fix → repeat) has been replaced by something closer to a conversation.

And GPT-5.4 dropped mid-stream, so we got to road-test it in real time. Here's everything we learned.

First up, the tl;dr

The traditional loop (read docs → type code → break it → Google the error → repeat) used to cost an hour per question. Now you ask an AI agent. It answers in seconds. And Carson's surprising claim: you learn more this way, not less.

So what do you actually need to know? Carson's hierarchy:

• How LLMs work. Not at the PhD level. Just tokens, weights, and next-word prediction. "Because you're using the tool, it helps to understand how the tool works."
• Security hygiene. The models won't always catch your mistakes. His go-to prompt: "Am I doing anything dumb?"
• One level below. Understand roughly how Git, branches, and testing work. Don't worry about specific languages; the agents pick those.

What you don't need: libraries, frameworks, or networking knowledge. "The models are picking everything," he said.

We tested GPT-5.4 live, building Cat Doom in Codex. The first attempt produced orange spheres instead of cats, proving the visual feedback loop is still the biggest bottleneck. Carson thinks it'll be solved by year's end.

The most striking detail: Carson just closed a $2M seed round for his startup Untangle and isn't hiring anyone. He's building the product solo with AI agents. The math he keeps coming back to: you only need 250 people paying $20/month to make $5K/month. That's 250 people in the entire world.

In 2006, building that product required a team and VC money. In 2026, you need a $20 subscription and a weekend.

FULL BRIEF: Read the complete playbook with every tool, tip, and timestamped moment below.

Part 1: Foundations (What You Actually Need to Know)

The old learning loop (read the docs → type the code → break it → Google the error → repeat) is dead. Each question used to cost you an hour. Now you ask the agent and it answers in seconds.

But that doesn't mean you can skip understanding entirely. Here's Carson's hierarchy of what still matters, from most to least important:

1. Understand how large language models work

This is Carson's #1 recommendation, above everything else. Not at the PhD level. Just the basics: these models predict the next token (if you say "peanut butter and..." you say "jelly"), they're trained through millions of corrections, and the underlying math is matrix multiplication with weights and biases.

Why it matters: You're using these tools every day. Understanding how they work makes you better at using them. Carson compared it to how knowing how a car engine works (even loosely) makes you a better driver.

Your homework: Open your favorite AI tool right now and say "How does a large language model work?" Have a 10-minute conversation about it.

2. Learn basic security hygiene

The models will build things for you. They will not always catch when you've done something dangerous. Carson's biggest concern: people storing API keys and environment variables in plain text where anyone can see them. That's like writing your bank password on a Post-It note stuck to your laptop.

The prompt you need to memorize: "Am I doing anything dumb? Look through my code and tell me if we've made any stupid mistakes."

Run this regularly. Especially before you deploy anything to the internet. "You don't know what you don't know" was a refrain of the entire conversation.

3. Know one level below where you're working

Carson cited Boris Cherny (creator of Claude Code): it's always good to understand one level below whatever abstraction you're using. You don't need to know assembly language. But if you're directing an AI agent, a rough understanding of how software development works gives you more leverage.

That includes a basic grasp of:

• Git / version control — How to track changes and undo mistakes. The agents know how to use Git; you just need to know that it exists and to ask about it.
• Branches — Think of your codebase as a tree. The main trunk is your working app. You create a branch to try something new, and if you like it, you merge it back in. If it's a bad idea, you delete the branch and the main trunk is untouched.
• Testing / TDD — Writing tests means defining what should happen ("when I click this button, X should appear") and then verifying it does. This is called test-driven development: write the test first, then build the thing that makes the test pass.

4. What you DON'T need to worry about

Carson was clear about what beginners can safely ignore:

• Specific programming languages. The agents pick them. The current default is TypeScript for most things. Let the agent handle it.
• Libraries and frameworks. These are abstractions the agent chooses based on what's best for your project. You don't need to memorize React vs. Vue vs. Svelte.
• Networking details. Carson admitted his own understanding of networking is "so minimal" and it hasn't been a problem.
• Deployment specifics. Tools like Vercel abstract this away. Carson said: "I think my app is running on the edge somewhere. I don't know how that happens or what that even really means."

Part 2: How to Start

Step 1: Pick one tool

Don't agonize. Just pick one. They're all basically free to start:

• Total beginner, never coded before: Start with Replit. Carson's top recommendation. It handles deployment, hosting, and infrastructure so you never have to think about it.
• Beginner who wants to learn more: Try v0 or Lovable. Corey found v0 great for walking through errors with easy one-button deploy. We did a full deep-dive with Vercel's CPO Tom Occhino where he built a sophisticated portfolio tracker from a single prompt; it's a great intro to what's possible.
• Ready for more control: Use Codex (OpenAI's coding agent app) or Claude Code. More powerful but more to manage. Carson called Codex the best app experience so far. Grant prefers Claude Code to avoid lock-in.

Carson's key principle: the tool matters less than the act of starting.

Step 2: Think of something fun to build

Not useful. Fun. A game. A joke app. A gift for someone. Something that will hold your attention through the frustrating parts.

"The key is to think of something fun that you want to create," Carson said. "And then once you've done it, you can start to iterate on it."

Step 3: Build it together with the AI

Talk to the agent like a colleague. When you hit something confusing, open a second thread (or a separate chat) and ask "What is [thing I don't understand]?" while the main build keeps running.

Carson demonstrated this live: while Codex was building a chess game in one thread, he opened a second thread to ask "What is Three.js?" and got a quick explainer without interrupting the build.

This is the new learning model. Just-in-time learning. You learn what you need to know exactly when you need to know it.

Bonus learning hack from our v0 stream: After you build something, download the code and take it to a separate chat (ChatGPT, Claude, wherever). Ask it to walk you through what each function does, line by line. Tell it you're a new engineer and you want to stay in your proximal zone of difficulty. Repeat back what you learned in your own words so it can correct your understanding. You're not just building; you're actively training yourself.

Step 4: Deploy it

Getting something live on the internet is where most people get stuck. But you just have to remember: every time you ask "how do I...?" you ask the agent.

"All of your questions can be answered by the agent," Carson said. "That turns out to be the hack."

If you're on Replit or v0, deployment is one click. If you're on Codex, tell it: "Make this a one-click executable that I can run on my computer." Carson learned this tip the hard way.

v0 bonus: When you hit publish, v0 compiles and deploys your app globally on Vercel's infrastructure with SSL automatically configured. You get a live URL instantly. It even has built-in versioning (every change creates a new version you can revert to), a point-and-click editor for quick tweaks, and a design panel where you can swap colors, fonts, and border radius without writing code. And if v0 catches its own bugs, it fixes them for free without spending your tokens.

Step 5: Pay for a subscription

Carson was emphatic about this. "Cancel Netflix or whatever thing you've got that's taking up your $20 and pay for one of these tools, whether it's ChatGPT or Claude." The gap between free and paid tiers is enormous.

"We live in a world now where you have these tutors running around. You do not want the free tutor. You want the one you're going to pay."

Part 3: Pro Tips (Ryan's Prompts, Phrasing, and Advice)

These are specific, actionable tips Carson shared throughout the stream. Each one comes from his daily workflow building Untangle.

Planning before building

Use plan mode. Before you start building anything complex, switch to plan mode (in Codex: type /plan). Chat with the model about what you want. Let it ask you questions. Get a plan document, then reference that plan when you start building with the @ symbol.

If you're on v0, use the "Enhance Prompt" button. Before hitting generate, click the enhance button and v0 will expand your vague request into a detailed spec with features you didn't think to ask for. Vercel CPO Tom Occhino's workflow: type a rough idea, hit enhance, review what it added, then generate. This alone can save you multiple back-and-forth iterations. Also: brainstorm in a cheaper tool first. Corey's approach is to workshop ideas in ChatGPT (which doesn't burn v0 credits), get the prompt tight, then bring the polished version into v0.

Break big projects into chunks. Corey learned this the hard way: he fed v0 a 3,000-word prompt on his first attempt and immediately hit problems. The fix was having ChatGPT break the project into 25 steps and feeding them one at a time. "Just like clockwork, they fell right over."

Carson's approach for features: create a PRD (product requirements document) → break it into tasks → then build task by task. He has a public GitHub repo for this workflow.

Giving better instructions

"Make it a one-click executable." When you ask the agent to build something, specify that you want to be able to run it with one click. Assume you know nothing. Otherwise you'll end up needing to type terminal commands you don't understand.

"Include the instructions on screen." For games especially, always tell it to display key bindings and controls on the screen. Carson: "Always tell it to include the instructions or key bindings on the screen. I figured that out the hard way."

Always go extra-high reasoning. Carson always sets reasoning effort to maximum. "You end up spending more time going in circles when you choose a lower reasoning model." It takes longer but wastes less time overall.

"Follow best practices." A viewer tip that Carson endorsed. Append "follow best practices" to your prompts. Simple but effective.

Read Vercel's prompting guide. If you're using v0 specifically, Vercel published a guide on how to prompt v0 that covers what works and what doesn't. Worth a quick read before you burn credits on vague requests.

Spec-driven development still matters. Being specific about what should happen ("when I click the button, a shot comes out and hits the cat, and when the cat dies it blows up") produces dramatically better results than vague prompts. The more the model assumes, the less likely it matches what you want.

Debugging and feedback

"Have I done anything stupid?" Carson's go-to security audit prompt. Run it before deploying anything.

Screenshot feedback. When the output doesn't look right, take a screenshot and paste it into the chat. Say exactly what's wrong: "The cats are balls. Make them look more like cats." The more specific your visual feedback, the better the fix.

Use Agentation for front-end work. Agentation is a free React annotation tool. Click on any UI element in your browser, write a note like "needs more padding" or "make this darker," and it generates structured markdown with the exact CSS selectors and context. Paste that into your agent and it knows exactly what to fix. Carson: "Can't recommend it enough."

Carson's "loop fix" skill. He built a custom Codex skill that tells the agent: reproduce the problem → try to fix it → verify the fix → loop again. "It sounds dumb but the feedback loop problem is real."

Use Agent Browser. Vercel's Agent Browser is "like Playwright on steroids." Good for end-to-end testing where the agent actually clicks through your app.

Managing multiple workstreams

Three checkouts of the same repo. Carson keeps three copies of his codebase in different folders. Folder 1 stays on the main branch for hotfixes. Folders 2 and 3 are for feature branches. This way he's never risking his working app while experimenting.

Queue messages. In Codex, you can type a message while the agent is working and hit Cmd+Enter to queue it. The agent sees it when it's done with its current task without interrupting the current flow. "When I'm doing frontend work, I do this a lot."

Steer the model on the fly. You can now send messages to the agent while it's working without stopping it. Use this to redirect or add context without halting the build.

Testing and automation

End-to-end testing with computer use. You can now have the agent test your app by actually using it, clicking buttons, navigating pages, filling forms. Carson has a daily automation: Codex signs up for an Untangle account, completes onboarding, reports any issues, and deletes the test user. Every morning at 9 AM. No human involved.

Red-team your own site. You can set up automations that probe your app for security vulnerabilities. "Can't you set it up where it basically red teams your site for you? Yeah. You can do all this."

Managing agents is managing people. Carson's closing insight: "It turns out you have to specify, then check, then give feedback. It's really just managing agents now like you would manage people." Set them up like an org chart. The future is managing teams of agents.

Claude Code's new /loop command. Announced the same day, /loop lets you schedule recurring tasks for up to three days. Examples: "/loop babysit all my PRs" or "/loop every morning give me a Slack summary."

Part 4: Ryan's Complete Tool Stack

Every tool, skill, and resource Ryan mentioned on stream, with context on what each does and when to use it.

Coding Agents

• Codex — OpenAI's dedicated coding agent app. Carson's primary tool. Think of it as OpenAI's version of Cursor with a dedicated desktop app. He pays for the $200/month tier because he's building a company. (Demo starts here)
• Claude Code — Anthropic's terminal-based coding agent. Grant's preference. Carson said: "I really like the Codex app experience, but my preference is Claude Code."
• OpenClaw — Carson uses this as a chief of staff with its own email and GitHub account. He sets it up with the Google Workspace CLI for Gmail and Google services. "When it works right, it's magic."

Building & Deployment

• Replit — Best for beginners. Handles everything from code to deployment. (Recommendation at)
• v0 — Vercel's AI coding tool. Great for starting and learning. Has an enhanced prompt feature, built-in design editor, one-click deploy, database integrations (Superbase, Neon, AWS), GitHub connection, and even an iPhone app so you can monitor builds from your phone. Check out templates for inspiration. Runs on multiple LLMs including Claude Opus and GPT-5 via Vercel's AI gateway.
• Vercel — Hosting / deployment. Codex has a one-button Vercel deploy built in.
• GitHub — Version control in the cloud. Where your code lives. "Git for people who don't know: GitHub is taking the Git tree functionality and putting it on the cloud."

Productivity

• Wispr Flow — Voice-to-text dictation. Carson uses it to talk to Codex rather than type. Works in any app.
• Agentation — Visual annotation for UI feedback. Click elements, write notes, copy structured output to your agent. Free, open source.
• Agent Browser — Vercel's browser automation CLI. "Like Playwright on steroids." Great for end-to-end testing.
• Skills.sh — Directory for discovering and installing agent skills. Think of it like an app store for agent capabilities.

Game Development

• Godot — Open-source game engine. The free alternative to Unity. Uses scenes as its core organizational concept.
• Godot MCP server (Coding-Solo) — Lets AI agents interface directly with the Godot editor: launch projects, edit settings, create assets.
• Godot MCP server (Derfirm) — A second MCP option with similar capabilities.
• Brackeys Proto-Controller — Pre-built first-person character controller for prototyping FPS games in Godot.

Skills (Agent Instructions)

Carson stores all his skills in a Git repo in his home directory. When he got a new MacBook, he cloned the repo and had everything back instantly. Key skills he mentioned:

• PRD skill — Guides the model through an interview process to create a product requirements document before building.
• Loop fix skill — Custom skill: reproduce the problem → fix it → verify the fix → loop.
• Figma implement design skill — Takes a design from Figma and writes the corresponding code.

His advice: "Install a few. Don't install too many." You can find community skills at Skills.sh or browse the official OpenAI skills catalog.

Skills vs. MCPs: Carson says skills are "somewhat replacing MCPs." They're more portable, just text files you can check into Git. The exception: tools that need reliable API calls (like the Figma MCP) still need to be MCPs. But for most workflows, a SKILL.md file is becoming the standard.

The Math That Should Change Your Mind

Carson closed with an idea that reframes the entire conversation. He credited it to DHH (creator of Ruby on Rails), who told him this 20 years ago:

If you have a problem you can solve with software and you want to make $5,000 a month, you just need 250 people in the whole world willing to pay $20/month.

Let's run the numbers for 2026:

• 250 customers × $20/month = $5,000/month ($60K/year). That's a living.
• ~1,042 customers × $20/month = ~$250K/year. That's a very comfortable living.

Finding 1,042 people in the entire world who share a specific problem you can solve? That's not a fantasy. That's a niche product with a targeted audience.

And here's what's changed: in 2006, building that product required a team, months of development time, and often venture capital. In 2026, you need a $20 AI subscription, a free tool like Replit or v0, and the willingness to spend weekends iterating.

Carson just closed a $2M seed round for Untangle and isn't hiring anyone. He's building the entire product with AI agents. When he does eventually hire, "I'm definitely not hiring a junior."

The need for software engineers will explode. But wages will compress. The leverage of knowing how to code isn't what it used to be, because now everyone has access to it.

So the question isn't whether you can build software anymore. Everyone can. The question is whether you'll be the one solving a problem that 250 people care about... or the one still paying someone else $20/month because you didn't start.

The Old Way vs. The New Way

Carson described the traditional coding education pipeline in blunt terms. You'd take a course. You'd read about it. You'd type the code. You'd try to run it. It would break. You'd Google the error. You'd find a Stack Overflow answer from 2014. And you'd repeat that loop for hours.

Each question used to cost you an hour.

Now? You ask the agent. It answers in seconds. And here's the part Carson emphasized: you actually learn more this way, not less. When Carson fired up Codex (OpenAI's coding agent app) and screenshared a chess game build live on stream, he opened a second thread just to ask "What is Three.js?" while the first thread kept building. Side-by-side learning and building, simultaneously.

Corey made the same point from personal experience. A year ago, his coding skills topped out at a GeoCities HTML page from the mid-'90s. Now he's building functional apps in v0 and spinning up agents in the CLI. "I learn in bite-sized nuggets as I need it," he said. "Just-in-time learning."

That phrase kept coming back: just-in-time learning.

What You Actually Need to Know in 2026

We pressed Carson on this directly: if you're a knowledge worker with no engineering background, what are the foundational concepts that still matter?

His answer surprised us. It wasn't "learn Python" or "understand data structures." His hierarchy:

1. Understand how large language models work. Not at the PhD level. But you should know that these models predict the next token, that they're trained through massive repetition, and that weights and biases are just numbers shaped by millions of corrections. "Because you're using the tool," Carson said, "it helps to understand how the tool works."

His homework assignment for everyone watching: open your favorite AI tool and say "How does a large language model work?" Then just... have a conversation about it.

2. Learn basic security hygiene. This is the one that keeps Carson (and, frankly, all of us) up at night. The models will help you build things. They will not always remind you that you're storing API keys in plain text where anyone can see them. Carson's advice: regularly ask your agent "Am I doing anything dumb? Look through my code and tell me if we've made any stupid mistakes."

The models are getting better at catching these things. But you need to know to ask. "You don't know what you don't know" was a refrain of the whole conversation.

3. Know one level below where you're working. Carson referenced an interview with Boris Cherny (the creator of Claude Code): it's always good to understand one level below whatever abstraction you're using. You don't need to understand assembly language. But if you're using an AI coding agent, understanding roughly how software development works (version control, deployment, testing) gives you more leverage.

What you don't need to worry about: libraries, frameworks, specific programming languages. "The models are picking everything," Carson said. "The current right now is TypeScript. If you're building anything that can be TypeScript, just let the agent do it."

The Live GPT-5.4 Test (And What It Revealed)

GPT-5.4 launched during our stream, so we did what we always do when a new model drops: we tried to build the game Doom, but with cats.

(Yes, really. It's our tradition. We've done it in Google AI Studio and Claude. The prompt is always the same: "Make the game Doom but with cats.")

Round 1: GPT-5.4 on Extra High Reasoning

Carson fired up Codex with GPT-5.4 on extra-high reasoning effort. The model automatically created task lists (which appeared to be a new feature, possibly from 5.4's post-training). It scaffolded a React app using Three.js, implemented a 3D chessboard, and added automated tests.

The result: A tiny, over-engineered chess game with an unusable UI. The board worked but was microscopic, buried under unnecessary UI elements.

Carson's takeaway was instructive: "The idea that you spend three minutes and get something amazing and perfect is just not real." It takes hours. Or weeks. Or months.

Round 2: Plan Mode + Feedback Loop

We tried again, this time using plan mode (where you chat with the model to create a spec before building). Carson asked us to play product owner. We specified: Doom but with cats, one-click executable, instructions on screen, WASD movement with spacebar to shoot.

The model chose to build it in Godot (the open-source game engine), which was an interesting autonomous decision. We installed a Godot MCP server to give the agent direct access to the engine, plus a second MCP option for additional capabilities.

First attempt: Black screen. No movement. Health and ammo displayed, but nothing else.

After one feedback loop (telling the agent the game was broken, the 3D environment wasn't working): The model discovered the arena was "effectively filled with giant invisible slabs" due to collision objects using the full floor collision box. It fixed the collision issue, brightened the materials, and suddenly... we could walk around. We could see enemies. We could shoot.

After a second feedback loop (sending a screenshot showing the enemies were orange spheres, not cats): The model replaced the spheres with low-poly cat shapes built from primitive meshes. They actually looked... cat-like. Not great. But recognizably feline.

The progression demonstrated something important about the current state of AI coding: the visual feedback loop is the bottleneck. The model built something it thought was a cat. It had no way to verify that what it created was actually an orange sphere. Only when we (the humans) closed that loop with a screenshot did it fix the problem.

Carson is convinced this will be solved by end of year. "The most basic thing," he said, "is: can I see what I did, and is it good, in a reliable, non-flaky way?"

The Tools That Actually Matter

Throughout the stream, Carson and Corey dropped a bunch of specific tools and workflows. Here's the complete list with context on what each does and when to use it:

For Beginners

• Replit — Carson's top recommendation for true beginners. Handles deployment and hosting so you don't need to understand infrastructure. "If you truly are a newbie, Replit could actually be really good because they take care of all the complexity."
• v0 — Corey's starting point. Great at walking you through errors and has one-button deploy. We did a full live demo with Vercel CPO Tom Occhino where he built a sophisticated portfolio tracker from a single prompt, complete with interactive charts, sortable tables, and a watch list. v0 features worth knowing: an enhanced prompt button that expands your vague idea into a detailed spec, built-in design controls for colors and fonts, one-click database integration with Superbase, and automatic bug detection that fixes itself for free. Check v0.app/templates to skip the blank canvas entirely.
• Codex — OpenAI's coding agent app. Think of it as OpenAI's Cursor. Best app experience so far according to Carson. Good for more serious projects where you want control.

For the Workflow

• Wispr Flow — Voice-to-text dictation tool. Carson uses it to talk to Codex instead of typing.
• Agentation — A free React annotation tool that lets you click on UI elements in your browser and generate structured feedback for AI agents. Instead of describing "the blue button in the sidebar," you click it and Agentation captures the exact CSS selectors and context. "For front-end work, can't recommend it enough," Carson said.
• Agent Browser — Vercel's browser automation CLI for AI agents. Like Playwright on steroids. Useful for end-to-end testing. Carson called it "a very, very good tool."
• Skills.sh — A directory for discovering and installing reusable agent skills (the SKILL.md format used by Claude Code, Codex, and others). Carson recommended installing a few but cautioned against too many.

For Game Development

• Godot — The open-source game engine. Think of it as the free alternative to Unity. Carson and I both use it; I've been teaching myself GDScript through Claude.
• Godot MCP servers — Lets AI agents edit Godot projects directly, including running the game, creating 3D assets, and modifying settings.
• Brackeys Proto-Controller — A simple first-person character controller for prototyping FPS games in Godot. Good for getting movement working quickly.

Skills vs. MCPs: What's Replacing What?

One of the sharpest exchanges came from an audience question: are skills replacing MCPs (Model Context Protocol servers)?

Carson's answer: mostly yes.

"Skills are somewhat replacing MCPs," he said. "They're more portable. They're easy to use. They're just text. You can literally check them into Git." He stores all his skills in a Git repo in his home directory. When he got a new MacBook, he just cloned the repo and had everything back instantly.

The exception: some tools genuinely need MCPs because they require reliable API endpoint calls. The Figma MCP, for example, can't easily be reduced to a text skill. But for most workflows, a well-written SKILL.md file is becoming the standard unit of agent capability.

Think of it like this: an MCP is a live API connection. A skill is a set of instructions the agent loads when it needs them. Skills are lighter, more portable, and don't require running a server.

The $2 Million Solo Founder

Midway through, Carson casually dropped that he just closed a $2M seed round for his new startup, Untangle (a product helping people navigate divorce more affordably). The kicker: he's not hiring anyone.

"That's awesome," he said, then caught himself. "And it's sort of like... wow, that's weird."

Weird because in every previous company he's built, raising money meant immediately building a team. Now he's a solo technical founder using AI agents for most of the engineering work. And when he does eventually hire, "I'm definitely not hiring a junior."

This led to a broader conversation about what happens to the software engineering job market. Carson and I agreed on the diagnosis: the demand for software will explode, but wages will compress. More people can build now, which means the leverage of knowing how to code isn't what it used to be.

Carson's optimistic version of this future: an explosion of small, useful apps built by individuals. People who can't get hired as engineers at big companies build tools that solve problems for 250 people willing to pay $20/month. That's $5,000/month. That's a living.

He credited the framing to DHH (creator of Ruby on Rails), who told him 20 years ago: "If you have a problem you can solve with software and you want to make $5,000 a month, you just need to find 250 people in the whole world who need it."

In 2026, building that software is orders of magnitude easier than it was in 2006. Run the math further: ~1,042 people paying $20/month gets you to $250K/year. Finding 1,042 people in the entire world who share a specific problem? That's a niche product, not a fantasy.

And the deployment gap that used to block vibe coders is closing fast. Tools like v0 now handle one-click global deployment, automatic SSL, built-in databases, and even auto-detect and fix their own bugs. As Vercel CPO Tom Occhino told us, they've been building this infrastructure for a decade; v0 just sits on top. You get Fortune 500-grade hosting from a single publish button.

Automations: The Real Unlock

Carson's Codex setup includes something most beginners haven't touched yet: automations. These are recurring tasks that run on a schedule without human intervention.

His example: every day at 9:00 AM, Codex signs up for an Untangle account, runs through the entire onboarding flow, sends him a report on any issues, and then deletes the test user. Automated end-to-end testing that he used to have to assign to a QA person.

This maps to a broader trend. Just this week, Claude Code launched /loop, a new command for scheduling recurring tasks that run for up to three days. Examples from the announcement:

• "/loop babysit all my PRs. Auto-fix build issues and when comments come in, use a worktree agent to fix them"
• "/loop every morning use the Slack MCP to give me a summary of top posts I was tagged in"

And it's not just code. Nat Eliason's OpenClaw agent Felix has been running its own business, generating tens of thousands of dollars in revenue with minimal human oversight. Felix has its own X account, its own Stripe account, and autonomously builds and sells digital products. (Watch his full tutorial and in-depth interview on how it works.)

When we mentioned Felix on stream, Carson lit up. He's been using OpenClaw as a chief of staff, giving it its own email address and GitHub account. "When it works right, it's magic," he said. "When I hire, I'm not hiring a junior."

The Feedback Loop Problem (And Why It'll Be Solved)

If there was one theme that unified the entire two-hour conversation, it was this: the biggest bottleneck in AI-assisted development is the feedback loop between what the agent builds and what humans can see is wrong.

The cat Doom experiment made this visceral. The agent built enemies that it believed were cats. They were orange spheres. The agent had no way to know this. Only human vision, communicated back through screenshots and natural language, closed the gap.

Carson's CI (continuous integration) pipeline for Untangle includes a step where the agent records itself using a feature and attaches the video to pull requests for review. "It works like 20% of the time," he admitted. Flaky, but directionally correct.

The good news: computer use capabilities are improving rapidly. GPT-5.4's release notes emphasized better tool use and computer interaction. Claude Code can now request accessibility permissions to control your machine. These are incremental steps toward agents that can look at their own work and ask "does this actually look right?"

Carson's prediction: "I'm convinced this loop will be solved probably by the end of the year." When it is, the gap between "building a prototype" and "shipping a product" will shrink dramatically.

Five Things to Do After Reading This

If you're a knowledge worker who's been AI-curious but hasn't taken the leap into building:

1. Pick one tool and build something fun. Not useful. Fun. A game, a joke app, a gift for someone. Replit if you're brand new, Codex or Claude Code if you want more control. The tool matters less than the act of starting.

2. Learn how LLMs work. Open your favorite AI tool and ask it to explain itself. Understand tokens, weights, training. It takes 15 minutes and makes everything else click.

3. Get a paid subscription. Carson was emphatic: "Cancel Netflix or whatever thing you've got that's taking up your $20 and pay for one of these tools." The difference between free and paid tiers is enormous, and you do not want the free tutor.

4. Ask your agent "Am I doing anything dumb?" Regularly. Especially before you deploy anything. Security hygiene is the one thing the agent won't volunteer unprompted.

5. Follow Ryan Carson on X. He posts daily about building with AI agents, doesn't charge for courses, and shares his full workflow publicly. Check out his articles on agent workflows, his Code Factory workflow, his posts on agent teams in OpenClaw, and how he has agents that ship while he sleeps. Subscribe to his newsletter for regular updates.

STEP-BY-STEP GUIDE: Read our full 101 guide with every tip, tool, and prompt from this episode.

Related: What Else Dropped This Week

• GPT-5.4 rolled out in ChatGPT, the API, and Codex. Early reactions (including from Matt Shumer) call it the best model available, with major improvements in reasoning, agentic workflows, and computer use. Coding improvements over 5.3 Codex appear modest; expect a dedicated 5.4-Codex release soon.
• Claude Code /loop launched the same day, enabling scheduled recurring tasks in the CLI. Boris Cherny (Claude Code creator) suggested use cases like auto-monitoring PRs and generating morning Slack summaries.
• Nat Eliason's autonomous AI business keeps growing. His OpenClaw agent Felix has generated tens of thousands in revenue building and selling digital products with minimal human oversight. Watch his full tutorial on building a self-running business with OpenClaw and his interview on the concept.
• The conversation around agent-first software design is accelerating. CLIs are becoming the preferred interface for AI agents (because models are heavily trained on bash commands), and companies like Google are shipping Workspace CLIs specifically for agent consumption.

This article is based on The Neuron: AI Explained livestream from March 5, 2026, featuring Ryan Carson, Grant Harvey, and Corey Noles. Watch the full episode for live demos, audience Q&A, and Carson's real-time reactions to GPT-5.4.