Latest / Elon Musk Podcast / How Claude Code cost AMD 42000 dollars

Transcript

How Claude Code cost AMD 42000 dollars · Elon Musk Podcast

0:00
Imagine looking at your company's monthly software bill
0:03
and seeing it jump from $345 to over $42,000.
0:09
You'd probably think someone had, you know, stolen your
0:11
corporate credit card or something.
0:12
Right. Exactly.
0:13
Well, AMD was not hacked. Stella Lorenzo, who is the
0:17
artificial intelligence director at AMD, she analyzed over 6000
0:21
coding sessions and found that entropics Claude code lost 67%
0:27
of its thinking depth. Wow.
0:29
Yeah, and that is exactly what drove their API bill from that
0:33
baseline of $345 all the way up to over 42,000.
0:38
The financial penalty there is just, I mean, it's staggering.
0:41
It really is. When you see a cost multiplier
0:44
of that magnitude and it's linked directly to the
0:46
behavioral degradation of a single software tool, you you
0:51
really have to look closely at the mechanics of what went
0:53
wrong. Yeah, you have to.
0:54
And you have a major hardware company providing the raw
0:56
telemetry for this event. Exactly.
0:59
And this was this was a creeping behavioral collapse.
1:04
It fundamentally undermined the core utility of an engineering
1:08
tool that you know entire teams had already integrated into
1:12
their daily workflows. Right, they were relying on it.
1:14
Heavily, if you are managing a development team right now, you
1:17
are probably scrutinizing your own cloud computing invoices.
1:21
The efficiency updates you install might actually be
1:24
burning your budget from the inside out.
1:26
So the question we have to answer is how does a top tier
1:29
artificial intelligence company accidentally degrade its own
1:32
flagship coding tool while trying to improve it?
1:35
Well, the data from those AMD logs gives us a highly clinical
1:38
look at exactly how this happened.
1:40
Right, because Stella Lorenzo and her team, they didn't just
1:43
rely on like, anecdotal feelings of frustration from their
1:46
developers. You know, not at all.
1:48
They tracked a massive, highly structured data set.
1:50
We are talking about thousands of individual session files.
1:53
And within those files, they analyzed hundreds of thousands
1:56
of tool calls. Yeah, and 10s of thousands of
1:58
isolated thinking blocks. So they mapped the exact
2:01
workflow mechanics of the tool. They did, and the most critical
2:06
metric they tracked was the read to edit ratio.
2:09
OK, the read to edit ratio. Right, so before the software
2:12
updates, the model maintained this careful deliberate ratio of
2:16
6.6, meaning for every single edit the system made to the code
2:21
base, it executed over six distinct read operations.
2:25
I mean, a read operation is basically the software
2:27
equivalent of looking at the blueprints.
2:29
That's a great way to put it, yeah.
2:30
Because when a human developer sits down to fix a bug in a
2:34
massive code base, they do not just start typing blindly.
2:39
No, that would be a disaster. Right.
2:40
They open the file, they read the surrounding functions, they
2:44
check the dependencies to see what other files rely on the
2:47
code they are about to change. They might run a search command
2:50
to find every instance of a specific variable.
2:52
Exactly. And all those actions are read
2:54
operations. And a ratio of 6.6 indicates a
2:57
system that is acting with like extreme caution.
3:01
It is examining the file, analyzing the architecture, and
3:04
understanding the context before it alters.
3:06
There's a single line of code. But then the update happened.
3:09
Right. And following the update, that
3:11
ratio plummeted to a blind 2.0. So the model essentially stopped
3:16
looking at the blueprints. It did.
3:18
It started modifying code without verifying the
3:21
surrounding context at all. Oh wow.
3:23
Yeah, you think about the contractor analogy.
3:25
You don't want someone swinging a sledgehammer in your kitchen
3:29
until they have checked behind the drywall for, you know,
3:31
electrical wiring and plumbing. Yeah, absolutely not.
3:34
But this system stopped checking for the wiring, it just started
3:37
swinging. And that reckless behavior
3:39
caused a massive spike in what the AMD telemetry called stop
3:43
hook violations. Yeah, stop hook violations.
3:45
This is a very specific type of failure in a Gentic
3:48
architecture, right? It is.
3:49
When an artificial intelligence acts as an autonomous agent, it
3:53
operates in this continuous loop.
3:55
It observes the environment, makes a decision, uses a tool,
3:58
and that observes the result of that tool, right?
4:01
The stop hook is the specific mechanism the agent uses to
4:04
signal the human user that the task is entirely complete.
4:09
O it is the model raising its hand and saying I finished the
4:12
job. Exactly.
4:13
A violation occurs when the model either exits a complex
4:16
task prematurely, claiming it is finished, when the work is
4:19
actually incomplete, or when it repeatedly asks the user for
4:23
unnecessary permissions to dodge responsibility.
4:26
So it just gets stuck in a loop of hesitation.
4:28
Yeah, basically freezes up. And prior to the updates, the
4:31
AMD team recorded zero stop hook violations.
4:35
The system just completed its tasks.
4:37
But after the updates. After the updates, that number
4:39
skyrocketed to an average of 10 per day.
4:41
Wow, so the system fundamentally shifted from a research first
4:46
approach to an edit first approach.
4:48
It really did. The tool essentially stopped
4:50
planning its actions, and you know when an agentic system is
4:54
functioning correctly. That preliminary research phase
4:56
is what guarantees the stability of the final output.
4:59
Because the agent has to build a mental map of the problem.
5:02
Right. By abandoning that phase, the
5:04
system began generating lower quality code, it started
5:07
ignoring established programming conventions, and it failed
5:10
entirely on long, complex sessions.
5:12
I mean, the core value proposition of using autonomous
5:15
agents is leverage. You bring these tools into your
5:18
workflow to increase productivity.
5:21
You want to hand off complex, tedious tasks so your human
5:24
engineers can focus on like higher level system
5:27
architecture. Exactly.
5:28
But if the human user has to constantly supervise the system
5:33
and review every single read and edit cycle, and force the tool
5:37
to complete tasks it abandoned halfway through, your
5:40
productivity gains just evaporate.
5:42
You end up spending more energy managing the tool than you would
5:46
have spent writing the code yourself.
5:47
Right, because trust is the foundation of agentic software.
5:51
When that trust breaks, the tool becomes a liability rather than
5:54
an asset. The entire relationship between
5:56
the developer and the software just changes.
5:59
Imagine hiring a senior software engineer who has, you know, a
6:02
pristine resume for the first few weeks.
6:05
They write brilliant, careful code.
6:07
They review their pull request. They check dependencies.
6:10
Sounds like a great hire. Right, but then suddenly they
6:13
start pushing unread, untested code directly to the production
6:17
server. They clock out early claiming
6:19
the work is done when the application will not even
6:21
compile. You would fire that engineer
6:23
immediately. Exactly.
6:25
The risk of a catastrophic failure taking down your entire
6:28
service is simply too high. And that breakdown in basic
6:32
reasoning is the direct mechanical cause of the
6:35
financial sinkhole the AMD team experienced.
6:38
The degradation in logic created this this cascading failure in
6:43
resource consumption. So it stopped planning and
6:45
started guessing. Yeah.
6:47
And let us look at the financial data attached to that guessing,
6:50
because for the exact same human workload, a nearly identical
6:54
number of user prompts provided by the AMD engineers, the model
6:58
consumed 80 times more API requests, 80 times and 64 times
7:02
more output tokens. Wow.
7:04
That is the multiplier that drove the estimated cost for
7:06
that workload from $345 to an astonishing 42,121 dollars.
7:12
The math there is almost difficult to process.
7:15
I mean, if you ask a system to do a job and it suddenly
7:17
requires 80 times more network requests to finish that
7:20
identical job, the natural assumption is that the system
7:23
simply lost its ability to actually write functional
7:26
software. Right, You assume the artificial
7:28
intelligence just forgot how to code.
7:30
But the data points to a very different conclusion.
7:33
The model itself was still entirely capable of writing
7:37
highly complex code. The failure was not in its
7:41
underlying intelligence. OK, then what was it?
7:44
The failure was in its adaptive thinking heuristic.
7:46
Wait, back up. How does making a mistake
7:48
multiply the API request by 80? I mean, adaptive thinking
7:52
heuristic sounds incredibly dense.
7:55
Why would a developer ever want their artificial intelligence to
7:58
use a heuristic to decide how hard it wants to think?
8:01
Well, the adaptive thinking heuristic is the internal
8:04
mechanism the system uses to judge its own confidence level
8:07
and allocate processing power. OK, computing power is really
8:10
expensive, so when presented with a task, the system
8:14
evaluates the complexity and decide how much reasoning effort
8:17
to apply. That makes sense.
8:18
If you ask the model to fix a simple spelling error in a text
8:21
document, it should not spend high level computing resources
8:25
analyzing the entire architecture of the software.
8:27
It should recognize a simple task, apply minimal reasoning
8:31
effort, and fix the spelling error.
8:33
So it matches the mental effort to the difficulty of the
8:35
problem. Yes, exactly.
8:38
But what failed was the model's ability to accurately assess
8:42
that complexity. Oh, I see.
8:43
It began looking at highly intricate system level
8:46
engineering problems and categorizing them as simle
8:49
routine tasks. Because it assumed the complex
8:52
tasks were simple, it applied minimal reasoning effort it.
8:56
Chose to be lazy when it needed to be diligent.
8:58
Exactly. OK, but I still need to
9:00
understand the multiplier. How does making a lazy mistake
9:03
multiply the API requests by 80? Because it creates a violent
9:08
cycle of correction. The cycle of correction.
9:10
Yeah, because the system applied minimal reasoning.
9:13
It generated A superficial, incorrect fix to a deeply
9:17
complex problem, right? It then attempted to compile or
9:20
run the code, but the code was flawed, which immediately
9:23
resulted in a build failure, and when a bill fails, the compiler
9:26
spits out an error log. And compiler error logs can be
9:28
massive. I mean, if you miss a single
9:30
bracket in a foundational file, the compiler might throw a
9:33
syntax error that cascades down through hundreds of connected
9:37
files. Exactly.
9:38
The compiler generates a massive text file detailing every single
9:42
thing that broke the agentic system, then ingests that entire
9:46
massive error log. This bloats its context window,
9:49
which is the working memory of the official intelligence.
9:52
The system looks at the error log and attempts another
9:55
superficial fix based on a completely flawed understanding
9:58
of the initial problem. And because the reasoning effort
10:01
is still set too low, the second fix also failed.
10:04
Exactly, and the compiler spits out another potentially even
10:07
longer error log. So the model eats the second
10:09
error log, it's working, memory gets even larger and it guesses
10:12
again. And this cycle repeats
10:14
endlessly. Every single time the system
10:16
fails, it has to process an increasingly large context
10:19
window of previous mistakes. And unofficial intelligence
10:23
charges you based on the number of tokens, the number of words
10:25
and characters it has to read and write.
10:27
Right. Pumping endless error logs into
10:30
the context window burns massive amounts of tokens.
10:33
The system executes 80 times the normal number of requests, just
10:37
spinning its wheels, generating useless code, failing the
10:40
compilation and reading the resulting failure.
10:43
You are basically paying an exorbitant premium for the
10:46
system to aggressively misunderstand its own mistakes.
10:49
That's exactly what's happening. And the financial pain of paying
10:53
for those endless correction cycles forced the developer
10:56
community to demand answers. Anthropic had to look under the
10:59
hood of their own system and publish a post mortem explaining
11:02
exactly how the tool broke down. They did, and Anthropic trace
11:07
the degradation to three separate compounding errors at
11:11
the product layer. Now, the product layer is an
11:13
important distinction here. It is because the core
11:16
artificial intelligence model, the massive neural network
11:20
trained on clusters of supercomputers, that is the
11:23
foundational layer. The product layer is the
11:25
software interface wrapped around that brain.
11:27
Right, it includes the settings, the user interface and the
11:30
hidden instructions that tell the brain how to behave.
11:32
So what was the first error? The first issue Anthropic
11:36
identified was a silent downgrade of the default
11:39
reasoning effort. A silent downgrade.
11:41
Yeah, to reduce interface latency and make the tool feel
11:44
faster and more responsive to the user, the development team
11:47
altered the default setting from high reasoning effort to medium
11:51
reasoning effort. They prioritized the appearance
11:54
of speed over the actual quality of the output.
11:56
Exactly. As a user, you type a prompt and
11:59
you want the software to start generating text immediately.
12:02
If the system pauses to build a complex mental map of the code
12:05
base, That pause feels like lag. So the product managers
12:10
intentionally degraded the intelligence of the tool so the
12:12
text would start scrolling across the screen faster.
12:14
Yes, and then the second issue involved a change to the system
12:19
prompt. OK, the system prompt being the
12:21
invisible set of instructions the model reads before it ever
12:24
talks to the user. Right Anthropic introduced a new
12:27
instruction that artificially capped the models responses at
12:31
25 words between tool calls. They forced the model to stop
12:35
talking through its thought process.
12:36
Yeah, and one of the fundamental ways large language models solve
12:40
complex problems is through chain of thought reasoning.
12:43
Right. They literally write out their
12:44
logic step by step to arrive at the correct conclusion.
12:48
The process of generating the text is the process of thinking.
12:51
Exactly. By capping the output at 25
12:54
words, you are forcing a highly intelligent system to solve a
12:58
massive engineering problem while only allowing it to speak
13:01
in short, broken sentences. That sounds completely
13:04
counterproductive. It is, and the third issue was
13:07
perhaps the most structurally damaging.
13:10
Anthropic discovered a severe caching bug A.
13:12
Caching bug. Yeah, this bug caused the model
13:15
to literally forget its own reasoning history on every
13:19
single conversational turn. Wow, so it would analyze the
13:22
code base, make a decision, execute a tool call, and then
13:25
immediately suffer total amnesia regarding why it just made that
13:28
decision. Yes, when the next turn started,
13:31
it had to look at its own previous actions with no memory
13:34
of the strategy it had been pursuing just seconds earlier.
13:37
These three distinct failures overlapped perfectly to create
13:40
the illusion that they foundational model itself had
13:42
been lobotomized. That's exactly what it looked
13:44
like, but the actual neural network weights the core
13:47
intelligence of the system we're completely fine.
13:50
The issue was that the product wrappers, the interface
13:53
settings, and the protective guardrails just choked the
13:57
system's ability to utilize that intelligence.
13:59
This limits a developer's ability to rely on default
14:02
configurations. I mean, if a silent update
14:05
designed to reduce latency can destroy the reasoning
14:08
capabilities of a production tool, you can no longer trust
14:11
the provider standard settings. No, you can't.
14:13
It completely changes how users view system updates.
14:17
Instead of anticipating guaranteed improvements,
14:19
developers now treat every background update as a potential
14:23
hazard to their infrastructure. You are paying for access to a
14:27
brilliant system, but the interface wrapper is preventing
14:30
that brilliance from executing its tasks.
14:32
They basically put a gag order on their own software.
14:34
Yeah, they did. And while the official autopsy
14:37
from Anthropic identified those specific interface bugs,
14:40
independent developers in the community found deeper,
14:43
significantly more expensive flaws hidden directly inside the
14:47
system's memory cache. The community investigation was
14:50
incredibly thorough. Yeah, a security researcher
14:54
reverse engineered the standalone binary file for the
14:57
coding tool and discovered 2 severe prompt caching bugs.
15:02
Two of them. Yes, and these independent bugs
15:05
were responsible for inflating token consumption by up to 20
15:08
times the expected rate. I mean, cracking open a compiled
15:12
binary file is intense investigative work.
15:14
When software is compiled, the human readable code is
15:17
translated into machine language.
15:20
So the researcher had to decompile that machine language
15:22
to see exactly how the tokens were being counted and stored on
15:25
the user's local machine. And they found that the custom
15:28
runtime environment was performing string replacements
15:31
on billing terms. OK, what does that mean?
15:33
Well, the software was searching the context window to replace
15:36
specific text strings related to billing, but when it executed
15:39
this search, it hit the wrong locations in the memory
15:43
structure. Yeah, modifying the wrong memory
15:46
locations completely broke the cache.
15:49
Furthermore, whenever a developer used a basic command
15:52
to resume a previous coding session, that specific action
15:56
also shattered the cache prefix. So to understand the financial
15:59
impact of breaking a cache prefix, we really need to
16:02
explain the mechanics of cached versus uncached tokens.
16:06
Think of tokens as putting quarters into an arcade machine.
16:10
Every time you ask the artificial intelligence a
16:12
question, you have to feed it quarters.
16:14
When a developer works in a massive software repository, the
16:18
model has to hold thousands of files in its working memory.
16:22
It needs to read the entire code base to understand the context
16:25
of your question. And if that working memory is
16:27
successfully cached on the provider's servers, reading is
16:30
incredibly cheap. The server already processed the
16:32
files, you are just paying a tiny fraction of a cent to
16:36
access that stored memory. Right.
16:38
So in the arcade analogy, reading from a functioning cache
16:40
is like having a handful of free tokens sitting on the glass of
16:44
the machine. But if the cache breaks, the
16:46
system has to take all of those thousands of files and write
16:50
them as fresh context to the server.
16:52
And writing fresh context is dramatically more expensive.
16:55
Because it requires the server to recalculate the mathematical
16:59
weights for every single word in the code.
17:01
Base right? So breaking the cache means you
17:03
have to convert $100 bill into quarters every single time you
17:07
hit the continue button. And the independent bugs the
17:09
researcher found were constantly breaking the cache.
17:12
Constantly, yes. The string replacements and the
17:15
session resume commands forced the system to recalculate the
17:19
entire code base repeatedly, burning massive amounts of fresh
17:23
input tokens. Which is incredibly expensive.
17:25
It is, and this was compounded by another silent server side
17:29
change. The cache expiration window was
17:31
aggressively shortened. OK, and the expiration window is
17:34
the amount of time the server holds on to that stored memory
17:36
while the user is idle, right? Server space is expensive, so
17:40
providers wipe the memory if a user walks away.
17:42
Exactly, and Anthropic reduced that expiration window from a
17:46
long duration down to an incredibly short 1.
17:48
How short? So short that if a developer
17:51
paused to read an e-mail, check a separate document, or even
17:54
just get a cup of coffee, the cash expired.
17:58
Wow. When the developer returned to
17:59
their desk and entered a new Trumped, the system was forced
18:02
to execute an expensive context re upload.
18:06
The memory had been completely wiped during that brief pause.
18:09
This changes user behavior entirely.
18:12
It creates an intensely stressful, perverse incentive
18:15
where developers feel they cannot physically step away from
18:18
their keyboards. Yeah, you become trapped.
18:20
Because it taking a brief pause incurs a massive financial
18:23
penalty just because the session expires and the context has to
18:27
be rebuilt from scratch, the tool becomes hostile to normal
18:31
human working patterns. You are tethered to the machine,
18:34
terrified that a bathroom break is going to cost your company
18:37
$50.00 in uncached token processing.
18:39
If the community hadn't decompiled the binary, would
18:42
these silent coke and drains have ever been caught?
18:44
I honestly don't know. Because the user interface does
18:47
not alert you when the cache breaks.
18:49
You only find out when the invoice arrives.
18:51
And that severe resource strain where the system is constantly
18:55
rewriting massive context windows connects directly to the
18:58
providers broader struggle to maintain profitability on their
19:02
standard consumer subscription plans.
19:04
Yeah, the hardware costs of running these models are
19:06
clashing heavily with the pricing structures they offer to
19:09
the public. Right.
19:10
And we saw that clash manifest in the capacity crisis and the
19:13
controversy surrounding the pro pricing tier.
19:16
We did. Anthropic quietly updated their
19:19
public website and all of their support documents to remove
19:22
access to this coding tool from their standard $20 Pro plan.
19:26
Moved it completely. Yeah, they shifted access
19:29
entirely, leaving the tool available only on their Max
19:31
plans, and the Max plans start at $100 per month.
19:35
Hold on, if it was just a test on a tiny fraction of users, why
19:39
did the public documentation change for everyone?
19:42
I mean, if a company quintuples the entry price for a flagship
19:45
tool, they usually issue a major press release explaining the new
19:49
enterprise features. They just quietly edited the
19:51
support documents without an official announcement.
19:54
Exactly. The developer community noticed
19:56
the changes to the documentation immediately and the backlash was
20:00
intense. Oh, I.
20:01
Bet. Following that community
20:03
outrage, the company's head of growth issued a statement
20:06
claiming that the removal of the tool from the $20 tier was
20:10
merely an experiment conducted on 2% of new signups.
20:15
New percent. That's what they claimed, and
20:17
shortly after issuing that statement, the company reversed
20:20
the website changes entirely and restored access to the standard
20:23
tier. Because the fundamental economic
20:26
math problem here is inescapable.
20:28
It really is. Conversational artificial
20:30
intelligence, like the standard chatbot interface most people
20:33
are familiar with, is relatively cheap to host.
20:36
The user types one prompt, the model generates 1 reply, and
20:40
then the system rests. It consumes compute power in
20:43
brief predictable bursts. Right, but agentic tools operate
20:47
entirely differently. Completely.
20:48
An autonomous coding agent performs hundreds of actions
20:51
based on a single prompt. It reads files, writes code,
20:54
triggers the compiler, reads the error logs, searches the
20:56
Internet for documentation and rewrites the code again.
20:59
And that continuous loop burns through usage at a rate that
21:03
cost the provider far more in raw electricity and silicon
21:07
compute power then a flat $20 monthly subscription fee can
21:11
cover. The model of offering unlimited
21:14
flat rate access to autonomous agents is structurally doomed.
21:18
The industry is shifting rapidly towards strict quota rationing.
21:22
Projecting this forward indicates A structural ceiling
21:25
for the entire software sector. High intelligence agentic tools
21:29
are destined to be gated behind high tier enterprise pricing
21:33
models. The physical limits of current
21:35
hardware capacity practically guarantee it.
21:37
Yeah, the sheer cost of the electricity required to cool the
21:40
data centers, combined with the extreme price of the spatialized
21:43
silicon chips required to facilitate hundreds of
21:46
autonomous actions per minute means the consumer level pricing
21:49
is fundamentally unsustainable for this specific type of
21:52
software. The economic reality of the data
21:54
centers dictates the product strategy.
21:56
The hardware cannot subsidized the software indefinitely.
21:59
It can't. But let us go back to that
22:01
public documentation change for a second.
22:04
If the restriction was just a test on a tiny fraction of
22:08
users, a random 2% of new signups, why did the public
22:12
documentation change for everyone?
22:14
A standard AB test does not require rewriting the global
22:17
support pages. No, it doesn't.
22:19
And that discrepancy is exactly why trust within the developer
22:23
community continue to erode. The explanation just did not
22:27
align with the execution. Not at all.
22:29
And while the community was heavily focused on the pricing
22:31
adjustments and the token drains and the performance drops, a
22:35
massive security blunder exposed the inner workings of the entire
22:38
tool to the public. Oh yeah, the leak.
22:40
Yeah, a routine software update accidentally included a source
22:44
map file. Yeah, and this file exposed over
22:46
500,000 lines of proprietary code, the internal performance
22:50
metrics and the hidden system prompts that govern the models
22:53
behavior. To understand how damaging a
22:55
source map leak is, you really have to look at how modern
22:58
software is deployed. When developers ship complex
23:01
applications, they run the code through a minifier.
23:04
This process compresses the code, removes all the spaces,
23:08
shortens the variable names and just obfuscates the logic.
23:12
Right. It makes the application run
23:13
faster and protects the intellectual property from
23:15
competitor. Exactly.
23:16
The compressed code is completely unreadable to a
23:19
human. But a source map file is
23:21
essentially the master translation guide.
23:23
Yes, it is used internally by the developers to debug the
23:27
application. The source map links the
23:29
compressed, unreadable output directly back to the original,
23:32
beautifully formatted human written code.
23:35
So by accidentally shipping that source map file in the public
23:38
update, they handed the exact blueprints of their flagship
23:41
product to anyone who downloaded the software.
23:43
It is the equivalent of serving a meal in a restaurant but
23:46
accidentally leaving the chef's secret handwritten recipe book
23:50
on the customer's table. That's exactly what it is, and
23:52
the developer community reacted instantly.
23:55
A developer took that leaked code base and used a competing
23:59
artificial intelligence model to perform a clean room rewrite.
24:02
Which is fascinating because clean room design is this
24:05
incredible concept in software engineering.
24:07
It is. Historically, if a company
24:10
wanted to clone a competitor software without violating
24:14
copyright law, they would set up a literal clean room, right?
24:18
They would have one team of engineers analyze the competitor
24:21
software to extract the functional specifications, the
24:25
list of things the software does.
24:27
Then they would hand that list of specifications to a
24:30
completely different team of engineers who had never seen the
24:33
competitors code. This second team would write new
24:37
code from scratch to meet those exact specifications.
24:40
And because the second team never saw the original code,
24:43
they could prove in court that they did not copy the specific
24:46
expression of the competitor's intellectual property.
24:49
Exactly, they only replicated the functional ideas, and ideas
24:52
cannot be copyrighted. But in this instance, a
24:54
developer fed the leaked proprietary logic into a rival
24:58
artificial intelligence system. Yeah, they instructed the rival
25:01
system to act as the clean room team.
25:04
The system absorbed with the complex architectural concepts,
25:07
the workflow loops and the prompt structures, and then
25:10
translated the entire architecture into a completely
25:13
new programming language. This created a highly popular,
25:17
fully functional clone of the tool immediately.
25:20
The code leaked and another AI absorbed.
25:22
It, and this creates an absolute labyrinth of legal and
25:25
structural chaos because traditional copyright defense
25:29
and software relies heavily on proving that the specific
25:32
expression of the code was copied.
25:34
Right. The lawyers look for identical
25:36
variable names, specific syntax choices, and the unique phrasing
25:40
of the logic. If you copy the exact text of
25:43
the code, you lose the lawsuit. But if an artificial
25:46
intelligence reads a leaked proprietary code base, extracts
25:49
the underlying functional logic, and then generates A
25:52
structurally distinct clone in an entirely different language,
25:56
the traditional mechanisms for issuing A takedown notice just
25:59
fail. They do.
26:00
The new code does not look anything like the old code.
26:02
A textual comparison which shows 0 similarities even though the
26:05
new software performs the exact same proprietary functions based
26:08
on the exact same leaked logic. This opens up entirely new legal
26:13
vulnerabilities for every technology company operating
26:15
today. It severely limits the power of
26:18
standard copyright enforcement. If an artificial intelligence
26:22
can launder proprietary logic at lightning speed, rewriting the
26:26
architecture so thoroughly that it bypasses standard plagiarism
26:30
checks, the concept of keeping software logic a trade secret
26:34
becomes incredibly difficult to enforce.
26:36
You no longer need a massive team of engineers working in
26:39
isolation for months to execute a clean room design.
26:43
You just need an exposed source map and a subscription to a
26:46
rival model. Right.
26:48
And to manage this rapidly growing complexity and the
26:51
fundamental unreliability of code generated by artificial
26:54
intelligence, and Thropic introduced a new system where
26:56
the models are now required to monitor themselves.
26:59
Yeah, they launched a feature called Code Review.
27:01
Yeah, instead of relying on a single model to write the code
27:04
and then check its own work, which is historically prone to
27:06
failure because the system rarely catches its own logical
27:09
blind spots, this tool dispatches a team of parallel AI
27:12
agents. So when a human developer
27:14
submits a pull request, which is a formal proposal to merge new
27:18
code into the main project repository, these parallel
27:21
agents examine the submission simultaneously.
27:24
The architecture of this review system is highly structured.
27:27
You have worker agents that scan specific sections of the code
27:31
looking for security vulnerabilities, syntax errors,
27:33
and logic flaws. OK and then you have critic
27:36
agents that evaluate the findings of the worker agents.
27:39
They cross verify the identified issues, filter out the false
27:43
positives, and rank the discovered bugs by severity.
27:46
And it costs 15 to $25 per review depending on the size of
27:50
the pull request, right? Importantly, this parallel agent
27:53
team does not have the authority to actually approve the code and
27:56
merge it into the repository. It only suggests fixes and flags
28:00
issues for the human engineers to evaluate.
28:03
You have to look at why a tool like this suddenly exists in the
28:06
marketplace. Artificial intelligence coding
28:08
assistants have drastically increased the sheer volume of
28:11
code being generated every single day.
28:13
Yeah, it's exponential. A single developer using an
28:17
autonomous agent can now generate thousands of lines of
28:20
code in a single programming session.
28:22
And this has created a massive, unmanageable bottleneck for
28:25
human reviewers. If a junior developer uses an
28:28
agent to generate 3000 lines of complex system architecture, a
28:32
senior engineer still has to read and verify every single
28:36
line of that output before it goes into production.
28:39
Exactly. The human capacity to review
28:41
code is not scaled to meet the machine capacity to generate
28:44
code. The proposed solution to the
28:46
massive volume of errors generated by artificial
28:48
intelligence is now highly structured parallel layers of AI
28:52
driven review. This completely shifts the role
28:55
of the human developer. You are no longer primarily a
28:58
writer of code. You are transitioning into a
29:00
manager of competing artificial intelligence agent teams.
29:03
Right, Your daily workflow looks more like middle management in a
29:06
massive corporate bureaucracy. Your job is to orchestrate the
29:09
generation agents, review the findings of the diagnostic
29:13
agents, mediate the disputes between the different models and
29:16
make the final strategic decisions based on their cross
29:19
verified reports. Which means we are paying an
29:22
artificial intelligence a premium fee to find the bugs
29:25
that another artificial intelligence just wrote into the
29:28
code base. We're paying an AI to find the
29:30
bugs that another AI just wrote into the code base.
29:33
You are funding both sides of the generation and correction
29:36
loop. Yeah, exactly.
29:37
Agentic coding represents an immense leap in technical
29:40
capability, but the invisible layers of caching bugs, token
29:44
limits, and product layer prompt engineering make it an
29:48
incredibly fragile system that requires constant human
29:51
vigilance. If the tools we use to build our
29:53
digital infrastructure require a massive, profitable compute
29:57
subsidy to function, what happens to the software industry
30:01
when that hardware subsidy finally dries up?
30:03
If you're not subscribed yet, take a second and hit follow on
30:05
whatever app you're using. It helps us keep making this.
30:07
We appreciate you being here. Also, check out our YouTube
30:10
channel for more business and tech updates.
30:12
There's a link in the description.