1
00:00:00,040 --> 00:00:04,400
Imagine upgrading from a bicycle
to a fully autonomous self 

2
00:00:04,400 --> 00:00:06,560
driving car overnight. 
I mean, that sounds like a 

3
00:00:06,560 --> 00:00:08,280
pretty great upgrade to me. 
Right. 

4
00:00:08,280 --> 00:00:11,240
It sounds amazing, but then 
imagine you're suddenly flying 

5
00:00:11,240 --> 00:00:14,440
down the highway at 80 miles an 
hour and you realize, wait, 

6
00:00:14,960 --> 00:00:16,680
nobody's actually paved the 
roads yet. 

7
00:00:17,640 --> 00:00:21,200
Yeah, that is a massive problem.
Yeah, and that is the exact 

8
00:00:21,560 --> 00:00:24,120
crisis hitting the software 
industry today. 

9
00:00:24,680 --> 00:00:28,360
Welcome to the Deep Dive. 
Today we have a massive stack of

10
00:00:28,360 --> 00:00:30,120
sources from across the 
development world. 

11
00:00:30,400 --> 00:00:33,200
We've got developer blogs, 
industry analysis, Reddit 

12
00:00:33,200 --> 00:00:37,360
threads, and honestly a massive 
internal code base leak from 

13
00:00:37,360 --> 00:00:40,440
April 2026. 
Which is just a wild story on 

14
00:00:40,440 --> 00:00:42,800
its own. 
Completely wild and all of these

15
00:00:42,800 --> 00:00:45,440
sources are pointing to the 
exact same massive shift. 

16
00:00:45,920 --> 00:00:49,080
AI has officially graduated. 
Like we are no longer talking 

17
00:00:49,080 --> 00:00:51,560
about a fancy auto complete that
just finishes your sentences in 

18
00:00:51,560 --> 00:00:52,400
the editor. 
Right. 

19
00:00:52,400 --> 00:00:54,200
We've moved way past that. 
Exactly. 

20
00:00:54,680 --> 00:00:57,120
We are dealing with autonomous 
agents that just go off and 

21
00:00:57,120 --> 00:00:59,840
execute entire workflows 
entirely on their own. 

22
00:01:00,640 --> 00:01:03,200
So our mission for you today, 
whether you are a seasoned 

23
00:01:03,200 --> 00:01:07,280
developer, managing A-Team, or 
just insanely curious about 

24
00:01:07,280 --> 00:01:11,120
where AI is heading, we're going
to explore what actually happens

25
00:01:11,120 --> 00:01:14,640
when we hand over the keys. 
Because the transition from, you

26
00:01:14,640 --> 00:01:19,400
know, passive assistance to 
active agency, it basically 

27
00:01:19,400 --> 00:01:22,360
breaks almost every assumption 
we have about how software is 

28
00:01:22,360 --> 00:01:24,040
built. 
Let's talk about how we even 

29
00:01:24,040 --> 00:01:27,040
know this is breaking, because 
we got a very unexpected look 

30
00:01:27,040 --> 00:01:30,160
under the hood recently, and 
it's all thanks to a pretty 

31
00:01:30,160 --> 00:01:32,840
embarrassing operational 
security failure over at 

32
00:01:32,840 --> 00:01:33,960
Anthromic. 
Yeah. 

33
00:01:34,520 --> 00:01:36,560
The clawed code leak. 
Yeah, the clawed code leak. 

34
00:01:36,560 --> 00:01:39,240
They literally accidentally left
their own clawed code source 

35
00:01:39,240 --> 00:01:42,280
repository public on GitHub. 
Which, you know, happens when 

36
00:01:42,280 --> 00:01:45,360
you're moving at that kind of 
breakneck speed, but still. 

37
00:01:45,400 --> 00:01:47,920
Right, but the funny part is how
they handled it. 

38
00:01:48,240 --> 00:01:51,520
The issue to DMCA takedown 
request to scrub it from the 

39
00:01:51,520 --> 00:01:54,720
Internet, which honestly just 
functioned exactly like firing a

40
00:01:54,720 --> 00:01:57,240
flare into the night sky. 
Oh, total Streisand effect A. 

41
00:01:57,400 --> 00:02:01,000
100% the moment they tried to 
hide it, outlets like the new 

42
00:02:01,000 --> 00:02:04,520
stack and latent space just 
descended on it with these 

43
00:02:04,520 --> 00:02:06,720
incredibly deep architecture 
analysis. 

44
00:02:06,800 --> 00:02:09,520
And what those analysis 
uncovered is just crucial for 

45
00:02:09,520 --> 00:02:12,160
anyone using these tools because
it really strips away this 

46
00:02:12,160 --> 00:02:16,280
illusion of a a hyper 
intelligent, omniscient AI 

47
00:02:16,280 --> 00:02:17,000
brain. 
Right. 

48
00:02:17,040 --> 00:02:20,080
It pulls back the curtain. 
So what did the leak actually 

49
00:02:20,080 --> 00:02:21,640
reveal about what's going on in 
there? 

50
00:02:21,720 --> 00:02:25,040
Well, it exposed the raw 
mechanics of their agentic loop 

51
00:02:25,040 --> 00:02:27,800
scaffolding, so it showed 
precisely how the prompt 

52
00:02:27,800 --> 00:02:29,880
structures the tool you 
sequencing. 

53
00:02:29,880 --> 00:02:32,960
And these relentless error 
handling loops are layered 

54
00:02:32,960 --> 00:02:35,600
around the core model. 
So it's not just a smart model 

55
00:02:35,600 --> 00:02:38,040
doing everything natively. 
No, not at all. 

56
00:02:38,040 --> 00:02:41,200
It's a deliberate, highly 
engineered system to create the 

57
00:02:41,200 --> 00:02:44,040
illusion of autonomy. 
Like in a standard that 

58
00:02:44,040 --> 00:02:46,520
interface, the model just 
generates a response based on 

59
00:02:46,520 --> 00:02:48,360
its internal weights and then it
stops. 

60
00:02:48,360 --> 00:02:49,800
You asked a question, you got an
answer. 

61
00:02:49,880 --> 00:02:52,640
Right, but the Claude code 
architecture relies on this 

62
00:02:52,640 --> 00:02:55,960
persistent evaluation loop. 
The system prompt actually 

63
00:02:55,960 --> 00:02:59,040
injects a hidden scratch pad for
the model to use for its 

64
00:02:59,040 --> 00:03:01,440
intermediate reasoning. 
OK, so it's like talking to 

65
00:03:01,440 --> 00:03:03,200
itself before it talks to you. 
Exactly. 

66
00:03:03,200 --> 00:03:06,320
And it wraps these thoughts in 
specific XML tags. 

67
00:03:06,320 --> 00:03:08,400
Like literally a thought tag and
an action tag. 

68
00:03:08,680 --> 00:03:11,480
So say the model decides it 
needs to run a bash script to 

69
00:03:11,480 --> 00:03:14,320
check a file. 
The scaffolding catches that 

70
00:03:14,320 --> 00:03:18,120
action tag, executes the script 
in a hidden terminal, grabs the 

71
00:03:18,160 --> 00:03:21,840
output or the error message, and
then feeds it directly back into

72
00:03:21,840 --> 00:03:24,680
the models context window. 
And then tells it to evaluate 

73
00:03:24,680 --> 00:03:25,640
what just happened. 
Yes. 

74
00:03:26,280 --> 00:03:30,040
And if the script fails, the 
scaffolding literally forces the

75
00:03:30,040 --> 00:03:33,920
model into a retry loop based on
the specific error code it got. 

76
00:03:34,120 --> 00:03:35,800
But wait, let me push back on 
this a little bit. 

77
00:03:36,520 --> 00:03:40,160
If the secret sauce driving this
whole new era of AI is 

78
00:03:40,160 --> 00:03:43,280
essentially just a highly 
organized, automated To Do List 

79
00:03:43,280 --> 00:03:45,640
looping over itself, I mean, 
doesn't that kind of kill the 

80
00:03:45,640 --> 00:03:46,800
magic? 
In what way? 

81
00:03:47,440 --> 00:03:49,640
Well, where is the actual 
intelligence? 

82
00:03:49,680 --> 00:03:52,440
Aren't we just talking about 
standard boring automation 

83
00:03:52,440 --> 00:03:55,320
bolted onto a language model? 
How does knowing about these 

84
00:03:55,320 --> 00:03:58,200
scenes actually change how you 
type a prompt into the tool 

85
00:03:58,200 --> 00:04:01,320
today? 
I get that, but the intelligence

86
00:04:01,320 --> 00:04:04,120
is in the model's ability to 
semantically interpret the 

87
00:04:04,120 --> 00:04:07,160
failure state and rewrite its 
own approach on the fly. 

88
00:04:07,360 --> 00:04:10,080
The automation is just the 
chassis of the car, right? 

89
00:04:10,760 --> 00:04:14,480
But understanding this mechanism
fundamentally changes how you 

90
00:04:14,480 --> 00:04:17,440
work with it. 
The leak basically proves that 

91
00:04:17,519 --> 00:04:20,720
you need to stop spending time 
endlessly tweaking your prompt 

92
00:04:20,720 --> 00:04:24,000
to have the exact perfect 
wording, and instead start 

93
00:04:24,000 --> 00:04:27,640
spending your time building 
rigid fault tolerant scaffolding

94
00:04:27,640 --> 00:04:29,440
around the model. 
Oh, because it's a looping 

95
00:04:29,440 --> 00:04:31,800
machine. 
It's going to generate output at

96
00:04:31,800 --> 00:04:34,480
an unprecedented speed, and it's
going to make mistakes. 

97
00:04:34,640 --> 00:04:37,760
Exactly, which is why developers
like Simon Willison are 

98
00:04:37,760 --> 00:04:41,760
aggressively exploring sandboxed
iframes for things like Claude 

99
00:04:41,760 --> 00:04:43,240
artifacts. 
Right, I saw that in the 

100
00:04:43,240 --> 00:04:45,800
sources. 
Because if you know the agent is

101
00:04:45,800 --> 00:04:49,440
going to relentlessly loop and 
execute code, you definitely 

102
00:04:49,440 --> 00:04:51,680
can't just let it run wild on 
your local machine. 

103
00:04:51,680 --> 00:04:53,240
No, it'll destroy your 
environment. 

104
00:04:53,240 --> 00:04:56,840
So developers are building these
isolated sandboxed iframes. 

105
00:04:56,840 --> 00:04:59,600
That way the agent can render 
its own UI, run its own 

106
00:04:59,600 --> 00:05:02,960
JavaScript, test its theories, 
all without nuking the host 

107
00:05:02,960 --> 00:05:04,760
machine. 
You don't trust the agent to be 

108
00:05:04,760 --> 00:05:06,800
correct right away. 
Right, you just trust the 

109
00:05:06,800 --> 00:05:09,360
sandbox to contain the mess 
while it iterates. 

110
00:05:09,600 --> 00:05:13,040
And because it never gets tired,
it just iterates so fast. 

111
00:05:13,640 --> 00:05:17,480
Which actually brings us 
directly to the massive traffic 

112
00:05:17,480 --> 00:05:19,240
jam happening at the human 
level. 

113
00:05:19,240 --> 00:05:22,840
The review model neck. 
Yes, The New Stack published 

114
00:05:22,840 --> 00:05:26,600
this really fascinating piece 
about the hidden PR tax and how 

115
00:05:26,600 --> 00:05:30,640
agentic AI is just actively 
breaking CICD pipelines right 

116
00:05:30,640 --> 00:05:32,480
now. 
Well, yeah, because our software

117
00:05:32,480 --> 00:05:35,200
pipelines were designed around 
the biological limits of human 

118
00:05:35,200 --> 00:05:38,320
typing speed and, you know, 
human cognitive load. 

119
00:05:38,320 --> 00:05:40,480
Right, we can only type so fast.
Exactly. 

120
00:05:40,480 --> 00:05:43,680
So when you flip the paradigm 
and suddenly an agent can 

121
00:05:43,680 --> 00:05:47,320
generate a massive pull request 
touching 20 different files in 3

122
00:05:47,320 --> 00:05:50,160
minutes, the bottleneck 
instantly shifts. 

123
00:05:50,560 --> 00:05:52,920
Writing code is no longer the 
rate limiting step. 

124
00:05:52,960 --> 00:05:55,600
Reviewing the code is. 
Exactly, reviewing is the new 

125
00:05:55,600 --> 00:05:57,000
bottleneck. 
And it seems like management 

126
00:05:57,000 --> 00:05:59,400
teams are just totally stuck in 
what the articles call phase 

127
00:05:59,400 --> 00:06:01,440
one. 
They buy everyone Claude Code 

128
00:06:01,440 --> 00:06:04,000
licenses, they roll it out, and 
they just celebrate these 

129
00:06:04,000 --> 00:06:06,760
amazing velocity metrics. 
Yeah, line output goes through 

130
00:06:06,760 --> 00:06:08,720
the roof. 
But they have not braced for 

131
00:06:08,720 --> 00:06:12,520
Phase 2 at all, and Phase 2 is 
when that downstream avalanche 

132
00:06:12,520 --> 00:06:15,560
of code hits the senior 
engineers who actually have to 

133
00:06:15,560 --> 00:06:18,600
review and approve it. 
And that creates a severe crisis

134
00:06:18,880 --> 00:06:21,960
because senior engineer time is 
basically the scarcest resource 

135
00:06:21,960 --> 00:06:25,960
in any tech organization, and 
the nature of the AI code makes 

136
00:06:25,960 --> 00:06:27,960
it uniquely exhausting to 
review. 

137
00:06:28,360 --> 00:06:30,840
Let's talk about why it's so 
exhausting, because there's a 

138
00:06:30,840 --> 00:06:33,120
detail here that is just 
fascinating to me. 

139
00:06:34,000 --> 00:06:37,360
AI generated code looks 
incredibly confident. 

140
00:06:37,400 --> 00:06:41,120
Yes, dangerously confident. 
Like if you have a human junior 

141
00:06:41,120 --> 00:06:44,600
developer submitting a really 
complex database migration, 

142
00:06:44,920 --> 00:06:46,800
they'll usually flag their 
uncertainty right? 

143
00:06:46,800 --> 00:06:48,920
They'll leave comments As for 
architectural guides and say 

144
00:06:48,920 --> 00:06:50,920
like hey, not sure if this is 
going to scale. 

145
00:06:50,960 --> 00:06:54,160
Right, there's humility there, 
but agent generated code carries

146
00:06:54,160 --> 00:06:57,200
0 humility. 
The AI will output a completely 

147
00:06:57,200 --> 00:07:01,000
hallucinated API endpoint or 
just a subtly flawed encryption 

148
00:07:01,000 --> 00:07:04,320
wrapper, but it formats it with 
the exact same authoritative 

149
00:07:04,320 --> 00:07:07,800
styling and variable naming as a
perfectly optimized algorithm. 

150
00:07:08,080 --> 00:07:11,040
It's basically an army of highly
caffeinated interns who never 

151
00:07:11,040 --> 00:07:13,600
sleep and absolutely never admit
when they're guessing. 

152
00:07:13,840 --> 00:07:17,400
That is exactly what it is, and 
so the cognitive load required 

153
00:07:17,400 --> 00:07:20,400
to review that kind of heavily 
refactored, highly confident 

154
00:07:20,400 --> 00:07:23,440
code is immense. 
The senior dev has to trace 

155
00:07:23,480 --> 00:07:27,160
every single logical leap the 
agent made, but without any of 

156
00:07:27,160 --> 00:07:30,120
the human context. 
And the scary part is, according

157
00:07:30,120 --> 00:07:33,480
to a post on the Stack Overflow 
blog, we can't even fall back on

158
00:07:33,480 --> 00:07:35,760
our automated test suites to 
catch these errors. 

159
00:07:35,920 --> 00:07:38,080
Right, because traditional 
testing assumptions are 

160
00:07:38,080 --> 00:07:40,080
completely breaking down. 
How so? 

161
00:07:40,080 --> 00:07:43,280
Like why doesn't a unit test 
just catch the bad AI code? 

162
00:07:43,720 --> 00:07:47,240
Because our entire testing 
philosophy historically has been

163
00:07:47,240 --> 00:07:51,520
built on determinism, you assert
that a specific input will yield

164
00:07:51,520 --> 00:07:55,080
a highly specific, immutable 
output every single time. 

165
00:07:55,080 --> 00:07:57,640
OK, simple enough. 
But if your application is now 

166
00:07:57,640 --> 00:08:00,160
relying on an agent to 
dynamically generate data 

167
00:08:00,160 --> 00:08:03,560
transformation logic on the fly,
the output shape might subtly 

168
00:08:03,560 --> 00:08:06,960
shift between runs. 
It's non deterministic, so your 

169
00:08:06,960 --> 00:08:09,560
strict assertion tests are going
to start throwing red flags 

170
00:08:09,560 --> 00:08:11,400
everywhere. 
Oh wow, so the code isn't 

171
00:08:11,400 --> 00:08:13,520
necessarily broken, but the test
fails anyway. 

172
00:08:13,520 --> 00:08:16,280
Exactly. 
The testing paradigm itself is 

173
00:08:16,280 --> 00:08:18,720
becoming obsolete in an agentic 
world. 

174
00:08:19,200 --> 00:08:21,360
How are organizations actually 
handling this? 

175
00:08:22,000 --> 00:08:23,960
Because the sources talk about a
few mitigations. 

176
00:08:24,440 --> 00:08:26,240
You have companies like Gradient
Labs, right? 

177
00:08:26,680 --> 00:08:31,400
They're deploying GPT 4.1 to 
power AI account managers in the

178
00:08:31,400 --> 00:08:33,600
banking industry. 
Which is highly regulated. 

179
00:08:33,600 --> 00:08:37,080
Super regulated in banking. 
A hallucination isn't just a 

180
00:08:37,080 --> 00:08:39,640
bug, it's a massive compliance 
violation. 

181
00:08:39,640 --> 00:08:43,080
You can't just rely on an 
exhausted human reviewer to 

182
00:08:43,080 --> 00:08:45,400
catch every confident error an 
AI makes. 

183
00:08:45,720 --> 00:08:48,600
Right, So what gradient labs and
others are doing is relying on 

184
00:08:48,600 --> 00:08:50,840
aggressive pre review 
automation. 

185
00:08:50,840 --> 00:08:53,720
Like automated toll booths 
before the human even sees it. 

186
00:08:53,800 --> 00:08:56,840
Exactly. 
Before a human ever lays eyes on

187
00:08:56,840 --> 00:08:59,480
the PR, you force the agents 
code through a gauntlet. 

188
00:08:59,760 --> 00:09:03,320
You use semantic linting, static
analysis and property based 

189
00:09:03,320 --> 00:09:05,880
testing. 
You validate the characteristics

190
00:09:05,880 --> 00:09:08,400
of the output rather than 
looking for an exact string 

191
00:09:08,400 --> 00:09:10,960
match. 
The sources also uniformly agree

192
00:09:10,960 --> 00:09:13,440
that you have to keep AI 
generated pull requests 

193
00:09:13,440 --> 00:09:17,320
extremely small and explicitly 
tag them as AI generated. 

194
00:09:17,520 --> 00:09:20,200
Right, because if you let an 
agent rewrite an entire back end

195
00:09:20,200 --> 00:09:22,840
service and submit it as one 
giant chunk, your senior 

196
00:09:22,840 --> 00:09:24,880
engineering team is paralyzed 
for a week. 

197
00:09:25,240 --> 00:09:28,640
But if you restrict the size of 
what the agent can do, doesn't 

198
00:09:28,640 --> 00:09:31,200
that defeat the purpose? 
Like, doesn't that limit the 

199
00:09:31,200 --> 00:09:33,720
utility of having an autonomous 
agent in the first place? 

200
00:09:33,720 --> 00:09:36,560
It does, which is why the 
industry's next move is 

201
00:09:36,560 --> 00:09:39,760
horizontal scaling. 
If one agent submitting a 

202
00:09:39,760 --> 00:09:43,360
massive block of code breaks the
pipeline, the solution is to 

203
00:09:43,360 --> 00:09:47,480
deploy multiple agents working 
on micro tasks simultaneously. 

204
00:09:47,480 --> 00:09:49,920
OK, and that brings us right to 
this new feature. 

205
00:09:49,920 --> 00:09:53,600
The GitHub blog posted about the
slash fleet command in the 

206
00:09:53,600 --> 00:09:56,880
Copilot CLI. 
This feels like a massive 

207
00:09:56,880 --> 00:09:58,600
paradigm shift. 
Oh, it really is. 

208
00:09:58,600 --> 00:10:00,960
Because you're no longer just 
talking to a single assistant, 

209
00:10:01,040 --> 00:10:04,600
you are basically dispatching an
entire swarm of parallel workers

210
00:10:04,640 --> 00:10:07,320
right for your command line. 
Yeah, and the mechanics of slash

211
00:10:07,320 --> 00:10:10,120
fleet demand an entirely new 
skill set from developers. 

212
00:10:10,440 --> 00:10:13,200
You're orchestrating multiple 
agents across a code base. 

213
00:10:13,520 --> 00:10:16,320
One agent might be updating the 
front end React components, 

214
00:10:16,320 --> 00:10:18,360
while a second agent is 
simultaneously writing the 

215
00:10:18,360 --> 00:10:22,240
database migration and a third 
is updating the API docs. 

216
00:10:22,560 --> 00:10:27,200
But there is a huge catch here. 
The GitHub blog explicitly 

217
00:10:27,200 --> 00:10:30,200
details a major failure mode 
with this swarm approach. 

218
00:10:30,720 --> 00:10:33,440
If you don't perfectly declare 
the interagent dependencies, 

219
00:10:33,600 --> 00:10:36,160
they just trip over each other. 
They absolutely destroy each 

220
00:10:36,160 --> 00:10:39,520
other's work if the database 
agent decides hey I'm going to 

221
00:10:39,520 --> 00:10:43,640
rename this primary key to 
optimize a query, but the front 

222
00:10:43,640 --> 00:10:47,560
end agent is currently binding 
data to the old key name. 

223
00:10:47,560 --> 00:10:49,760
Then the whole code base is just
fractured completely. 

224
00:10:49,760 --> 00:10:51,720
Fractured. 
It's not magic, so developers 

225
00:10:51,720 --> 00:10:53,440
have to learn task 
decomposition. 

226
00:10:53,440 --> 00:10:56,880
You have to foresee the friction
points before you launch the 

227
00:10:56,880 --> 00:10:58,720
fleet. 
You have to explicitly tell the 

228
00:10:58,720 --> 00:11:01,920
front end agent hey, you must 
wait for the database agent to 

229
00:11:01,920 --> 00:11:04,040
finish its schema before you 
even start. 

230
00:11:04,240 --> 00:11:07,440
But wait, let me jump in here. 
Because if I have to spend hours

231
00:11:07,440 --> 00:11:10,120
perfectly mapping out this 
intricate dependency graph, 

232
00:11:10,480 --> 00:11:13,040
telling 5 different agents 
exactly how to interact, aren't 

233
00:11:14,120 --> 00:11:17,600
we just trading the chore of 
writing code for the equally 

234
00:11:17,600 --> 00:11:19,960
tedious chore of writing 
impossibly detailed 

235
00:11:19,960 --> 00:11:21,360
instructions? 
That's fairpoint. 

236
00:11:21,360 --> 00:11:23,080
Like are we actually saving any 
time here? 

237
00:11:23,280 --> 00:11:25,400
You are, but you're shifting the
burden. 

238
00:11:25,560 --> 00:11:28,360
You're moving away from writing 
syntax and moving into the 

239
00:11:28,360 --> 00:11:32,040
architectural layer, but we're 
already seeing solutions to that

240
00:11:32,040 --> 00:11:34,600
specific orchestration burden. 
Really like what? 

241
00:11:35,280 --> 00:11:38,440
The Copilot applied Science team
actually just published findings

242
00:11:38,440 --> 00:11:42,080
on Agent Driven Development. 
They are actively using agents 

243
00:11:42,080 --> 00:11:44,240
to build and orchestrate other 
agents. 

244
00:11:44,280 --> 00:11:46,960
Wait, so a manager agent gets 
the humans broad objective, 

245
00:11:46,960 --> 00:11:50,840
breaks it down, writes the 
dependencies and then launches 

246
00:11:50,840 --> 00:11:51,560
the worker? 
Agents. 

247
00:11:51,560 --> 00:11:53,760
Precisely. 
The manager agent analyzes the 

248
00:11:53,760 --> 00:11:57,400
code base, realizes the database
migration, naturally blocks the 

249
00:11:57,400 --> 00:12:00,320
front end, and it just 
automatically constructs the 

250
00:12:00,320 --> 00:12:02,480
slash fleet execution plan for 
you. 

251
00:12:03,160 --> 00:12:05,680
Managing a swarm of agents like 
that sounds exhausting, 

252
00:12:06,120 --> 00:12:08,680
especially because of a really 
weird cork with these systems 

253
00:12:08,680 --> 00:12:12,280
that the sources highlighted. 
Every single morning your entire

254
00:12:12,280 --> 00:12:14,520
swarm wakes up with complete 
amnesia. 

255
00:12:14,520 --> 00:12:18,240
Yes, persistent episodic memory 
is basically the Holy Grail 

256
00:12:18,240 --> 00:12:19,760
right now. 
Because according to the news 

257
00:12:19,760 --> 00:12:23,760
stack, there's this massive race
between projects like Open Claw 

258
00:12:23,760 --> 00:12:28,080
and Hermes Agent to solve this. 
Right now every AI coding 

259
00:12:28,080 --> 00:12:32,080
session starts from Absolute 0. 
Right, you know developers are 

260
00:12:32,080 --> 00:12:35,240
using things like the clod OD 
dot MD file to help with this. 

261
00:12:35,240 --> 00:12:37,920
You put a markdown file in your 
root directory that just says 

262
00:12:37,920 --> 00:12:40,320
hey we use TypeScript, we prefer
functional components. 

263
00:12:40,960 --> 00:12:42,840
Never use this one deprecated 
library. 

264
00:12:42,840 --> 00:12:44,840
OK, so rules of the road. 
Exactly. 

265
00:12:45,240 --> 00:12:47,880
But that's just static project 
state, it doesn't give the agent

266
00:12:47,880 --> 00:12:50,760
episodic memory. 
Right, so if I spent 3 hours 

267
00:12:50,760 --> 00:12:54,720
yesterday arguing with the agent
about some weird race condition 

268
00:12:54,720 --> 00:12:58,520
in the payment gateway and I log
back in today and say OK, let's 

269
00:12:59,040 --> 00:13:01,760
finish fixing that bug. 
The agent has absolutely no idea

270
00:13:01,760 --> 00:13:03,840
what you're talking about. 
It's so frustrating. 

271
00:13:03,880 --> 00:13:07,360
It's terrible UX. 
To regain the context, the agent

272
00:13:07,360 --> 00:13:10,400
basically has to reinjest the 
entire history of the project, 

273
00:13:10,400 --> 00:13:13,320
all the static rules and the 
current state of the code base. 

274
00:13:13,600 --> 00:13:16,280
It's just a brute force solution
and it completely interrupts 

275
00:13:16,280 --> 00:13:18,960
your flow state. 
And it's not just a UX problem, 

276
00:13:18,960 --> 00:13:20,680
right? 
That brute force memory 

277
00:13:20,680 --> 00:13:23,120
retrieval has a massive 
financial cost. 

278
00:13:23,480 --> 00:13:25,720
If you go on to the developer 
subreddits right now, the front 

279
00:13:25,720 --> 00:13:29,320
pages are just filled with users
freaking out because they are 

280
00:13:29,480 --> 00:13:32,200
hitting their API limit and 
burning through their token 

281
00:13:32,200 --> 00:13:36,480
budgets in literally hours. 
Oh yeah, the token economics of 

282
00:13:36,480 --> 00:13:40,400
an agentic loop are brutal, and 
users are completely 

283
00:13:40,400 --> 00:13:42,800
miscalculating it because 
they're bringing chatbot 

284
00:13:42,800 --> 00:13:45,120
expectations into an agentic 
reality. 

285
00:13:45,160 --> 00:13:46,600
Let's break that down for the 
listener. 

286
00:13:46,960 --> 00:13:49,920
Why is the token burn so much 
worse with an agent? 

287
00:13:49,960 --> 00:13:51,400
Well. 
Think about a chatbot. 

288
00:13:51,760 --> 00:13:55,200
You ask a question, you consume 
maybe a few 100 tokens for the 

289
00:13:55,200 --> 00:13:58,720
prompt and a few 100 for the 
answer. 1 discrete transaction. 

290
00:13:58,720 --> 00:14:01,160
Simple. 
But when you deploy an agentic 

291
00:14:01,160 --> 00:14:04,880
loop to fix a bug, the model 
looks at the code base, writes a

292
00:14:04,880 --> 00:14:07,280
script, executes it, and 
evaluates the error. 

293
00:14:07,640 --> 00:14:10,480
That's just loop 1. 
OK, if it fails, it has to try 

294
00:14:10,480 --> 00:14:12,600
again. 
But to maintain its train of 

295
00:14:12,600 --> 00:14:15,760
thought for loop 2, it has to 
pass your initial prompt, the 

296
00:14:15,760 --> 00:14:19,040
script it just wrote, the error 
it got, and its new hypothesis 

297
00:14:19,080 --> 00:14:20,840
all back into the context 
window. 

298
00:14:20,840 --> 00:14:22,520
Oh I see. 
So the context window just 

299
00:14:22,520 --> 00:14:24,600
compounds on itself every single
time it loops. 

300
00:14:24,600 --> 00:14:26,680
Exactly. 
By loop 10 the agent is 

301
00:14:26,680 --> 00:14:29,880
ingesting 10s of thousands of 
tokens just to remember what it 

302
00:14:29,880 --> 00:14:32,720
already tried 5 minutes ago. 
We're literally paying for the 

303
00:14:32,720 --> 00:14:36,680
agent to reread its own massive 
internal monologue over and 

304
00:14:36,680 --> 00:14:38,720
over. 
So the token consumption rate 

305
00:14:38,720 --> 00:14:42,040
and ends up being 10 to 20 times
higher than a standard chat 

306
00:14:42,040 --> 00:14:42,920
interaction. 
It's. 

307
00:14:42,920 --> 00:14:47,120
Literally the equivalent of 
hiring a general contractor to 

308
00:14:47,120 --> 00:14:49,880
come to your house just to screw
in a light bulb. 

309
00:14:50,160 --> 00:14:53,520
Like yes they can do it, but 
it's massive overkill and you're

310
00:14:53,520 --> 00:14:56,200
going to drain your budget. 
That is the perfect way to look 

311
00:14:56,200 --> 00:14:58,080
at it. 
You have to map the tool to the 

312
00:14:58,080 --> 00:15:00,800
complexity of the problem. 
Single shot prompts are for 

313
00:15:00,800 --> 00:15:04,480
localized syntax generation. 
Save the agentic loops for 

314
00:15:04,480 --> 00:15:08,720
complex multi file refactoring 
where the time you save actually

315
00:15:09,080 --> 00:15:12,840
that exponential Turk and cost. 
This entire deep dive really 

316
00:15:12,840 --> 00:15:15,880
highlights how much software 
engineering is recalibrating 

317
00:15:15,880 --> 00:15:19,000
right now, and when we started 
with that clawed code leak which

318
00:15:19,000 --> 00:15:22,480
showed us that AI autonomy is 
really just relentless looping 

319
00:15:22,480 --> 00:15:24,920
scaffolding under the hood. 
Not spontaneous magic. 

320
00:15:24,920 --> 00:15:27,920
Right, and we saw how the sheer 
speed of that loop shifts the 

321
00:15:27,920 --> 00:15:31,160
bottleneck away from writing 
code and just Burry senior 

322
00:15:31,160 --> 00:15:35,040
engineers under an avalanche of 
confident, non deterministic 

323
00:15:35,040 --> 00:15:38,080
PRS. 
Which is forcing teams to adapt.

324
00:15:38,760 --> 00:15:42,480
They're deploying pre review 
automation, they're using GitHub

325
00:15:42,480 --> 00:15:46,440
slash fleet to run multiple 
micro agents at once, and 

326
00:15:46,440 --> 00:15:49,240
developers are having to master 
task decomposition. 

327
00:15:49,400 --> 00:15:52,640
And of course, navigating the 
whole amnesia problem, plus the 

328
00:15:52,640 --> 00:15:56,200
massive token taxes required 
just to force these models to 

329
00:15:56,560 --> 00:15:58,080
remember what they did 
yesterday. 

330
00:15:58,840 --> 00:16:02,720
It really feels like the 
developer's job is shifting from

331
00:16:03,320 --> 00:16:07,680
writing syntax to orchestrating 
fleets, managing token budgets, 

332
00:16:07,920 --> 00:16:10,600
and basically building fault 
tolerant sandboxes. 

333
00:16:10,720 --> 00:16:13,240
It is, and that trajectory 
actually brings up a deeply 

334
00:16:13,240 --> 00:16:15,440
provocative question about where
this is all heading. 

335
00:16:15,720 --> 00:16:17,800
We mentioned Simon Willison 
earlier in his work with 

336
00:16:17,800 --> 00:16:19,960
sandboxes. 
In a recent discussion, he 

337
00:16:19,960 --> 00:16:22,880
brought up this concept of dark 
factories in the manufacturing 

338
00:16:22,880 --> 00:16:23,840
world. 
Have you heard of this? 

339
00:16:23,840 --> 00:16:25,560
I think so. 
Is that where the physical plan 

340
00:16:25,560 --> 00:16:27,880
is so fully automated that they 
literally don't even turn the 

341
00:16:27,880 --> 00:16:29,960
lights? 
On exactly there are no human 

342
00:16:29,960 --> 00:16:33,120
operators on the factory floor, 
so the entire assembly line just

343
00:16:33,320 --> 00:16:36,000
ones in the dark. 
Wow, OK, that's a wild image. 

344
00:16:36,160 --> 00:16:38,720
Now apply that concept to what 
we've been talking about today. 

345
00:16:39,040 --> 00:16:42,520
We already have the Copilot 
applied science team using 

346
00:16:42,520 --> 00:16:44,320
agents to orchestrate other 
agents. 

347
00:16:44,680 --> 00:16:48,320
We know the ultimate bottleneck 
right now is the human senior 

348
00:16:48,320 --> 00:16:50,280
engineer who has to review the 
code. 

349
00:16:50,440 --> 00:16:52,960
Right, humans are the slow part 
of the pipeline. 

350
00:16:53,000 --> 00:16:55,760
So how long does the human 
actually remain in the loop? 

351
00:16:56,400 --> 00:16:59,160
If an agent can write the code, 
and a manager agent can 

352
00:16:59,160 --> 00:17:02,320
orchestrate the dependencies, 
and a third agent can run the 

353
00:17:02,320 --> 00:17:04,839
pre review semantic analysis to 
ensure it's safe? 

354
00:17:05,280 --> 00:17:08,640
How long until we just decide 
the human reviewer is too slow 

355
00:17:08,640 --> 00:17:11,599
and we replace them entirely? 
Oh wow, we have to ask 

356
00:17:11,599 --> 00:17:15,400
ourselves, are we rapidly 
approaching the era of software 

357
00:17:15,400 --> 00:17:19,200
dark factories where code is 
designed, written, reviewed and 

358
00:17:19,200 --> 00:17:22,160
deployed entirely by machines, 
and we're left with a digital 

359
00:17:22,160 --> 00:17:25,480
infrastructure that no human 
actually comprehends anymore? 

360
00:17:25,560 --> 00:17:27,119
That is a static, staggering 
thought. 

361
00:17:27,359 --> 00:17:30,040
The self driving car isn't just 
navigating the unpaved roads we 

362
00:17:30,040 --> 00:17:33,400
talked about at the start, it's 
basically paving its own routes,

363
00:17:33,720 --> 00:17:37,040
communicating in protocols we 
barely understand and operating 

364
00:17:37,040 --> 00:17:38,840
with the windows completely 
blacked out. 

365
00:17:38,880 --> 00:17:40,680
Moving at speeds we can't even 
review. 

366
00:17:40,920 --> 00:17:43,920
It fundamentally challenges what
it means to be a software 

367
00:17:43,920 --> 00:17:46,920
engineer in the coming decade. 
Definitely something for you to 

368
00:17:46,920 --> 00:17:50,120
consider the next time you 
casually authorize an agent to 

369
00:17:50,120 --> 00:17:53,160
rewrite your repository. 
Thanks for joining us on this 

370
00:17:53,160 --> 00:17:53,760
deep dive.