YT YouTube2Text

YouTube2Text → Transcripts → ELITE Agentic Engineers Are LEAVING THE LOOP... Here’s why

ELITE Agentic Engineers Are LEAVING THE LOOP... Here’s why — Transcript

by IndyDevDan · 5,312 words · 779 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00Look, AI agents make fewer mistakes than
0:02you or I on our best days as engineers.
0:05Don't take my word for it. Give Opus 5.5
0:07a hard task and read the trace.
0:09Seriously, read the trace. It now looks
0:11like an alien engineer running the most
0:14obscene bash commands and tool call
0:16combinations, and it's not a one-off.
0:19Opus and Astra do this
0:20back-to-back-to-back. You and I are
0:22smart, so let's ask smart questions. If
0:25the agent is a better programmer inside
0:27the loop, why are you still sitting in
0:30it? Recent intelligence has unlocked a
0:32new level of capability that the best
0:35engineers are obsessing over. If you
0:37want to know what this new level is that
0:39you can unlock, you're watching the
0:41right video. I've been working with
0:43language models and agents since it was
0:45first possible. Before that, I trained
0:47classic scikit-learn models. I have 15
0:50plus years of software engineering
0:52experience underneath all of it, and
0:54that's exactly why I'm telling you this.
0:56Experience doesn't auto unlock this new
0:59level in the age of AI. Your experience
1:01pays off if you change how you operate.
1:05Not all of us will make this leap. Why?
1:07Because we're doing things the way they
1:09were done yesterday. What are Opus,
1:11Astra, and DeepSeek? These are new
1:13tools, nothing more, nothing less. But
1:15stack enough of them in the right
1:17architecture, and you can change what's
1:19possible by changing how you operate.
1:22And you've been doing this. Instead of
1:24writing the skill yourself, you taught
1:25your agent how to write your skill. Meta
1:27skills, check. Instead of running 10
1:29agents yourself, you ran [music] one
1:31agent to prompt nine. Orchestration,
1:33check. Instead of being stuck in the
1:35loop, realizing you can build [music]
1:37the system that builds the system. And
1:39this begins the critical journey from
1:41human in the loop to near the loop to
1:44finally out the loop. [music] That's the
1:46central topic for this video. I'll show
1:48you three of many near-loop agents I'm
1:50running [music] right now that do real
1:52work before I sit down. And by the end
1:54of this video, you'll know exactly how
1:56to level up your agentic [music]
1:58engineering. Stick around and let's
2:00understand in loop, near loop, out loop.
2:07What if your agents never stopped?
2:14The big question is, what can run
2:17without you next? This is the guiding
2:18question. This moves us from in loop to
2:20near the loop to out the loop. We are
2:22constantly building the system that
2:24builds the system. That's the theme
2:25here. Prompt, click, cron. What do I
2:27mean by this? Let's break it down. When
2:29you're in the loop, it's you and the
2:30terminal. You're constantly applying
2:32your attention to write prompts. When
2:34you're near the loop, you're clicking,
2:36you're responding, you're giving advice,
2:38you're giving feedback. When you're out
2:39the loop, it's full cron. You have
2:41stepped away. You are not a requirement
2:43anymore. And this is the new mental
2:46model for understanding your agentic
2:48engineering skill by the results you can
2:50achieve. If you're improving, you're
2:52building more systems that don't need
2:54you in the loop. You're building more
2:56near the loop systems and more out the
2:57loop systems. So, why is in the loop
3:00such a problem? Let's talk about it.
3:02What's wrong with being in the loop? The
3:03problem with being in the loop is that
3:04you and I, as you know, are the
3:06limitation. You and I are now the
3:09bottleneck. Our agents can do so much
3:11more if we have the right skills, if we
3:13have the right tools, technology, and if
3:14we're operating the right way. This
3:17threshold, this new level of capability,
3:19requires you to change how you're
3:21operating because you and I are the
3:23bottleneck. And the hard truth here is
3:2580% or more of all the work we're doing
3:28right now can run without you, can run
3:30without me with the right system in
3:32place. So, the next question is, what is
3:34this system? And what is this way of
3:36thinking? And as you know, you know,
3:37based on the title,
3:39it's out loop. But then another problem
3:41arises very quickly. Jumping right from
3:43in loop to out loop is hard. So, what do
3:45we do? We create this middle step, this
3:47transition in between fully required
3:51butts and seats, you using all your
3:53attention on the next prompt, you
3:54watching your agent, jumping straight to
3:56out loop is hard and challenging. So,
3:58what do we do? We move near the loop. We
4:00incrementally work toward the future we
4:02want to create where our systems can
4:04operate for us without us by first
4:06stepping away and then stepping in when
4:09we're required. So, the big difference
4:11is are you being proactive or are you
4:13being reactive? You want to be
4:15proactive. You want to build systems
4:16that start working for you before you
4:19sit down. And we've been covering these
4:21on the channel week after week, but it
4:22looks like this. Instead of you being
4:24the trigger, you have a concrete event.
4:27Think webhook. Think cron. Think user
4:30action near interface. Think Jev
4:32classifying an event from your log
4:34stream. There are a million other ways
4:37to kick off your agent. Why are you
4:38still the main one? That's phase one and
4:41phase two agentic coding. That's in
4:44loop. That's yesterday's advantage.
4:46That's fully saturated. You want to
4:48switch to thinking about pro- active
4:50agents, proactive agent systems. The
4:53thing that they need kicks them off. If
4:55you haven't figured it out yet, the
4:56thing they need isn't you. It's
4:58information. And it's the right
5:00information. And that's the job now of
5:02agentic engineers. Get the right agent
5:04the right information.
5:11Why do this? Who cares about proactive
5:13agents? Why am I bringing this up on the
5:14channel for the third time in a row?
5:15It's because work happens before and
5:18after you check in. This is the result
5:19of investing, putting time in, and
5:21creating a system that only requires you
5:23to be near the loop, okay, which is
5:25substantially different than in the
5:27loop. But it's still close enough that
5:29it doesn't feel super disconnected.
5:30Let's walk through a real use case. The
5:31classic one we'll be looking at is some
5:33event comes in to your event stream, to
5:34your log stream. Triage happens. You'll
5:37use Jev to classify the event. You
5:38prepare the patch. And then your agents
5:40present it to you. This is where you
5:42check in. You make a concrete decision.
5:44And then guess what? You can walk away
5:45because you've already built it into the
5:47system what happens next, right? You
5:48have an AI developer workflow executing
5:50on your behalf. Detect event, triage,
5:52patch, ask, apply the change, verify the
5:55change, results saved. This is human
5:57near the loop. Work happens before and
5:59after you check in. Very, very valuable.
6:01So, what are the core elements you need
6:03to understand to build these near loop
6:05systems? Again, themes on the channel.
6:07We've been talking about these week
6:08after week after week, because they
6:09matter so much right now. This is high
6:11signal information. Durable agents is
6:13the first item. Why do we need durable
6:15agents? Why can't we just throw classic
6:17pie, classic cloud code, classic code X
6:19at this problem? It's because we need to
6:20survive crashes, restarts, closed
6:22laptops. Speaking of closed laptops, the
6:24big up level here is a classic theme
6:27that's permeating throughout the
6:28software industry. You want to put your
6:30agent in their own sandbox. You want to
6:32give them their own CPU compute. And for
6:34the labs, also GPU compute. Why is this?
6:37It's because they're always on. It's
6:39isolated. It's safe, if you're
6:40sandboxing properly. And most
6:42importantly, it's autonomous. You're
6:44scaling your agents into their own
6:45environments where they can perform like
6:47you, because they have all the tools you
6:49have. And the most important tool is a
6:51full computer. So, that's not it. This
6:53doesn't make a near loop agent. You need
6:55something else. You need a clear API
6:58layer, so that you can connect a variety
7:00of triggers to actually activate the
7:02system. Again, there are a million ways
7:05to kick off your agent. Why are you
7:06still the main one? Asking yourself that
7:09question, it lets you design the system
7:11where you can move from in the loop to
7:13near the loop. And they're all exactly
7:15what you would expect. Cron triggers,
7:16log events, tickets, right? User
7:18interfaces, drag and drop image events.
7:21And then of course, CLI agents working
7:23on their own time, doing their own
7:25thing, kicking off your near loop
7:26system. So, this is what it takes. These
7:28are the core elements of a near loop
7:31system. This creates something really
7:32powerful once you build it out. The
7:34thing that really makes it a step
7:36change, a level up in your capacity, is
7:38that a durable agent plus a trigger in a
7:40sandbox gives you a proactive agent.
7:43This agent does not wait for you to
7:45work, it works for you then waits. This
7:47is a massively different level of
7:50engineering results you can achieve now
7:52with this architecture. Try to have a
7:54vibe coder vibe code this, they won't be
7:55able to. That's why GrokBot, that's why
7:58dots, that's why Claud's co-work and all
8:00their infrastructure exists is because
8:02they're trying to commoditize this for
8:04the average user and frankly for some
8:06lazy engineers. That's okay if you're
8:08one of them. I will say though this is
8:10technology I highly recommend you own
8:11because this is going to be a key part
8:13of what it means to engineer massively
8:16leveraged results in your favor. Again,
8:18durable agents persist. This is what
8:20makes them so powerful. They persist and
8:22that means that they can ask you things,
8:24they can survive restarts, and then they
8:26can get the job done fully. But they
8:28need to be keeping track of everything
8:30in a repeat basis. Durable agents
8:32require memory. Your normal in-the-loop
8:34agents will not cut it for systems like
8:36this. Hope that's clear.
8:42Once you get these up and running they
8:43become really powerful. So incident
8:45response agent, this is something we
8:46covered on the channel. An incident
8:48comes in, your agents then run a
8:50clear-cut and available workflow, a
8:52workflow that you used to run yourself,
8:54a developer workflow. If you're the
8:56incident response engineer on call, you
8:58detect, you investigate, you root cause
9:00analysis, you fix it, and then you prep
9:02for review. The difference is now you
9:04can build a proactive agent inside a
9:06near-loop system to do this on your
9:07behalf. And then guess what? You are
9:09then just the reviewer, you review the
9:11fix, and then you deploy it. This is not
9:13pie-in-the-sky information. This is what
9:15we cover on the channel week after week.
9:17Here is the real UI that we looked at
9:19for a mock example of what this system
9:21looks like. It's a disconnected client
9:23with streaming events. We're using Jev
9:25to classify the events, and then our
9:27on-call agent found the issue, and now
9:29all you have to do is understand and
9:30click deploy. I've been talking with
9:32main engineers. They are actively
9:34rolling this out right now because the
9:35value prop is there. Proactive agents
9:38can give you value right now. This is
9:40real. This is tangible. Agent work
9:42through, the AI developer workflow, it
9:44waits for your approval, and it is using
9:46Jev to judge every single row. There are
9:49improvements to be made here. If you're
9:50not getting 4xx or 5xx HTTP error codes,
9:54you don't need Jev for that. What you do
9:55need Jev for is to classify the
9:57information very, very quickly to
9:59understand, based on your system, if
10:01it's an issue or not. Okay, so that's a
10:02real example. What else? How else can
10:04you use proactive agents? Last week, we
10:06covered using Jev to filter out hype, to
10:09analyze facts, and then to filter in
10:11signal that we actually care about,
10:13information you can act on. Many
10:16engineers, you know, many content
10:18creators, YouTubers, posters, media,
10:21they just hand wave and talk about this
10:23stuff.
10:24>> [snorts]
10:24>> I like to hand wave, literally,
10:26>> [laughter]
10:26>> and talk about this stuff, but I also
10:27like to prove it so you can better
10:29understand what's happening and what's
10:31possible, so you can go beyond what your
10:33competition can do, so you can actually
10:35act on this information. We have done
10:37this. This UI is real, and I can pull it
10:39up right now. This is on a sandbox, and
10:41this was actually on my M-core Mac mini
10:43right here. If I go to IDD agents, there
10:45we go. Hit enter here. You can see that
10:47this is a durable agent that's on all
10:49the time. It's working for me, and then
10:51it waits for me. This has been on for a
10:53week and a half now. I keep it on all
10:54the time. I'm not going to turn it off
10:56because it's constantly providing me
10:57value. I can hop in here, ingest the
10:59news at light speed. Information is
11:01getting pulled to me. I'm not getting
11:02clickbaited into anything because I'm
11:04normalizing how I want to see the
11:06information in a non-biased way. Again,
11:08check out last week's video where we
11:09covered the durable news agent, but you
11:11can see, you know, real concrete
11:12example. This is stuff I'm building
11:14against right now. This is stuff I am
11:16working with engineers to build all the
11:18time. You can see here, Loom cycle
11:20decision model scores 40 out of 40 on
11:22prompt injections. Interesting. I'm
11:24going to upvote that. I'm going to give
11:25signal to my proactive agent so that it
11:27continues to prompt me with questions it
11:30has, and continue to reinforce the data
11:33flywheel I'm building with this kind of
11:35micro product. This is a key
11:36distinction. The best engineers are
11:38moving from building individual
11:40engineering agents to really product
11:42agents that focus on a specific use case
11:44that outperform the default by miles.
11:47So, this is one of many near loop
11:49systems that I'm building aggressively
11:50right now because again, it's going to
11:52work for me without me and then I'll
11:54come in, I'll extract value, I'll give
11:56feedback and it's going to improve. Real
11:58concrete result. Let me show you another
12:00one that I haven't revealed on the
12:01channel yet. This is new since the Jev
12:031.14 was released. I'm dropping in UI
12:07designs, I'm dropping in mock designs
12:09and then a primitive RSI loop is
12:11running. It's going to build against the
12:13mock and compare over and over and over
12:16until the UI matches the mock design I
12:18passed in. It looks just like this. Fix
12:20build screenshot Jev. It uses two or
12:22more agents optionally. We're just
12:24looking to pass a similarity threshold
12:26for the UI, okay? And you know, I can
12:28show this to you.
12:30Right? This is real. Called the deep Jev
12:32UI replicator and you can see here I
12:34dropped in a screenshot of the phase
12:36three agentic engineering product I'll
12:38talk about at the end. You can see it's
12:40looping, it's hill climbing on this
12:42objective that I gave it and it's just
12:44working and working and working. I can
12:46change the model, I can change the
12:47comparison agent, I can tweak the core
12:48four of the system. You can't build
12:51these systems without understanding the
12:52core four context model prompt tools.
12:54We'll talk about that in a second. Key
12:55skills to know and to learn. Again, a
12:57lot of channels they just try to
12:59newsjack. This is real content, real
13:02ideas that we talk about every week on
13:03the channel. We are putting these ideas
13:05into action to generate real value, real
13:08alpha. Let me show you exactly what I
13:09mean. Bam, here it is. This is on a
13:11cloud sandbox, so this is not local
13:14anywhere, this is in the cloud. You can
13:15see here I had Astra mirror this UI, it
13:18got a 86.1 match. I just drag and
13:21dropped an image in and it looped over
13:23this. You can see I have another one
13:24here. Let's go to another example here
13:26mirroring the phase three landing page.
13:28You can see slowly he'll climb toward
13:30this. Got a decent result here after
13:32iteration three, and then it failed to
13:34mirror even further. Okay, this was the
13:36Sonic 5.5, so not bad. But you can see
13:38here, you know, again, it's a system
13:40that delivers me concrete results. I can
13:42come in, ask for something, and then
13:43leave. I walk away while it works. It
13:46takes, you know, some 30 minutes for all
13:48these iterations to run, to basically
13:50recursively work toward an example.
13:52These are all big ideas, big themes
13:54we're talking about on the channel all
13:56the time, week after week. The next leap
13:58is here, and I'm going to do my best to
14:00communicate it to you, the mid senior
14:02plus level cracked engineer. This is
14:04where it all leads, these powerful
14:06systems. Let me make it super clear,
14:08once again, that these are just clients.
14:10Like when I connect to the browser, I
14:11can connect to some of these via my
14:12terminal or my phone, and they're all
14:14backed by some sandbox. Because, again,
14:18proactive agents are always on, they
14:19don't turn off. Just like when you walk
14:22away from a session, at the end of the
14:23day, you close your clo- your code, you
14:25close your codex, you close your pie,
14:26it's done. The value you can get when
14:29you build a system like this is immense.
14:32There are other new, next level
14:33problems, you know, next generation, but
14:36all next emerge, but right now the goal
14:38is to move from in loop to near loop to
14:41out loop. And so the sandbox
14:42architecture is really, really
14:44important. You do not want your agents
14:45to be limited [music] by your device.
14:52Why do we build these durable agents?
14:54These agents persist on the device. Why
14:56do we need them? First off, they can be
14:58proactive. They can start working before
15:00you show up, before you wake up. They're
15:01multi-client. Again, browser, terminal,
15:04phone, anyone, anywhere can connect to
15:06it. This is really important for
15:07products. And then, of course,
15:08multiplayer. You, product, design,
15:10support, if you build and you give them
15:12the right tool, they can hop into the
15:14right agent to get the work done much,
15:16much faster than they would otherwise.
15:18Long-running. Durable agents survive
15:20crashes, they survive restarts, and they
15:21have to. They have to have this
15:23property. And then finally, all this
15:25builds up to the fact that this lets you
15:27move near the loop. It removes the seat
15:29from underneath your butt. Okay? You
15:31don't have to be sitting in the dev
15:33chair. And this is a big unlock. I hope
15:36that's clear. So, what are the essential
15:38skills to learn? It's the essentials.
15:39Again, this is like our bread and butter
15:41on the channel. Context model prompt
15:43tool. This is the measure of how far you
15:45can move out. You know, we've been
15:46talking about this for literally years
15:49on the channel. Context model prompt
15:50tools. It all comes back to this. The
15:52agent is made of these four. And you've
15:54heard of all these skills, you've
15:55learned and expanded on your abilities.
15:58Most engineers, most content creators,
16:00most people talking about agents,
16:02they're just focused on this. This is a
16:04lot of the earlier channel videos. We've
16:06moved up a lot from this stuff.
16:08Sometimes we jump back in and cover, you
16:10know, some system prompt engineering or
16:11some context engineering trick, or maybe
16:13we'll cover a model if it's interesting
16:15enough. But really, these are the new
16:16lower-level primitives. The one that's
16:18really worth a lot of attention and time
16:20when you move to the mid and advanced
16:22levels is really harness engineering.
16:23Because it starts to move and wrap this
16:26powerful intelligence in a system that
16:28can outperform the baseline and do
16:30really unique things. It's why I
16:32constantly talk about the Pi coding
16:33agent and Pi durable. It's because there
16:36you can really expand and give your
16:38agents more actions and customize the
16:41results they can get. Specialization is
16:44the advantage, and a lot of engineers
16:46are really noticing this as everyone,
16:48their mom, their brother, their sister,
16:49their dad can prompt and build a air
16:51quote application, right? Or reverse
16:53engineer anything. The advantage then
16:55becomes how can you specialize your
16:57results? How can you build a system that
17:00can do what others could not do? This is
17:02where software engineers have a huge
17:04advantage. That's the big idea.
17:05Mastering your context engineering, your
17:07tokenomics for the model you're
17:08selecting. It needs to be performant
17:10enough to get the job done, but not so
17:12expensive that it breaks the bank. These
17:14insanely subsidized subscriptions will
17:16not last forever, so understand
17:18tokenomics. Shout out deep seek. Then of
17:20course, prompt engineering is how you
17:23instruct your agent in the first place.
17:25If you can't write a great system
17:26prompt, if you're stuck relying on the
17:28defaults, it's going to be really hard
17:29for you to move near loop and out loop.
17:31You must understand both the user prompt
17:33you pass in all the time and the system
17:35prompt to change the law for your agent.
17:37And then of course, the tools, the
17:38harness. This is a big one and these all
17:40make up the core four. You must learn
17:43these skills to transition out the loop.
17:45Otherwise, you'll be stuck at the lowest
17:46level because you'll be relying on
17:48whatever the out of the box cloud code,
17:50the out of the box codex, the out of the
17:52box experience of the agent harness, the
17:54out of the box results that everyone
17:56else is now receiving. Again, the
17:58advantage of a single agent in the
18:00default configuration is completely
18:02saturated. It's been that way for a
18:04while now. Everyone's relying on the
18:05models to improve this. That is just one
18:08dimension of four that you, the
18:10engineer, can tap into to multiply your
18:13leverage. Agentic engineering is
18:15understanding these four. Your context,
18:17your tokenomics, your prompt and your
18:19harness engineering. And the big thing
18:21that I think the industry is really
18:23losing their brains over right now and
18:24viewers of this channel understand
18:26deeply is that all this is multiplied by
18:28your software engineering because this
18:30is what you know. These are the
18:31questions you can ask. These are the
18:33architectures you can build. This is the
18:35expertise you have in your domain that
18:37you've been building up year after year.
18:39The value of this cannot be overstated
18:41now because you can now use the rest of
18:43these items. You can now use these new
18:45paradigms to multiply, and I really mean
18:47multiply what you can do. I know it's so
18:49cringey just throwing out phrases like
18:51multiply, exponential, parabolic, but
18:54it's true. It's factually true. And this
18:56is available to you because you can use
18:58these powerful new intelligent tools and
19:01then apply your knowledge in the context
19:03and the tokenomics and the prompt and
19:04the instructions and in your harnesses.
19:06The gap for engineers truly upskilling
19:09their agentic engineering has never been
19:11higher. As I always say, vibe coding is
19:13the floor, agentic engineering is the
19:15ceiling. So, what do I mean by this?
19:17Let's be super concrete. So, you select
19:19a specific model at the right cost
19:21performance speed trade-off. You then
19:23build a custom agent harness using
19:25whatever SDK you want. I recommend Pi.
19:27This enables you to start harness
19:28engineering specific tools to generate
19:31specific results for your product or
19:32application. You then realize that your
19:34agent could start firing off some
19:36negative commands. So, what do you do?
19:38You add a Jeff damage control. Maybe you
19:40get rid of the bash tool entirely
19:42because you realize how dangerous it is,
19:44and you just give your agent the exact
19:45results it wants. This is agentic
19:48engineering. This is a concrete example
19:49of you applying your expertise, your
19:51awareness, your understanding of
19:52security, of your product, right? What
19:55your product needs, your understanding
19:56of model selection, tokenomics, harness
19:59engineering, you passing in the right
20:00prompts to this system. These are skills
20:03that make up agentic engineering. This
20:05is how you move from in to near to out.
20:08You build these systems so well, you
20:10don't have to look at what they're
20:11doing. That's the key. Again, not to
20:13flame or rip on all my vibe coders that
20:15show up, you know, shout out to you
20:16guys, but vibe coding is not knowing
20:18what your system does, and it's not
20:20looking. Agentic engineering is knowing
20:22what your system does so well, you don't
20:24have to look. The The difference is
20:26massive. This is what it looks like. You
20:28are building the application layer. You
20:29are prompting your agent. We want to
20:31move to this new paradigm where you
20:32build a system that then builds the
20:34system on your behalf. That's the
20:36target. This is what it looks like.
20:37Build a system that builds the system.
20:39This is the guiding phrase I used for
20:41tactical agentic coding, the phase two
20:43product I put out a year ago now, which
20:45is still relevant, by the way, but the
20:47third phase is coming, and this single
20:50phrase still holds true. And so, here's
20:53the measure of your success now. You can
20:54use this as a concrete model, a concrete
20:56framework I'm recommending for
20:57engineers. This is something I'm
20:58obsessing over right now. Your measure
21:00of success is how many agents are
21:02working for you right now. Right now. In
21:05this very second.
21:07Now, obviously, I'm not talking about
21:09token maxing. Anyone can spin up a while
21:11loop and have an agent just do random
21:13I'm talking about useful work that
21:15you need to get done, and this stuff is
21:17happening. Right? I'm talking about
21:18useful work that can multiply your
21:19abilities in ways that you understand,
21:21and ways that you might not have
21:22foreseen yet. I'm talking about products
21:24that you've built with agents inside
21:26running for you without you. I'm talking
21:28about Near Loop and Out Loop. The
21:30advantage is very clear. You can only
21:32focus on so much. You can only split
21:34your attention across so many terminals
21:36before you lose your mind and lose
21:38focus, and now all these three threads
21:40have turned into three threads where you
21:42have no idea what's going on. And you're
21:43just trusting the model more and more.
21:45That is not engineering. Engineering is
21:47building systems that you reliably know
21:49what they'll do to get the results
21:51you're looking for. This is the measure
21:53now. This is the move from low-leverage
21:55agentic engineering to more-leverage
21:57agentic engineering to high-leverage
22:00agentic engineering. You build the
22:01system that is built so well, you step
22:03away because you realize you are the
22:07bottleneck. The next leap is here. If
22:08you've been with the channel week after
22:10week, month after month, you know what's
22:11coming next. Phase three is the
22:13deprecation phase. Augment, automate,
22:15deprecate. This is the three-stage cycle
22:17of every technological revolution. This
22:19is where we employ ZTE zero-touch
22:22engineering. If you've been with the
22:23channel, you know what I'm going to do
22:24next. I'm going to pitch
22:26the next phase three product that I'm
22:27building right now for advanced
22:30engineers using agents every single day.
22:32Link's going to be in the description
22:33for you. In [music] phase three, we
22:35focus purely on Out Loop agentic
22:38engineering. This is the next leap.
22:40[music] The thing to master is going to
22:42be all the fundamentals so that you can
22:43deploy them into these systems that,
22:45again, work for you without you. Link in
22:48the description for that. Pre-sale
22:49starts soon, and throughout pre-sale,
22:51I'm going to be offering a huge discount
22:53on the product. And if you are a phase
22:54two tactical agentic coding member,
22:56you'll also receive a large discount on
22:58the product. I'm so, so excited to share
23:00this with you. It's coming along really,
23:02really well. What is this transition?
23:04Why is it so important? We're moving
23:05from in loop where you prompt to near
23:07loop where you approve to out loop where
23:10you observe. This is the key flow. This
23:12is the progression for agentic engineers
23:15now. So, how do you actually do it? How
23:17do you move out the loop? You master the
23:19core four. You master what makes up the
23:21agent. You use durable agent to solve
23:23real problems. This agent keeps running.
23:25It's looking for triggers. You build
23:27systems that build systems. This is the
23:30key thing that software engineers can do
23:32that no one else can. It's always been
23:34this way. But now it's clearer than ever
23:36because the leverage is higher than
23:37ever. And then, like and subscribe.
23:40>> [laughter]
23:40>> Stay connected to valuable information
23:42to engineers actually doing the thing,
23:45not just covering the news, not just
23:46covering the new model release with the
23:48shock Mr. Beast O face thumbnail.
23:51>> [laughter and gasps]
23:51>> Right? Like this is our bread and butter
23:52on this channel. I've been here 4 years
23:55covering this week after week every
23:57single Monday for years now. And guess
23:59what? I'm going to do it until the end
24:01with you because this is the most
24:03incredible opportunity that has ever
24:05existed for us engineers. Maybe you
24:07missed the internet revolution. Maybe
24:08you missed the mobile revolution. Maybe
24:10you missed social. Maybe you missed
24:12crypto. You and I are here right now in
24:14the age of agents. Let's capitalize on
24:17this. This is what we focus on every
24:18single week here. Again, like and
24:20subscribe. Join the journey. Tell the
24:21algorithm this is signal for you. I've
24:23got three really important links for you
24:25in the description. Pre-sign up for the
24:27phase three product. If you use agents
24:29every single day, if you understand this
24:31advantage, if you're an advanced user of
24:33agents, that's going to be for you. If
24:35you don't fall into that bucket, I'm
24:36sorry, this product is not for you. This
24:38is going to be the most complex course,
24:40the most complex product for engineers I
24:41have ever created and the most valuable.
24:43So, that's linked in the description.
24:44And then I have previous week's video
24:45where we talk about and break down two
24:47real durable agent use cases. You saw us
24:49cover here, the durable news agent and
24:51the on-call agent. Over the next month
24:54leading up to the the
24:55of the phase three product, I'm going to
24:57be sharing content directly from the
24:59phase three products to give you a
25:00teaser of what's coming next to really
25:02paint the picture of what you can do and
25:04what's inside the product so you can
25:06know what you're getting so that you can
25:07hop on the discount. I want [music] to
25:09reward engineers that move fast and
25:11invest in themselves. So again, link in
25:14the description for that. It's going to
25:15be you or your competitors [music] that
25:17make this leap and I want it to be you.
25:19Whenever you sit down in the terminal,
25:20when you put your butt in the seat, I
25:22want you to really stop and [music] ask
25:23yourself, "Is there reason I'm still in
25:26the loop for this work?" And the answer
25:28should truly only be yes if you are
25:31building the system that builds the
25:32[music] system. Comment down below if
25:34this all makes sense to you. Thanks for
25:35watching till the end. I'm going to be
25:36with you here till the end. You know
25:38where to find me every single Monday.
25:41Stay focused and keep building.

About this transcript

This page contains the full transcript of ELITE Agentic Engineers Are LEAVING THE LOOP... Here’s why by IndyDevDan, generated from the public captions YouTube serves with the video. The transcript has 5,312 words across 779 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.