Latest / Elon Musk Podcast / Why engineers stopped writing code

Transcript

Why engineers stopped writing code · Elon Musk Podcast

• 0:00
  Boris Churney, the creator of Anthropic's Clawed code, is
• 0:03
  shipping two dozen pull requests a day without manually editing a
• 0:08
  single line of code. Right.
• 0:09
  Clawed code is now authoring 4% of all public GitHub commits,
• 0:14
  and literally no one at Anthropic is manually writing
• 0:17
  code anymore. I mean, that volume is just hard
• 0:19
  to comprehend if you know how software is actually built.
• 0:22
  Like two dozen pull requests, which are basically packaged
• 0:26
  proposals to change or add to a code base that used to be a
• 0:29
  solid month of work for a senior developer.
• 0:32
  You have to write the code, you test it, document it, send it
• 0:35
  for review. Shipping 24 of those in a single
• 0:38
  day means the entire concept of individual output has just
• 0:42
  fractured. Google is currently generating
• 0:44
  75% of its new code with AI. And Met and Snap are enforcing
• 0:49
  strict mandates for their engineers to hit similar
• 0:51
  thresholds for committed code. So if human developers aren't
• 0:54
  actually typing code anymore, what exactly is their job?
• 0:57
  And why are the creators of these tools suddenly terrified
• 1:00
  of the culture they built? Well, we can look at the
• 1:02
  physical places where developers work to see how this is playing
• 1:05
  out. Traditional coding environments,
• 1:07
  you know, the actual software tools where developers sit and
• 1:10
  type. Those are becoming obsolete.
• 1:12
  Yeah, tools like Microsoft VS Code and Apple X Code are
• 1:15
  basically on their way out, right?
• 1:17
  Cherney intentionally built clod code as a terminal based command
• 1:20
  line interface. So instead of a complex program
• 1:23
  with menus and sidebars and file trees, it is just a plain text
• 1:28
  prompt. Just a black box with white
• 1:30
  text. And the reasoning behind that is
• 1:32
  the underlying AI models are improving so fast that building
• 1:35
  a rich graphical user interface is like building sand castles on
• 1:39
  a beach. Because by the time you finish
• 1:41
  designing the buttons, the drop down menus, the visual feedback
• 1:44
  loops, the AI has outgrown the need for them entirely.
• 1:48
  Exactly. A terminal interface strips away
• 1:50
  all that visual scaffolding. It allows the AI to run in
• 1:53
  autonomous loops. It just executes commands and
• 1:56
  edits files directly across a code base with almost 0 latency.
• 2:00
  You stop using a tool and you start directing a worker.
• 2:03
  Yeah, and that shift in interaction is killing the
• 2:06
  traditional software engineer title.
• 2:09
  It's being replaced by this concept of a builder.
• 2:11
  Right, because the boundaries between departments are
• 2:14
  collapsing inside these companies.
• 2:16
  There's about a 50% overlap right now between engineering,
• 2:19
  product and design. Product managers, data
• 2:23
  scientists, finance teams, they're all writing code now
• 2:26
  because the interface is just natural language.
• 2:28
  I mean, if you can describe a financial model in plain
• 2:31
  English, the agent can build the software to execute it.
• 2:36
  But it's not a seamless utopia for everyone, though.
• 2:39
  Engineers and product managers generally report enjoying their
• 2:42
  jobs a lot more because they get to skip the tedious minutia.
• 2:45
  Yeah, they don't have to write boilerplate code or deal with
• 2:47
  dependency management. Which is just making sure all
• 2:50
  the different software libraries talk to each other correctly.
• 2:52
  Right, But designers are reporting the exact opposite.
• 2:55
  They are enjoying their jobs less.
• 2:57
  Because they're visual problem solvers who are suddenly forced
• 3:00
  to work in a text medium. Yeah, think about the design
• 3:03
  process like sculpting a physical object.
• 3:06
  If you are shaping clay or working with spatial
• 3:08
  relationships, negative space, visual weight, movement, you are
• 3:13
  reacting to how the object looks in front of you.
• 3:16
  You cannot easily type out a spatial visual experience.
• 3:19
  You can't. Text is linear and logical.
• 3:22
  Design is spatial and emotional. So a pure texta code paradigm
• 3:26
  doesn't naturally fit someone who's primary value is visual
• 3:30
  thinking. They end up fighting the text
• 3:32
  prompt to get the exact pixel layout they see in their head.
• 3:36
  They tell the AI to move a button slightly to the left.
• 3:38
  The AI moves it too far, they type another prompt to fix it
• 3:41
  and it breaks the alignment of the entire page.
• 3:44
  They lose the tactile control of their work completely and that
• 3:47
  reality of non-technical people are frustrated visual thinkers
• 3:51
  typing casual prompts to build software.
• 3:54
  It brings up a cultural phenomenon that the traditional
• 3:56
  engineering world is now actively trying to kill.
• 3:59
  Oh yeah, Andres Carpathy coined the term vibe coding, which
• 4:03
  actually ended up becoming the dictionary word of the year.
• 4:06
  It describes a very specific chaotic workflow.
• 4:09
  A user casually prompts an AI to build something.
• 4:13
  The AI spits out hundreds of lines of code and the user just
• 4:17
  accepts all the generated changes without reading the
• 4:19
  diffs. The diffs being the red and
• 4:21
  green lines showing exactly what was added or removed in the
• 4:24
  file. Right, the actual line by line
• 4:25
  comparison. The user ignores that entirely.
• 4:28
  They just hit accept, run the program, and if it breaks they
• 4:31
  just copy and paste the error messages back into the chat
• 4:34
  until the program eventually works.
• 4:36
  It is an output first approach with 0 structural rigor.
• 4:40
  Which is why Churney and other leaders are crowdsourcing
• 4:43
  alternatives for the term. They hate the culture it
• 4:46
  promotes. Sharoni actually compares it to
• 4:48
  gut feeling medicine for surgery.
• 4:50
  Yeah, imagine waking up from an operation, you feel fine, but
• 4:53
  your surgeon says they have no idea how they fixed you.
• 4:56
  Right, they just asked a robot to try random things until
• 4:59
  you're vital stabilized. You might be cured, but you have
• 5:01
  no idea why it worked, and you cannot guarantee they didn't
• 5:04
  leave a scalpel inside you. Exactly.
• 5:06
  And the pushback from engineers is not just about bruised egos
• 5:10
  or elitizing. There are real world business
• 5:13
  consequences to that specific phrase.
• 5:16
  When enterprise, procurement and legal teams hear the term vibe
• 5:19
  coding, they interpret it as unstructured guesswork.
• 5:23
  So they're blocking the adoption of these tools across large
• 5:26
  corporations? Well.
• 5:27
  Procurement teams exist to assess and mitigate risk.
• 5:30
  If you manage an engineering department, you have to prove to
• 5:33
  your legal team that your software is secure.
• 5:35
  Yeah, a culture built around vibes offers no clear quality or
• 5:39
  ownership standards. If an employee is generating
• 5:41
  thousands of lines of code without reading them, the
• 5:44
  company cannot verify if that code contains security
• 5:46
  vulnerabilities. They cannot verify if it
• 5:48
  infringes on intellectual property by copying copyrighted
• 5:51
  algorithms. And that unquantifiable risk
• 5:54
  threatens billions in enterprise software revenue.
• 5:57
  Which is entirely justified when you look at the actual code
• 5:59
  these casual workflows produce. Recent developer analysis show
• 6:03
  that while 84% of developers use AI tools, only a third trust the
• 6:08
  output. Because relying purely on
• 6:10
  generation leads to what is known as the lethal trifecta.
• 6:13
  High volume, low quality and 0. Structural maintenance.
• 6:17
  The volume is the trap. I mean, if you can ship complex
• 6:20
  features in seconds, you naturally bypass line by line
• 6:24
  review. The sheer amount of code being
• 6:26
  generated overwhelms human oversight.
• 6:29
  And the damage is highly measurable.
• 6:32
  AI I generated code produces almost double the structural
• 6:35
  issues, triple the readability problems and eight times the
• 6:38
  performance inefficiencies compared to human authored code.
• 6:41
  8 times. That means the software runs
• 6:43
  slower, it drains more battery on a user's device, and it costs
• 6:47
  the company significantly more in cloud computing fees just to
• 6:51
  keep it running. Right, there are hard technical
• 6:53
  limits driving this degradation. The first limit is the context
• 6:56
  ceiling. So explain the mechanics of
• 6:57
  that. If I feed an entire application
• 6:59
  code base into an AI model, what is actually happening under the
• 7:02
  hood? Does it just get distracted?
• 7:04
  Basically, yeah. Every piece of information you
• 7:06
  feed into a model depletes its attention budget.
• 7:08
  The AI processes text in chunks called tokens.
• 7:12
  As you add more tokens to the context window, which is
• 7:15
  essentially the AI's short term memory for that specific chat
• 7:19
  session, the model's performance drops.
• 7:22
  It starts to forget constraints you gave it earlier.
• 7:25
  Right. It might ignore specific
• 7:26
  formatting instructions, or it might hallucinate a function
• 7:29
  that doesn't exist because its attention is spread too thin
• 7:32
  across millions of tokens. And then the second limit is the
• 7:35
  duration ceiling. Current frontier models have a
• 7:38
  very short horizon for coherence.
• 7:41
  They perform well on tasks a human can finish in a few
• 7:43
  minutes. But they fail completely on
• 7:46
  complex tasks that take a human more than a few hours to solve.
• 7:50
  Like if you ask an AI to refactor an entire database
• 7:53
  schema across 40 different files, it loses the plot.
• 7:57
  Oh completely. It will update the 1st 10 files
• 7:59
  correctly, make a logical error on the 11th, and then cascade
• 8:03
  that error through the rest of the project.
• 8:05
  Which raises a critical question about the actual utility of all
• 8:08
  this generation. I mean, if a developer has to
• 8:10
  spend the majority of their time fixing an AI's hallucinated
• 8:13
  code, are they actually saving time or just shifting the burden
• 8:17
  from writing to debugging? And that shift is exactly why
• 8:21
  debugging AI code often takes longer than writing it manually.
• 8:25
  When you write code from scratch, you understand the
• 8:27
  architecture because you built it.
• 8:29
  You hold the mental model in your head.
• 8:30
  Exactly. You know why certain decisions
• 8:33
  were made, but when you debug a machine's output, you lack that
• 8:37
  mental model. You have to reverse engineer its
• 8:40
  logic first. You are solving a mystery before
• 8:43
  you can even begin fixing the actual problem, right?
• 8:46
  And recognizing those hard limits the top engineers have
• 8:50
  abandoned raw prompting entirely.
• 8:52
  They move to a new discipline called Agentic Engineering IT.
• 8:55
  Replaces the casual chat interface with a strict plan,
• 8:59
  execute and verify workflow. Research shows that forcing an
• 9:03
  AI to write a natural language plan before generating any code
• 9:06
  drastically boosts its success rate.
• 9:09
  You literally don't let it touch the code base until the human
• 9:12
  reviews the architecture document.
• 9:13
  Because it directly addresses the context sealing problem.
• 9:17
  Instead of cramming an entire application request into one
• 9:20
  massive prompt and hoping for the best, the planning layer
• 9:23
  breaks the system into small, well scoped units.
• 9:26
  So the coding agent only receives the exact context it
• 9:29
  needs for that specific component.
• 9:31
  Yeah, it doesn't need to hold the entire application in its
• 9:33
  memory, just the one small piece it is building right now.
• 9:37
  Boris Cherney's personal setup is an extreme example of this
• 9:39
  workflow. He runs 10 to 15 Claude Sessions
• 9:43
  in parallel across his terminal, his web browser and his phone.
• 9:48
  That's intense. He uses a specific file in his
• 9:51
  project directories that acts as a living rule book.
• 9:54
  Every time the AI makes a mistake, the team adds a new
• 9:58
  rule to that file to ensure the mistake never happens again.
• 10:01
  And that rule book is part of what the industry calls the
• 10:04
  harness. This represents the broader
• 10:06
  paradigm shift known as Software 3 point O.
• 10:09
  In this model, the context window is the new program.
• 10:12
  Right, the underlying AI model itself is just a commodity.
• 10:15
  The real intellectual property is the harness.
• 10:18
  It's the environment, the structural rules, and the
• 10:21
  automated sensors built around the agent to keep it on track.
• 10:24
  Think of the harness as the physical boundaries of a factory
• 10:27
  floor. The prompt tells the AI what to
• 10:29
  build, but the harness defines the strict boundaries of what it
• 10:33
  is allowed to touch. If the AI writes a piece of code
• 10:37
  that violates a security rule, an automated sensor in the
• 10:40
  harness catches it immediately. It blocks the code from being
• 10:43
  committed, feeds the specific error back to the agent, and
• 10:46
  forces it to rewrite the code before a human ever sees it.
• 10:49
  Yeah, that is how you solve the lethal trifecta.
• 10:52
  You replace the unstructured vibe coding loop with a
• 10:55
  deterministic engineering environment.
• 10:57
  The human stops writing syntax and starts designing the factory
• 11:00
  floor. Exactly.
• 11:02
  But building these sophisticated harnesses requires a totally
• 11:05
  different approach to managing an engineering team.
• 11:08
  The new management philosophy for the AI era is to
• 11:11
  intentionally underfund projects regarding human headcount, but
• 11:15
  give that small team unlimited AI tokens.
• 11:17
  The prevailing strategy is that optimizing cost too early
• 11:21
  stifles innovation. So giving a few engineers
• 11:24
  massive compute power yields better results than hiring more
• 11:27
  people. Yeah, you force the team to
• 11:29
  leverage the AI maximally. I mean, if an engineer has
• 11:32
  unlimited tokens, they don't just use the AI to write a
• 11:34
  function. They run parallel agent tests,
• 11:37
  generate multiple architectural variations simultaneously, and
• 11:41
  automate their own quality assurance.
• 11:43
  They can tell 10 agents to try 10 different ways of solving a
• 11:46
  problem and just review the best result.
• 11:49
  But. Pushing all this automated
• 11:50
  generation through small teams creates a huge externality for
• 11:54
  the open source community. Open source software is the
• 11:57
  foundation of almost everything built on the Internet today, and
• 12:01
  it's maintained largely by independent developers.
• 12:03
  Right, and AI agents are now silently fetching, assembling
• 12:07
  and debugging these open source packages behind the scenes.
• 12:10
  Because of this automated integration, direct human
• 12:14
  engagement with those open source repositories is basically
• 12:17
  collapsing. Yeah, developers used to spend
• 12:19
  hours reading through documentation, browsing forums,
• 12:22
  looking at the code hosted on these public pages.
• 12:24
  Now the AI handles all of that in the background, so the humans
• 12:27
  never actually visit the project pages.
• 12:29
  And that's a problem because open source maintainers rely on
• 12:32
  human visibility. When a developer visits A
• 12:35
  repository and interacts with the issues page, that engagement
• 12:38
  translates into real world economics.
• 12:41
  It leads to corporate sponsorships, premium support
• 12:43
  tiers, consulting contracts. It is how maintainers earn a
• 12:47
  living for work they essentially give away for free.
• 12:50
  So if humans stop visiting those pages, the maintainers lose
• 12:53
  their visibility and their financial support.
• 12:56
  It threatens the very ecosystem that trained the AI models in
• 13:00
  the first place. I mean, these models were
• 13:03
  trained on the collective output of the open source community and
• 13:06
  now they're automated agents are bypassing the front door.
• 13:10
  It creates this negative feedback loop.
• 13:12
  If maintainers abandoned their projects due to a lack of
• 13:15
  funding or engagement, the quality of open source software
• 13:18
  degrades. Vulnerabilities don't get
• 13:20
  patched. Updates stop rolling out.
• 13:23
  And the AI agents will then blindly pull that degraded code
• 13:26
  into enterprise environments, which lowers the quality of the
• 13:30
  commercial software. The tools are effectively
• 13:32
  cannibalizing their own supply chain.
• 13:34
  The fundamental bottleneck in technology has permanently
• 13:37
  shifted. The hard part is no longer
• 13:39
  figuring out how to build something, but deciding what to
• 13:42
  build. We are currently in what Dario
• 13:43
  Amadei calls the Centaur phase, where humans and AI work in
• 13:47
  tandem, leveraging each other's strengths.
• 13:50
  But if you think about it, if we outsource all the actual
• 13:53
  creation and implementation to autonomous agents, we really
• 13:56
  have to consider whether we eventually lose our own capacity
• 14:00
  to understand the complex systems running our world.
• 14:03
  If you're not subscribed yet, take a second and hit follow on
• 14:06
  whatever app you're using. It helps us keep making this.
• 14:08
  We appreciate you being here. Also, check out our YouTube
• 14:11
  channel for more business and tech updates.
• 14:12
  There's a link in the description.