YT YouTube2Text

YouTube2Text → Transcripts → FORGET Loop Engineering. Agentic Engineering is about THIS

FORGET Loop Engineering. Agentic Engineering is about THIS — Transcript

by IndyDevDan · 6,447 words · 948 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00It's time for us to talk about loop
0:02engineering. I was hoping this would
0:03just blow over after a couple weeks. I
0:05was hoping a cracked engineer would call
0:07this stupid phrase what it really is,
0:09but no one has. So, I'll do it myself.
0:13Forget about loop engineering. It's the
0:15wrong way to think about building
0:17valuable software with agents at scale
0:20consistently. Loop engineering is a
0:22terrible rebrand of the software
0:25development life cycle. It's as unclear
0:28as it is hype-filled. In this video, we
0:31simplify loop engineering and call it
0:33what it really is. If you understand
0:35this concept properly, we're going to
0:37break down in this video, [music]
0:39you'll accelerate far ahead of the AI
0:42industry. Clarity and simplicity of
0:45information gives you [music] speed and
0:48performance in your work. It's much more
0:50valuable and helpful to think about
0:53building with [music] agents as if
0:55you're building developer workflows
0:57inside your software factory. Your props
1:00[music] go into your software factory. A
1:03specific workflow runs. Each workflow
1:05[music] is a combination of code plus
1:08agents and then your results [music]
1:10come out. Forget about loop engineering.
1:13Focus your valuable engineering time and
1:16tokens on building AI developer
1:19workflows.
1:25So, first off, who am I to go up against
1:28big ideas from AI engineers like Boris
1:31Churnney from Anthropic and Peter
1:33Steinberg, now from OpenAI? If you
1:35already know who I am and the work I've
1:37done, or you don't care, skip to this
1:39timestamp. My name is Dan Eisler aka
1:41Indie Dev Dan. I'm a software engineer
1:43with over 15 years of EXP. I started out
1:46building Adobe Flash games with Action
1:48Script 2 and three with my brothers. I
1:50interned at Blizzard and then I quickly
1:52moved into the finance and accounting
1:54space programming in C, TypeScript,
1:57Python, God awful React and God bless
2:00Evanu for creating Vue. I was AI coding
2:03before anyone had a name for it with
2:05tools like Ader and classic models like
2:08GPT3.5 Turbo, GPT4, and Sonnet 3. Tools
2:12and models you've probably never heard
2:14of or used. I own the domain name
2:17agenticengineer.com
2:18where thousands of engineers you've
2:20heard of from companies you know have
2:22improved their agentic engineering
2:24thanks to information products I've
2:26built by hand. But anyone can pick up a
2:29domain name and create a course though,
2:31right? Sure. I also have an irrefutable
2:33trail of code and content for engineers
2:37on GitHub and this YouTube channel every
2:40single week for years now. You can see
2:42myself and engineers that follow this
2:44channel consistently ahead of the curve
2:47of the AI industry. I don't just farm
2:49news for views like every other tech
2:52content creator. On this channel, we
2:54think, plan, and build. Every few
2:56months, it's important for me to sit
2:58down and say this. I'm not a content
3:01creator. I'm a software engineer that
3:03does content creation on the side. Why?
3:06Because this technology is too valuable
3:09to fall into the hands of a lucky few.
3:11And yes, I sell courses. And yes, I
3:14benefit from it. Big whoop. Don't do
3:16anything you're great at for free.
3:17Welcome to capitalism. Enough about me.
3:19I don't show up here every single Monday
3:21to gloat and talk about myself. I show
3:23up here to give engineers like you an
3:25advantage you can use to accelerate your
3:28career, your work, your business, your
3:30engineering in the age of AI, no hype.
3:33So, forget about loop engineering and
3:36focus on this instead. There are now
3:39three actors of value creation for
3:42engineering work. The engineers like you
3:44and I, there are the agents and there's
3:46the code. Knowing when and where to
3:49place each of these is the name of the
3:52game of agentic engineering. And you
3:54might be thinking, where is he going
3:55with this? How does this relate to loop
3:57engineering and developer workflows?
3:59Stick with me here. We're going to work
4:00up to it. If you master the
4:01fundamentals, you'll master the
4:03compositions. Everyone in their AI
4:05psychosis seems to forget code is fast,
4:09always runs the same way unless you tell
4:11it not to. And guess what? It costs
4:13nothing. There are no token costs
4:15associated with code. the thing that
4:17truly moves at light speed. There's a
4:19hidden cost to implementing every single
4:21one of these actors of value creation.
4:25Everyone's talking about agents. We're
4:27all well aware of the cost of engineers,
4:29but code is the unsung hero of all of
4:32this. Consistent value creation creates
4:34consistent business value. And out of
4:36these three, code is the most reliable
4:39by miles followed by engineers [music]
4:42and then agents. So let's start with the
4:44most basic developer workflow.
4:50An engineer prompts an LLM and the
4:53engineer reviews the result. This is the
4:55simple foundation that makes up every
4:58single loop, every single workflow,
5:01every single piece of work moving
5:03forward. Now, of course, we're not just
5:05using the LLM anymore. In this central
5:07node, we have an agent. Insert your
5:10favorite agent. Insert your favorite
5:11model. It doesn't matter anymore. It's
5:14about the workflow that you and I
5:16execute every single day. Great. Let's
5:19scale it up. Now, we have code, agents,
5:22and engineers all involved in the
5:24process. We're building up to more and
5:27more advanced developer workflows.
5:29You'll notice something really important
5:31here. We now have code. In this case,
5:33we're just running a llinter. We have a
5:35condition. If the llinter fails, the
5:37results go back into our build agent. If
5:40they're successful, it passes. This
5:42condition and this routing back to our
5:45build agent creates our first loop.
5:47Hence the term loop engineering. But
5:50loop engineering is too simple. It's too
5:52inaccurate. And there's a lot more to
5:54this story. So what comes next? How can
5:56we continue to enhance our developer
5:58workflow to get better results? We can
6:00of course add more deterministic code.
6:03Now we have multiple pass fill
6:04statements routing back into our build
6:06agent. Your codeex, your cloud code,
6:08your pi coding agent, whatever your
6:10agent harness is. This is the foundation
6:12of what it means to build with agents.
6:14Now you have three actors in this.
6:17Engineers, agents, and raw code. You
6:20have to leverage them all in the right
6:22location at the right time. Here we're
6:24adding a code formatter. It doesn't
6:25matter what language you're in. linting
6:27your code, formatting your code, type
6:29check your code, and then keep scaling
6:31up the validation loops to run back into
6:35your agents. Once again, you'll see here
6:37these conditions is what makes up what
6:40is called the loop. But there's a lot
6:42more going on here. This is really a
6:44workflow of how information travels
6:47within a system. Okay, keep scaling it
6:50up. What comes next? We can add more
6:53code. A very valuable piece of code here
6:55is testing your code. So test. Now we
6:58take all these results, feed it back
7:00into our build agent over and over and
7:02over until the results all pass. And
7:05that gives us our final engineering
7:07review. You'll notice a pattern here.
7:09You and I always show up at the ends.
7:12These are the two constraints of a
7:13gentic engineering. Prompting, also
7:16known as planning, and reviewing, also
7:18known as validation. If you're a gent
7:20engineering at scale properly, you're
7:22showing up at the beginning and the end
7:25with a few exceptions. Your AI developer
7:27workflows start simple like this, but
7:29they should continue to grow. Real
7:31engineering work looks a lot more
7:33complex than this, [music] right? What
7:35do we do next?
7:40We can scale all of our testing, all of
7:43our validation, all of our linting, all
7:45of our type checking into a single test
7:47agent. So now we're scaling our compute
7:50to scale our impact. We're adding
7:52compute to add confidence. Now you can
7:54imagine we've handed this test agent all
7:57the things we want to do to test. And if
7:59something goes wrong, we send the
8:01context back to the build agent. If it
8:03passes, the engineer reviews and then we
8:06can ship the deliverable. We can ship
8:08the code. All right. So notice a couple
8:09themes working here. As you scale up
8:11your developer workflows, you add agents
8:14and you add code. But what you don't
8:16want to add is more engineering effort
8:18outside of building the system that
8:21builds the system. Let's keep scaling
8:22this up. Let's add planning to the
8:25workflow. You're very familiar with
8:26these ideas, right? We're building
8:28workflows. These are all steps that you
8:31and I, the engineer, used to take and
8:33used to execute ourself, right? We would
8:36plan work, we would build the work, we
8:38would test the work, we would then have
8:40another engineer review the work, and
8:41then we would finally ship it into
8:43production. All right? It's a developer
8:45workflow and all we've done here is
8:47added AI to it. The loops is just one
8:50piece of it. You can call it loop
8:52engineering but it's inaccurate and it's
8:54not encapsulating the whole picture. If
8:55we have loop engineering, we need to
8:57have condition engineering and then we
8:58need to have function engineering and
9:00then we need to have a word plus
9:02engineering for every type of control
9:03flow inside of the software development
9:05life cycle which is going to go on
9:07forever. Okay. So a very popular pattern
9:10is to push each one of your agents into
9:13their own work tree. This creates
9:14isolation. This creates parallelism.
9:16This lets you do more work in parallel.
9:19And there's a nice side effect here
9:21where the agents don't trip over each
9:22other. So, guess what we're going to do?
9:24We're going to write another prompt. And
9:26this time, we're going to write a prompt
9:28into a piece of code that's going to
9:31build our work trees. All right. So,
9:33here we have a deterministic piece of
9:34code that's going to kick off multiple
9:37work trees based on the prompt. And then
9:38we're going to execute several different
9:41agents running in line. So we have once
9:44again scaled our compute to scale our
9:47impact. We have multiple work trees
9:49running our plan, build, test, review,
9:52merge, ship pipeline, our developer
9:56workflow. The workflow you and I used to
9:58go through as engineers building by
10:02hand. Now we have AI, hence AI developer
10:05workflows. And this is really important
10:07to think through. This is where you
10:09should focus in your engineering time.
10:11How can I combine the three actors of
10:14value creation, engineers, agents, and
10:17code to create workflows that execute
10:20large amounts of work on my behalf, on
10:23behalf of my company, on behalf of your
10:25users and products? That's the name of
10:27the game. Okay, so great, we have work
10:29trees. Work trees are um like I like to
10:32say, a great place to start, not a great
10:34place to end. There are a lot of
10:35problems with work trees. We can do one
10:37better by giving our agents each their
10:40own sandbox. Okay? So instead of
10:42spinning up work trees, we're now giving
10:44every single agent their own computer,
10:47right? Their own agent sandbox to
10:49operate. Because once you do this, you
10:51have full isolation. You yourself can
10:54jump into the sandbox to look at the
10:56work, look at the result, look at the
10:58web page, look at the tests, look at the
11:00application, whatever you need to do, do
11:02your review. And then of course once all
11:04the work comes back in you merge and you
11:06ship. So once again notice the three
11:09actors of value creation working
11:11together. And notice how your ability to
11:14create these AI developer workflows is
11:16your ability to scale your impact with
11:19agents. It's designing these AI
11:22developer workflows that is the most
11:24value accreative thing an engineer can
11:26do. Hence the term I like to say on the
11:29channel all the time. You want to be
11:30building the system that builds the
11:33system. Okay? As you can see here,
11:35you'll start to see similarities in
11:37these workflows with a lot of work
11:39you've seen, a lot of work that you've
11:40done, and hopefully work that you're
11:42building into your teams, your
11:44co-workers, your business, your tools
11:46themselves. Okay? We're just getting
11:48started, [laughter] right? Uh real work
11:51gets more and more complex. And this is
11:53the art and science of agentic
11:56engineering. So, let's keep scaling it.
12:02A very common thing to do as you
12:04continue to progress is to set up a
12:07conbon board, some type of ticket
12:09system. Input comes from all over your
12:12organization, right? It comes from
12:13support, it comes from product, and it
12:14comes from engineers, right? So now
12:16things get interesting because now we
12:17have a new unit, a new wrapper around
12:20our code, right? We have some type of
12:22ticketing system. And so once again,
12:24like there's this really important
12:25delineation that I make inside of
12:28tactical agentic coding. And it is this
12:30idea of the agentic layer. The agents,
12:33the prompts, the skills, the system
12:36prompts that wrap your application are
12:39the thing to be focused on right now.
12:41Because when you put those together with
12:43your code, with your system, with your
12:45entire team and your organization, you
12:47are agentic engineering. Agentic
12:49engineering is not just about the
12:51agents. Spoiler alert, it's about your
12:54team and most importantly your users and
12:56putting together the most valuable stack
12:58of the actors of value creation. Okay,
13:01so conbon board, right? Let's let's jump
13:03into this. What does this look like?
13:04Okay, so for most teams, your tickets
13:06are then analyzed by your engineer who
13:09actually knows what's going on and
13:10they'll translate that into a mid to
13:12low-level prompt that you'll then pass
13:14into another full workflow, another
13:17agent sandbox. But some advanced teams
13:19if you're teaching your organization how
13:21to write prompts well enough and as
13:23models become more capable uh you can
13:25skip your engineer input prompt here
13:27right because your engineer's job should
13:29be building the system we act on the
13:31meta layer we act on the layer that can
13:33compound across our organization okay so
13:35advanced teams can skip the engineering
13:38prompt if this step is done properly all
13:40right but so you know this is code right
13:42conbon boards it's just code there are
13:44no agents there then we enter the meat
13:46of our workflow where we run code to
13:48move that ticket into planning. Guess
13:50what happens next? Our agents take over
13:52the pipeline. We'll have a scout agent
13:54look for all the code, look for all the
13:56tickets, look for all the documentation,
13:57look for previous spec files, and then
13:59it'll hand that to a plan agent. Right?
14:01So, we're splitting up our searching and
14:03our planning between two agents here.
14:05Once again, scaling compute, scaling
14:07impact. And after that happens, you
14:09know, plan phase is complete. So, we run
14:11code to update our ticket to move
14:13context to do some specific work inside
14:15of our sandbox. And then of course our
14:17build agent kicks off. And you know what
14:19happens from here. You've done it a
14:21million times yourself. And now with
14:23agents, your build agent moves it into
14:26testing after it's done. And then your
14:27test agent tests, right? This individual
14:30loop, which is just one part of the
14:32developer workflow, executes until the
14:35result passes. And then we're going to
14:37run our CI/CD. And guess what can happen
14:39here? This can pass or it can fail and
14:42go right back to the build agent to
14:43resolve the issues. All right. And then
14:45we get outside the sandbox. Engineer
14:47reviews the code. You know what this
14:48looks like now? Fail, pass, ship. Right?
14:51So you can see this is much more than
14:54just prompt engineering. It's much more
14:56than context engineering. It's much more
14:57than harness engineering. It's much more
14:59than loop engineering. This is about how
15:00teams move as an organism with all the
15:04actors inside. Okay? And if you're a
15:07small solo dev shop, same deal, right?
15:09It's about how you and your agents work
15:11together with code to generate valuable
15:15results. But this isn't the end. The
15:17future of engineering is vast. Okay,
15:19let's keep pushing this. What happens
15:21next? Let's let's imagine another
15:23scenario here. Imagine you have a
15:25support crisis. Production is down.
15:28Okay, production has crashed. So, what
15:31AI developer workflow do you have
15:33planned in your organization right now
15:35when production goes down? How are you
15:37leveraging engineers, agents, and code
15:40to resolve this issue and to stop your
15:42business from leaking cash as your
15:45production system is down? Let's walk
15:47through it, okay? Because we've thought
15:49through this, right? We've designed,
15:51we've architected the AI developer
15:53workflow to account for this situation.
15:55Support files a ticket. In our case
15:56here, this goes right to Slack. It goes
15:58right to Teams, goes right to your
16:00communication channel, and one of your
16:01cracked engineers picks this up
16:03immediately. What do they do? They
16:04prompt a scout agent that routes right
16:07into a hot fix agent. Your hot fix agent
16:10has a specialized set of mental memory.
16:13It's an agent expert that knows and is
16:16prioritized to get things fixed. It's
16:18not doing things the right way. It's not
16:20doing things the fancy way. It's not
16:21optimizing anything. It's getting the
16:23fix out ASAP and nothing else. This is a
16:25surgical hotfix agent, a custom agent
16:28that you have specialized, that you've
16:30templated your engineering into. Now,
16:32what happens here? Human in the loop.
16:34This is a hot fix. We need to know the
16:35solution is going to work. So you put in
16:37human effort, right? You use engineering
16:39effort to approve or reject. This
16:41creates a single loop. All right? If we
16:43approve, guess what happens? We're going
16:45to build up a bunch of sandboxes to run
16:47the solution in parallel. And guess
16:49what? We're using multiple sandboxes. I
16:52want the first fastest agent that has
16:54the solution to win. Okay? Whatever your
16:56compute budget is, you'll scale this up.
16:57You'll scale this down. If you're in a
16:59production system that's complex, you
17:00might want three, five, 10 agents
17:02running and racing toward a solution in
17:04their own agent sandbox, you don't care.
17:06You have the compute, you've done the
17:07agentic engineering to scale your
17:09impact. And guess what happens here? You
17:11already know what happens. It runs its
17:12individual loop in their sandbox. And
17:15then it passes or fails. If it fails, it
17:17goes right back to your hot fix agent
17:19and to you to resolve. And of course, if
17:21it's all successful, you the engineer
17:23validate it and you get the hot fix
17:25shipped ASAP. Okay. A question for you
17:28and your organization. Do you have an
17:30agentic workflow for production crashes?
17:32Can you get that resolved in record time
17:35using the three actors of value creation
17:38in the age of agents? Engineers, agents,
17:41and code. All three. Okay, this
17:44continues to scale and scale and scale.
17:46Let's push these workflows further.
17:49After some point, what you get is a
17:51structure like this.
17:57And this is what really starts turning
17:59into a software factory. Okay, you'll
18:02see here we have many different types of
18:04specialized agent sandbox workflows.
18:07Some are for chores, one is for a bug,
18:09one is for a feature, one is for this
18:11hot fix that we just walked through. And
18:13you get the idea here, right? Any
18:15specialized AI developer workflow you
18:18need can be built and routed to thanks
18:21to your routing system. Okay, this is
18:24the art and science of agentic
18:26engineering, right? This is all of it
18:28put together. The loops are just one
18:30small piece of this picture. I hope you
18:32can see that. Now, in all this is a
18:35great level of prompt context harness
18:38engineering. There are a million ways to
18:41do this. There are a million different
18:43multi- aent orchestration patterns to
18:45build into this. The key here is this.
18:49is that you have the right combination
18:51at the right time to push engineering
18:54work through end to end with agents with
18:57code with engineers. Okay, I know I'm
18:59repeating myself. I'm doing it on
19:01purpose. Most success in any domain is
19:04about doing a few things and saying a
19:06few things and focusing on a few things
19:09over and over and over. Let's walk
19:11through a full software factory. You can
19:14imagine how this looks, right? Let's
19:16keep with a conbon ticket example. Now,
19:18anyone can file a ticket. This is a
19:20feature. This is a bug. This is a chore.
19:22Advanced teams are going to skip wasting
19:24engineering time transferring your
19:26conbon ticket into a low-level or
19:28mid-level engineering breakdown of what
19:31needs to happen. Advanced teams are
19:32going to go right to kicking off a
19:33software factory. The moment your conbon
19:35ticket lands, once the factory starts,
19:37it's going to mark that ticket in
19:39progress and move it. And now we have a
19:41factory router agent. This could just be
19:43a simple LLM call. This could be some
19:46deterministic code. The exact nodes are
19:48up to you to decide, but you get the
19:50idea here. I'm going to throw a factory
19:52agent here to intake the results. Do a
19:55quick look at the codebase, understand
19:56what AI developer workflow we need to
19:59execute for the system. First though,
20:01we're going to set up a sandbox. We're
20:03not limiting our agents anymore. We know
20:05that agents are going to continue to
20:07expand. This is what the CPU crunch is
20:09all about. CPUs are getting wiped off
20:11the board outside of scaling RL and
20:14other ML engineering related work. Agent
20:16sandboxes are going to, I can guarantee
20:17you this, be the majority of computers
20:20out there in the world. You and I will
20:21be using fewer and fewer devices while
20:23our agents continue to scale up and use
20:25more sandboxes. Okay, but set up the
20:26sandbox. After that, our agent has
20:28already decided what type of workflow we
20:31need to get the job done at the best
20:33price, at the best performance, and at
20:35the right speed. Because as you likely
20:37know, you're not going to run your hot
20:39fix AI developer workflow or your
20:41feature AI developer workflow where
20:43you're scaling out your very best
20:44agents. Maybe your build agent is a
20:46workhorse model, but your planner and
20:48your scouters are going to be
20:49state-of-the-art model so nothing gets
20:51missed. Of course, there's a whole slew
20:53of multi- aent orchestration work that
20:55can happen here. But the whole point is
20:56you're not going to deploy your heavy AI
20:58developer workflows for a chore, right?
21:00for your chore. Throw a single agent at
21:02this with a workhorse model, maybe even
21:04a lightweight model. Build it, run the
21:06lint, run the CI/CD, engineer reviews
21:08it, and ship it out. We'll talk about
21:10ZTE in a second, but the best teams are
21:12going to start dropping off engineering
21:14review because they've built the best
21:17system possible that they know is going
21:18to execute for them. But every single
21:21unique workflow is unique for a reason,
21:24right? There are multiple workflows you
21:25want to build out here, multiple AI
21:27developer workflows you should be
21:28building out, not just one. I'll give my
21:30recommendation some really, really great
21:32practices you can use when building
21:34these out in a moment here. But the
21:36general rule of thumb is just to start
21:37simple. Once you start scaling this up,
21:39what you're going to end up with is a
21:41software factory. A software factory
21:44that can operate your application as
21:46well. And if you're doing it right,
21:48better than you and your engineering
21:50team. This is why all your effort, all
21:52of your effort goes into this. Now, the
21:54agentic layer, right? This is the al the
21:57agentic layer, not the app layer. The
22:00app layer is for your agents. The the
22:03best engineering teams never touch the
22:06product themselves. Okay, I know this
22:08might be like controversial. Some
22:09engineers are going to hate hearing
22:10this, but the best teams are doing meta
22:13work on the agentic layer. They're
22:16building the system that builds the
22:18system. That is the central thesis
22:20inside of tactical agentic coding.
22:22Thousands of engineers know that and
22:24you're going to figure it out too sooner
22:26or later. Okay, that doesn't mean you
22:27can't jump into the app to do work. But
22:29when you have a successful product
22:31scaled with users, the name of the game
22:34is this. Building a software factory
22:37that operates everything better than you
22:40alone could, better than code alone
22:42could, and better than agents alone
22:44could. Right? Three actors of value
22:46creation, agents, engineers, code. Where
22:49does that all lead us? It leads us to
22:50the simple conclusion that it's not a
22:52loop you're after. It's an AI developer
22:54workflow. Okay, you might be, you know,
22:56listening to this and thinking, but you
22:58you drew a million loops. Like, isn't
23:00this a loop? Fine. If you want to call
23:02it a loop, I don't really care. I think
23:04a loop is too constrained. If you're
23:06going to call it a loop, we're going to
23:07need if engineer, we're going to need
23:09throw engineering. We're going to need
23:10exception engineering, right? We're
23:11going to need to name all these things
23:12engineering. This is a developer
23:14workflow. This used to be what engineers
23:16did. Engineers used to decide if
23:18something was a chore, if something was
23:20a bug. We used to write the plan, we
23:22used to execute it, so on and so forth.
23:24But now we have a new tool and that's
23:26all it is. It's a new tool. We have
23:28agents to work with that gives us AI
23:32developer workflows. Okay. So at the
23:34highest levels of agentic engineering,
23:36you're building software factories that
23:39execute the right work and the right
23:41combination of engineers, agents, and
23:43code across your organization. Once you
23:45really start to scale it up, you're
23:46going to add your other teammates,
23:49right? Your other team members from
23:50other cross cutting concerns inside of
23:52your business. But at the core of it,
23:54the engineers are responsible for the
23:56code. Okay? I think a lot of orgs are
23:58going to have a a problem with this once
24:00they start scaling in and adding other
24:02team members, right? Especially ones
24:04that can't write clear tickets for the
24:06life of them. You've seen this a million
24:08times, right? It's the most painful
24:09thing when your product manager, your
24:11your CTO, your your tech lead [laughter]
24:14just writes a ticket and you have
24:16to translate it, right? So there's
24:17there's a lot of like, you know, people
24:19organizational level work to be done
24:21here. But you at the end of the day, you
24:23know, you the engineer plus the agents
24:25plus the code making up the AI developer
24:27workflow. This is what it's all about.
24:29This is where value is going to be
24:31created at absurd levels, at absurd
24:35scales. Because once you get this right,
24:37here's the dirty secret of all software,
24:40right? You already know it. Once you get
24:41this right, you set up the right
24:43guardrails, the right harness, right?
24:44Again, prompt, context, harness
24:46engineering, all of it. Once you do this
24:48right, you have a repeatable workflow
24:51that you can run tens, hundreds, and
24:53thousands of times, delivering
24:54consistent results to you over and over
24:57and over again if you template your
25:00engineering into the fabric of your AI
25:03developer workflows. Okay? And so I've
25:05been pushing against out of the box
25:06agents for a long time. Um, you know,
25:08specialization is the name of the game.
25:11What is a product? What is a company?
25:12Right? Unless you're a big tech giant,
25:14like a product in a company is a a set
25:18of people in technology that solve a
25:20specific problem for a specific avatar
25:22for a specific user for a specific
25:24customer. By very definition is
25:26specialization, right? Your expertise is
25:30the most valuable thing you have now.
25:32And you can template that into your
25:33engineering. You can template that into
25:36your AI developer workflows. All right,
25:38this is the greatest leverage point of
25:40agentic coding. It's building out these
25:43full AI developer workflows that puts it
25:45all together. Okay, and so you know once
25:48again we are pushing away from vibe
25:51coding. This is not vibe coding. Vibe
25:53coding is not knowing how the system
25:54works and it's not looking at how the
25:56system works. Okay, agentic engineering
25:58is knowing your system works so well you
26:01don't have to look. And that is because
26:03you the engineer have moved up a layer.
26:06You're meta-engineering. You're
26:07compounding an advantage by optimizing
26:10the three actors of agentic engineering
26:13engineer code agents into the right
26:16developer workflow at the right time at
26:18the right performance at the right price
26:19with the right speed. And after time
26:22you'll realize something really
26:23important is that you'll be building AI
26:26developer workflows into your products
26:28for your customers right with your
26:30customers as nodes and then as mentioned
26:33with your companies every user that can
26:35prompt into the system and receive
26:36results out the system right you have to
26:38design this system it's just another
26:40system
26:45so I've written hundreds and probably
26:47thousands of these AI developer
26:49workflows by now. So, let me give you
26:50the oil of everything I've learned so
26:52far with what I've seen and what I've
26:54recommended to engineers as they're
26:56building out their ADWs. Um, first off,
26:58keep it simple. When you start building
27:00these out, start with the simplest
27:02workflow you can think of, right? And
27:04typically that looks something like
27:05this, right? After you get an agent
27:07running, you prompt back and forth and
27:08you're babysitting your agent. Everyone
27:10knows what this looks like. Just let it
27:12lent your code. You know, to be clear,
27:13so that you can really feel this.
27:15Separate this out. I'm not saying write
27:17a skill, have your agent build, and then
27:19at the bottom of the skill, run lint.
27:22Separate this out. Use an agent SDK, run
27:24a build agent, do work, and then run a
27:27llinter. And when the llinter fails,
27:29pass that back into the build agent with
27:30the same session ID. You have to
27:32separate your code and your agents.
27:34Otherwise, you just have an agent
27:36calling code. That's not what we want.
27:38We want separation of concerns all the
27:40way through. If that doesn't make sense
27:42to you right now, don't worry. It'll
27:43make sense once you start building it.
27:45This is not a big skill where you run a
27:48hundred different nodes of workflows.
27:49There are massive testing, massive
27:52validation problems with doing that. And
27:54then what do you do after that? You add
27:56a couple nodes, right? Start solving
27:58real problems. Run your type checker,
28:00run your llinter. If things go wrong,
28:02funnel it back into your build agent.
28:04What you'll notice here is that you're
28:05starting to build a larger unit, a
28:08larger system that operates without you.
28:10You show the beginning and the end. the
28:13two constraints of agent coding,
28:14planning and reviewing, and your system
28:16does everything else. Okay? And then
28:18once you get to a certain point, you'll
28:19start separating out your agents. You'll
28:21start specializing your agents. Maybe
28:23you want to separate your front end and
28:25your back end. Maybe you want building
28:26and testing. Again, the key here is just
28:29that you separate the context out so
28:31that your context can move between
28:33individual agents and code. When you're
28:36starting, remember KISS, keep it simple,
28:38stupid. You can absolutely start with
28:40pure skill-based workflows where it's
28:43all one skill outside of the prompt and
28:45the review. But as soon as you start
28:47productionizing, as soon as you run to
28:48get serious about your AWS, you must
28:50separate code out of the skills because
28:53that's still your agent running it,
28:54right? You have to be super super clear
28:56about those steps so that you can set up
28:58the proper guard rails and information
29:00flows in your AI developer workflows. My
29:03next really big piece of advice here is
29:04design your ADWs by doing the work
29:07yourself first. For a lot of engineers,
29:09this will sound insanely painful, but
29:11you can like, you know, use your agent
29:13in the terminal. Run the build workflow.
29:16Do the testing, right? You can still use
29:17your agent for that. I'm not saying do
29:18it by hand. That would be a waste of
29:20time now. But what I am saying is
29:21whatever workflow you're setting up, run
29:23it end to end. Step into each node
29:26yourself. run the pass, run the
29:28condition, watch the functions get
29:30executed, do the review, and then do the
29:32ship to production and then start
29:34writing this all as a combination of
29:37agents, engineers, and code. And I
29:39recommend you take something like
29:40mermaid. And you know, by the way, this
29:42is like a adaptation of mermaid diagram.
29:45I had an agent create using a plan build
29:47test AI developer workflow in one shot.
29:50I created a animated application which
29:52is of course based on a mermaid diagram.
29:55Okay, so shout out to mermaid. Shout out
29:56to mermaid.live. But that's my second
29:58piece of advice, right? Walk through it
30:00all yourself first. Sit down pencil and
30:02a piece of paper or use mermaid or use
30:04whatever. Really sit down and like write
30:07out your workflow. And then lastly, make
30:09sure you're not just using agents,
30:11right? Use agents and code. As I
30:13mentioned, you can always start with
30:15agents and skills, but as soon as you
30:18start hitting production, as soon as you
30:19want to get serious, move some of that
30:21skill work into code. This is not just
30:23about token cost. This is about
30:24performance, reliability, and speed.
30:26Again, everyone in their AI psychosis
30:28has like forgotten that speed costs zero
30:31tokens. There's no hallucination. It
30:34does the exact same thing every time.
30:36And it literally runs at the speed of
30:38light. So, don't overleverage on agents.
30:41Okay? Balance it out with actual code,
30:44right? Code execution. And yes, there's
30:46information orchestration. There is this
30:47is what context engineering is. You're
30:50going to need a place for all the
30:52results in between each step. Yes, it's
30:55going to take some time. Yes, it's going
30:56to be a little knowing. Yes, during the
30:57process, you'll wonder, I should just
30:59throw this all in the skill. You'll be
31:00wrong down the road. I can guarantee you
31:02that. I've been there. Don't waste your
31:04time doing other engineers have
31:05already done wrong. Separate it out as
31:07you scale this. Okay, so that's the big
31:09third tip. Use agents and code. Okay,
31:12because agents plus code beats either
31:15alone, especially when you start really
31:17scaling these into legitimately large AI
31:20developer workflows that do serious work
31:23for you and your organization. Why?
31:25Because you're going to need to test
31:26this node. You're going to need to test
31:28plan into build. You're going to need to
31:30test plan into build and to update the
31:32status and to testing and to fail. This
31:34is all still a system you the engineer
31:36are responsible for. So keep using great
31:39classic engineering patterns,
31:41isolatable, decoupled, single interface,
31:44right? All that stuff matters probably
31:47even more, right? It matters even more
31:49now because once you do it right and you
31:51set up your AI developer workflow, it
31:52gets multiplied hundreds and thousands
31:54of times and your agents plus your code
31:57can drive the outcomes for you. Okay?
31:59So, you know, let's step away from the
32:00vibes a little bit and let's step out
32:02away from the AI psychosis a little bit
32:04because if we're going to do serious
32:05agentic engineering, you need to know
32:08what's going to happen in your system.
32:10So, if you made it to the end here, I
32:11want to just say thank you for trusting
32:13me. For everyone that's been with the
32:14channel for a while, for years now, you
32:16know, big shout out to you. I appreciate
32:18you trusting me and following along this
32:19massive journey of Agentic Engineering
32:21that we're on. Um, if you want more, I
32:23recommend you check out
32:24agenticengineer.com, specifically
32:27tactical agentic coding. As I mentioned,
32:30I've been pretty early to a lot of these
32:32ideas. In tactical agent coding, you're
32:34going to hear a lot of what I just said
32:36really broken down step by step across
32:38eight lessons and then six additional
32:41upgradable lessons if you're interested.
32:44Okay, so the big idea here is AI
32:45developer workflows. It's building
32:47systems that build systems. We're not
32:49touching the application layer anymore.
32:51We're touching the agentic system, the
32:53agentic layer that builds it on our
32:56behalf. Okay? So, if you want to pay to
32:57play, you want to get a big advantage
32:59that again thousands of engineers that
33:01you know of and have heard of at
33:03companies you know the names of, they
33:05are in here and they have gotten the
33:07advantage and they are getting the
33:08advantage, right? It's tactical agent
33:10coding is the first eight lessons you
33:11can upgrade to agentic horizon to get
33:13some upgradeable ideas. really big idea
33:15there is of course multi- aent
33:16orchestration but agent experts is
33:19turning out to be a massively banger
33:21idea a massively important idea for
33:23engineering in the age of agents if you
33:25want to build true specialists that
33:27outperform out of the box agent anyway
33:29lots more in there's a very clear 30-day
33:32refund before you start lesson 4. So if
33:34you don't like my style or you're not
33:36getting the core of it it's fine I don't
33:38want you in here if you don't want to be
33:3930-day refund before you start lesson 4.
33:41This is going to be linked in the
33:42description for you. Also, I recommend
33:44if you vibe with the ideas here, if you
33:46understand the ideas and you don't want
33:48to jump in the tactical agent coding
33:49right away, check out this blog. I'll
33:51link in the description as well,
33:53thinking in threads. It covers a lot of
33:55the same ideas we've been discussing 99%
33:58of everything I do here on this channel.
33:59It's all free. It's out there for you to
34:01understand and master agentic
34:04engineering. If you made it to the end,
34:05do me a favor, like this video, leave a
34:07comment, and share it with your coworker
34:09before your competition sends it to
34:11theirs. You know where to find me every
34:13single Monday. Stay focused and keep
34:16building.

About this transcript

This page contains the full transcript of FORGET Loop Engineering. Agentic Engineering is about THIS by IndyDevDan, generated from the public captions YouTube serves with the video. The transcript has 6,447 words across 948 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 choose a caption track available on the video.

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, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.