Latest / Elon Musk Podcast / AI UPDATE: Vibe coding, what is it?

Transcript

AI UPDATE: Vibe coding, what is it? · Elon Musk Podcast

• 0:00
  Clairvaux shipped 44 poll requests containing 93,000 lines
• 0:05
  of code. Wow.
• 0:06
  Yeah, and that was across more than 1000 files in just five
• 0:11
  days using Open AI's codecs and Anthropics Claudopis 4.6.
• 0:16
  I mean, the sheer scale of that achievement really highlights a
• 0:20
  massive transition happening right now.
• 0:22
  Absolutely, because software engineering is it's shifting
• 0:25
  away from those simple auto complete tools toward fully
• 0:28
  agentic orchestration, right where developers coordinate AI
• 0:32
  systems rather than, you know, just writing code line by line
• 0:35
  themselves. So how do you choose between an
• 0:37
  AI that acts like an interactive intern and one that operates as
• 0:41
  a completely autonomous manager for your digital workforce?
• 0:44
  Well, to understand how a single person even ships 93,000 lines
• 0:48
  of code, we first have to look at the interface where the work
• 0:52
  actually happens, right? Which splits into two radically
• 0:55
  different philosophies. Yeah, we are looking at a
• 0:56
  fundamental split between tools like Cursor and clawed code.
• 1:00
  Let me describe how Cursor operates for a second.
• 1:03
  It is an AI native code editor, which means you are working in a
• 1:08
  highly visual environment. Right, very visual.
• 1:10
  Focused entirely on interactive editing, you have features in
• 1:14
  there like Composer. Which is huge.
• 1:16
  Which handles multi file edit simultaneously and supermaven
• 1:20
  which provides this incredibly fast autocomplete.
• 1:24
  And when we say fast I mean we mean sub 100 millisecond
• 1:28
  latency. Which is wild to think about.
• 1:29
  It is that speed is crucial for the visual approach though.
• 1:33
  Because you need it to feel instant.
• 1:34
  Exactly. Sub 100 millisecond latency
• 1:37
  means the AI is suggesting the next block of logic before you
• 1:41
  even finish typing the variable name.
• 1:42
  You don't perceive a delay at all.
• 1:45
  Right cursor gives you immediate visual feedback on every single
• 1:48
  change. You literally see the diffs.
• 1:50
  Yeah, the exact lines being added or removed.
• 1:53
  You accept or reject them and you stay constantly engaged with
• 1:57
  the text on the screen. It feels very much like
• 1:59
  traditional programming. Just, you know, supercharged.
• 2:02
  Right, because you are looking directly at the code.
• 2:04
  But Claude Code Opera, it's entirely differently.
• 2:07
  Totally different. It is a terminal native command
• 2:10
  line interface. Yeah, there is no traditional
• 2:12
  editor window for the AI. It relies on deep code based
• 2:17
  reasoning, recursive context gathering and a specific plan
• 2:22
  mode to outline strategies before writing anything.
• 2:25
  So instead of sitting inside your visual editor, Claude Code
• 2:28
  lives in the terminal. Just that black screen with a
• 2:31
  blinking cursor. Exactly.
• 2:32
  It sits alongside whatever text editor you prefer, but it
• 2:35
  doesn't need to look at your active window, right?
• 2:37
  When you give it a command, it performs what we call recursive
• 2:40
  context gathering. Explain how that actually works
• 2:43
  for the listener, because I mean, recursive context
• 2:46
  gathering sounds incredibly dense, yeah.
• 2:48
  No, it does sound technical. Think of it like sending a
• 2:51
  detective into an archive room. OK, if you ask the AI to fix a
• 2:55
  bug in a specific feature, it doesn't just look at the one
• 2:58
  file you have open. Because it can't even see the
• 3:01
  file you have. Open right, It starts at the
• 3:03
  feature, reads the code, notices a function pulling data from
• 3:07
  somewhere else. Oh, I see.
• 3:09
  And follows that thread into your database schema.
• 3:12
  Wow. Then it reads the schema,
• 3:14
  realizes there is an authentication rule attached to
• 3:16
  it, and goes and reads the security security file.
• 3:19
  It just keeps. Digging it recursively follows
• 3:21
  the logic through the entire tree of your project until it
• 3:25
  has all the context it needs. All before it executes a single
• 3:28
  command. Exactly.
• 3:30
  I look at it this way, cursor is like having a driving instructor
• 3:34
  in the passenger seat with dual controls.
• 3:36
  That's a good way to put it. Now you are both steering.
• 3:38
  You are both looking out the exact same windshield, right?
• 3:41
  And if the instructor veers too close to the curb, you can grab
• 3:45
  the wheel and intervene instantly.
• 3:47
  Because you see it happening in real time.
• 3:49
  Exactly. But Claude code is like handing
• 3:52
  a mechanic a list of instructions and sending them
• 3:55
  into the garage alone. Yeah, you just sit in the
• 3:57
  waiting room until the car is fixed.
• 3:58
  Which is stressful for some people.
• 4:00
  Oh totally, But by giving up the visual control of an editor,
• 4:04
  aren't you severely increasing the risk of the AI writing
• 4:08
  faulty code that you can't easily monitor?
• 4:11
  I mean, I understand that fear. It feels completely unnatural to
• 4:13
  let go of the wheel like that. Yeah, but doing so shifts the
• 4:17
  developer's role from writing syntax to specifying intent,
• 4:21
  right? Yes.
• 4:22
  It limits your immediate visual feedback.
• 4:25
  You aren't watching the letters appear on the screen.
• 4:27
  Which is what we're all used to. But it opens up the ability to
• 4:31
  execute massive complex refactors across an entire
• 4:35
  project structure. Because it isn't waiting for
• 4:37
  your approval on every single line.
• 4:39
  Exactly when the AI is not constrained by what is currently
• 4:43
  visible in your active editor window, it can apply logic to
• 4:47
  hundreds of files sequentially just.
• 4:49
  Ripping through them. Yeah, and that is where plan
• 4:52
  mode comes in. You verify the architecture in
• 4:55
  plan mode. So it tells you what it's going
• 4:56
  to do first. Right, the AI prints out a step
• 4:59
  by step strategy of what it intends to change across the
• 5:03
  entire code base. OK, you review that high level
• 5:06
  plan, you approve it, and then the agent handles all the syntax
• 5:09
  on its own. Wait, back up.
• 5:10
  Yeah. How does the terminal agent
• 5:12
  actually know what to do without seeing the screen?
• 5:14
  What? Do you mean?
• 5:15
  Well, I like the mechanic analogy, but there is a hole in
• 5:17
  that logic. OK, let's hear it.
• 5:19
  Handing a mechanic a lift of instructions only works if the
• 5:22
  mechanic actually knows where the tools are kept.
• 5:26
  If they walk into a strange garage, they're going to spend
• 5:29
  hours just opening drawers. Yeah, totally lost.
• 5:33
  How does an AI operating entirely in a text based
• 5:36
  terminal know where your design files are or how your specific
• 5:40
  company structures its databases?
• 5:42
  That mechanism relies entirely on the Model Context Protocol,
• 5:47
  or MCP. MCP, right?
• 5:49
  Anthropic designed MCP to let AI securely connect to external
• 5:53
  data sources. So.
• 5:54
  It's a direct connection. Yes, and it does it without
• 5:57
  developers having to build custom API connections for every
• 6:00
  single tool. So instead of writing, you know,
• 6:02
  brittle glue code to connect your terminal to other
• 6:04
  platforms, MCP provides A standardized bridge.
• 6:08
  Exactly. Think of MCP like a universal
• 6:10
  security badge for your AI, instead of the AI needing a
• 6:13
  completely different set of custom built keys to access your
• 6:16
  Figma designs, your Slack messages, or your Notion
• 6:18
  documents. Which would be a nightmare to
• 6:20
  maintain. Total nightmare.
• 6:22
  MCP gives it a standardized way to walk into those rooms, read
• 6:26
  the files, and pull that knowledge directly into its
• 6:29
  reasoning process. That makes a lot of sense, and
• 6:32
  that leads directly to context. Engineering engineers now write
• 6:36
  specific files in their repositories, usually named
• 6:39
  agents dot MD or Claude dot MD, right, which basically act as a
• 6:45
  project constitution. A rule book.
• 6:47
  Yeah, you use context engineering to lay out the
• 6:50
  architectural rules, the naming conventions, and the strict
• 6:53
  constraints of the repository. So you are building a grounded
• 6:56
  source of truth. Right, so the AI knows the exact
• 6:59
  layout of the garage before it starts working.
• 7:01
  You are literally telling the AI AI.
• 7:03
  Here's how we name our variables.
• 7:05
  Here's the specific database structure we use.
• 7:07
  Do not use this outdated library.
• 7:09
  Giving it the exact lay of the land.
• 7:11
  Exactly. You combine that internal
• 7:13
  constitution with the external access provided by MCP, and
• 7:16
  suddenly the terminal agent has perfect awareness of your entire
• 7:19
  working environment. I want to look at a specific
• 7:21
  example of this because it clarifies exactly how powerful
• 7:24
  this combination is. Yeah, the Notion example.
• 7:27
  Right at Notion, a designer named Brian Lovin used MCP to
• 7:31
  build what he calls a Rototye playground UCH.
• 7:34
  A cool roject. It really is.
• 7:36
  He created a custom command where the AI takes a Figma link,
• 7:40
  extracts the design tokens, writes the code, opens a browser
• 7:44
  to verify it visually, and then loops to fix its own errors.
• 7:47
  And that extraction part is crucial.
• 7:49
  How so? Because of MCP, the AI doesn't
• 7:52
  just look at it like a picture of the design.
• 7:54
  It's not just a screenshot. No.
• 7:56
  It goes into Figma and extracts the literal design tokens, the
• 8:00
  exact hex codes for the colors, the precise pixel measurements
• 8:04
  for the padding, the specific font weights.
• 8:06
  So. It's pulling the raw data.
• 8:07
  It pulls the mathematical truth of the design.
• 8:10
  He even built a custom find icon skill.
• 8:12
  Oh yeah, because Notion has more than 5000 SVG files files in its
• 8:16
  icon library. Right, so instead of the AI
• 8:18
  guessing which icon to use, or, you know, hallucinating a file
• 8:22
  path entirely, which. Happens a lot without these
• 8:24
  skills. Exactly.
• 8:26
  The skill allows the AI to automatically search through the
• 8:29
  entire library, find the exact vector graphic it needs, and
• 8:33
  implement it. That's amazing.
• 8:34
  But the craziest part to me is the verification loop.
• 8:37
  Right, the visual checking. Yeah, how does a terminal AI
• 8:40
  verify a visual prototype? Well, the agent leverages a
• 8:45
  Chrome Devtools MC key. OK.
• 8:48
  This allows the AI to physically interact with the browser.
• 8:52
  It builds the code, renders the prototype in Chrome, and uses
• 8:55
  Devtools to inspect the Dom and analyze the layout.
• 8:58
  So it's actually looking at the page.
• 9:00
  It can essentially look at the prototype it just built, compare
• 9:03
  the CSS output to the original Figma design tokens, realize
• 9:06
  that a button is misaligned or the padding is wrong, and
• 9:09
  correct its own pathing or layout issues.
• 9:12
  It's doing it all itself. It handles the verification loop
• 9:14
  entirely on its own, without a human ever checking the browser.
• 9:18
  This completely removes the traditional handoff from design
• 9:21
  to engineering totally. You no longer have a designer
• 9:24
  creating a mock up, handing it to a front end developer and
• 9:27
  waiting for them to translate it into code.
• 9:29
  Right, the way is gone. ID has become interactive
• 9:32
  working prototypes almost instantly.
• 9:34
  It creates A seamless pipeline and you know once an agent has
• 9:37
  the context to verify its own work visually and
• 9:40
  architecturally, it no longer needs to run on your local
• 9:43
  machine at all. Right, which brings us to Open
• 9:45
  AI codecs operating as a cloud based autonomous agent.
• 9:49
  This is a. Huge shift.
• 9:51
  This is the third major workflow.
• 9:54
  You assign a task and codecs, spins up a sandbox virtual
• 9:57
  machine, close the repository, does the work asynchronously and
• 10:01
  delivers a finished pull request.
• 10:04
  And for context, A sandboxed virtual machine is basically a
• 10:07
  secure isolated room in the cloud.
• 10:10
  Like a safe space for the code to run.
• 10:12
  Exactly. The AI gets its own temporary
• 10:14
  computer. It copies all your code into
• 10:16
  that room and gets to work. That's a great way to visualize
• 10:19
  it. It acts like a slow cooker for
• 10:20
  software features. OK, I like that you set the
• 10:22
  parameters, add your instructions and let it run.
• 10:25
  The meal is ready later, fully cooked and ready to consume.
• 10:28
  Hold on. Yeah, it just runs the code
• 10:30
  itself in the background. What happens if it introduces a
• 10:32
  massive security vulnerability? Well, if I have an AI blindly
• 10:37
  writing and executing code while I am not watching, couldn't it
• 10:41
  accidentally delete a database or expose user data?
• 10:44
  That is exactly why the sandbox is so important.
• 10:47
  Well, because it's isolated. Right.
• 10:49
  The sandboxed execution environment allows codecs to
• 10:52
  safely run tests, execute builds, and verify changes
• 10:55
  before ever presenting the code for your review.
• 10:58
  So not touching your live stuff. It operates in total isolation.
• 11:02
  That means the agent can attempt a complex fix, run the project's
• 11:06
  entire test suite, fail completely, diagnose the error
• 11:09
  message from the failure, and try again.
• 11:12
  Without you even knowing it failed the first time.
• 11:14
  It can do this fifty times in a row without ever affecting your
• 11:17
  local development environment or your production servers.
• 11:20
  And because it connects to the ChatGPT ecosystem, a user can
• 11:23
  spot a bug on their phone. Literally while out of the
• 11:26
  house. Prompt the codecs agent to fix
• 11:28
  it and the agent does the work in the cloud while the user
• 11:31
  orders coffee. Yeah, you are completely
• 11:34
  untethered from your desktop. You don't even need to have your
• 11:36
  laptop open to be actively engineering software.
• 11:39
  This creates true parallelization.
• 11:41
  Which is incredibly powerful. It limits real time
• 11:44
  interactivity just like the terminal agents, but it
• 11:47
  drastically increases total throughput.
• 11:50
  Because you can. You can run so many at once.
• 11:51
  Exactly. It allows a solo developer to
• 11:54
  manage multiple threads of work simultaneously.
• 11:57
  You can have one cloud agent completely refactoring a back
• 12:01
  end database schema while you are interactively styling a
• 12:05
  front end component on your laptop using cursor So.
• 12:08
  You are acting as a manager of multiple digital workers.
• 12:11
  Yes, managing a massive parallelized cloud workforce
• 12:14
  sounds ideal, but running top tier AI models continuously
• 12:19
  presents a massive financial. Oh absolutely, the costs add up.
• 12:22
  If you have autonomous agents recursively searching files and
• 12:25
  running 50 verification loops in the cloud, you are burning
• 12:29
  through compute power. Cost becomes the primary
• 12:31
  bottleneck really quickly, right?
• 12:33
  That introduces the concept of sub agents and tiered model
• 12:36
  execution. Specifically looking at open
• 12:38
  AIS, GPT 5.4 mini and nano models.
• 12:41
  The smaller ones. Right, the mini model scores
• 12:44
  54.38% on the SWE bench pro coding test.
• 12:49
  We should clarify what that test actually is.
• 12:51
  Yeah, go ahead. The SWE Bench Pro is a benchmark
• 12:54
  where the AI is dropped into a massive real world open source
• 12:58
  code base and asked to solve complex issues originally
• 13:01
  flagged by human engineers on GitHub.
• 13:03
  It's a very rigorous test. Extremely.
• 13:06
  Scoring over 54% on that is staggering for a smaller model.
• 13:10
  It is very close to the performance of the massive
• 13:13
  flagship model, but it costs a fraction of the price at just
• 13:16
  $0.75 per million input tokens. Which is incredibly cheap.
• 13:20
  Very cheap. But I mean, delegating work to
• 13:22
  cheaper models seems counterproductive when writing
• 13:25
  production level software. Why do you see that?
• 13:27
  If you are trusting an autonomous agent to write code
• 13:29
  that runs your business, risking the introduction of subtle logic
• 13:32
  errors just to save a few cents on API calls feels incredibly
• 13:36
  risky. I can see that.
• 13:37
  If the goal is reliable autonomous output, cutting
• 13:41
  corners on the intelligence of the model seems like a fast
• 13:44
  track to broken software. You would think so, but the data
• 13:47
  actually proves otherwise. Really.
• 13:49
  Yeah, Notion's AI engineering lead a Besic Modi, found that
• 13:54
  for focused, well defined tasks like formatting, the mini models
• 13:58
  actually exceed the performance of previous flagship models.
• 14:01
  Wait, how is a smaller, cheaper model outperforming a massive
• 14:05
  reasoning engine? It comes down to cognitive load.
• 14:09
  The cognitive load required to parse a document or apply a
• 14:12
  specific formatting rule is narrow.
• 14:15
  Very narrow. When the task is highly
• 14:17
  constrained, the smaller model executes with extreme precision.
• 14:21
  Large models can overthink simple tasks or get distracted
• 14:25
  by the broader context of the repository.
• 14:27
  Because they're trying to do too much at once.
• 14:29
  Exactly. A mini model given one strict
• 14:31
  rule and one specific file just executes the rule.
• 14:34
  Florida State. So the strategy is now tiered
• 14:37
  orchestration. Yes, a senior model like Claude
• 14:39
  Opus 4.6 or GPT 5.4 thinking handles the initial planning and
• 14:44
  complex architectural decisions. Big picture stuff.
• 14:47
  Right then it delegates tasks to junior models like GPT 5.4 Mini
• 14:54
  which execute high volume subtasks such as searching code
• 14:58
  or processing documents. The senior model acts as the
• 15:01
  lead architect. It reads your agents dot MD
• 15:03
  constitution, formulates the strategy, and breaks the project
• 15:07
  down into 50 smaller steps. And then it just hands them out.
• 15:10
  Exactly. It hands those steps to 50
• 15:13
  junior models. The junior models do the heavy
• 15:15
  lifting of reading thousands of lines of syntax, executing the
• 15:19
  repetitive changes and reporting back.
• 15:21
  This changes the entire economic structure of building software.
• 15:25
  It really does. Instead of paying flat
• 15:26
  subscription fees for visual editors where you do all the
• 15:29
  manual typing, engineering teams manage granular API budgets.
• 15:33
  You are optimizing the precise amount of intelligence required
• 15:36
  for every specific task. Because you don't need a genius
• 15:39
  to do formatting. Right, You no longer apply a
• 15:41
  massive expensive reasoning engine to a simple syntax
• 15:45
  update. That makes perfect sense.
• 15:46
  You buy exactly the compute necessary for the complexity of
• 15:49
  the operation, you pay for the architect only when you need
• 15:53
  architecture, and you pay for the intern when you just need
• 15:56
  someone to format the files. Software development is
• 15:58
  fractured into 3 distinct workflows.
• 16:00
  Yeah, interactive visual editing, deep terminal, native
• 16:03
  reasoning, and autonomous cloud execution.
• 16:07
  The defining skill for builders now is orchestrating the right
• 16:11
  agents with the exact right context.
• 16:14
  And as these peered agents become increasingly capable of
• 16:18
  verifying their own work in secure sandboxes, what happens
• 16:21
  to the entry level engineering roles that traditionally handled
• 16:24
  those exact verification tasks? If you're not subscribed yet,
• 16:27
  take a second and hit follow on whatever app you're using.
• 16:30
  It helps us keep making this. We appreciate you being here.