Loop Engineering in 9 Minutes

I saw a couple posts that went viral of the creator of Claude Code and he mentioned I don't prompt Claude anymore.

What I mostly now use are loops. I

create loops, they do the rest of my job. And it's a really interesting

job. And it's a really interesting concept. I think for a lot of people

concept. I think for a lot of people that are potentially new to this type of thing, it might seem a little bit out there, especially if you have the type of role where it might be a little bit more hands-on. But the interesting thing

more hands-on. But the interesting thing with loops and what I'm going to be showing you in this video is you can use them in a number of different ways.

There's really a spectrum in terms of how you can use them. I only touch on some ways in terms of how I personally use them. Now, an interesting post that

use them. Now, an interesting post that just came out with the release of Fable 5 that came out yesterday was from Lance Martin. He wrote a really great ex post

Martin. He wrote a really great ex post which I'll link within the description of the video. And basically, the idea around loops is there's different levels of complexity with how you can actually approach this. There are some projects

approach this. There are some projects like auto research from Andrej Karpathy for instance, where what it does is it will train a model by performing different experiments at a set intervals. It will look and see what is

intervals. It will look and see what is actually working, what isn't, and for the things that work, it will progress it along its way. And this type of idea can really be applied in a ton of different ways. He mentioned within the

different ways. He mentioned within the post parameter golf is an interesting way to actually go about this. Another

way that you can actually think about this is even broader on tasks that aren't just even programming related.

One you can use both across Codex as well as Claude Code is the concept of a goal. Now, a goal is essentially a

goal. Now, a goal is essentially a long-running task. It is a very similar

long-running task. It is a very similar to something like Rob Wigham's, where instead of actually having to prompt the model again and again to go and continually work on a problem, this will

automatically have the mechanisms built into the harness where it will carry on its merry way until it actually gets to the goal. What you can do with this, and

the goal. What you can do with this, and this is probably one of the easiest developer experience or just user experiences in terms of how you can set this up, is within Claude Code or Codex you can simply run goal and then you can

describe what you want to do. Now,

additionally what you can do is within Claude code specifically is they do also have a loop feature. For instance, what I can do within here is if I {slash} loop, you're going to be able to put in your interval in natural language. You

could do it just like this. Loop every 5 minutes, and then you can describe the outcome of what you want to do. Now, the

one thing that I particularly like about loop is often times, if you're doing really exploratory work or if you're just experimenting with different things, maybe it's a green field

project, really want to leverage all of the capabilities that's built into the model and what it's actually able to do is often times what I like to do is a run a loop with a particular broad

open-ended question. And the way that

open-ended question. And the way that you can think about this is almost think about it handing it off to a really ambitious junior engineer. It might go off in a direction that doesn't necessarily make sense, but often times

it might not necessarily even make sense to you that it isn't a good approach to try until you actually see the results back. And as things get progressively

back. And as things get progressively cheaper with being able to try out different new ideas, and code just generally is becoming cheap, you can do much more ambitious things. The thing

that I like with loop is I can say something like, "Okay, every 5 minutes, let's go and let's explore these types of things that I'm trying to do within this project." And what it will do is it

this project." And what it will do is it will set up a cron job where within this session, it will run for the duration of however long you specify. So, I could say, "Loop for 5 minutes for the next 3

hours to help me explore this part of my project." And you will know there's that

project." And you will know there's that deterministic aspect where it will trigger the cron job where it will actually make sure to have that event fire within the context of the thread of

the LLM. It's very similar to goal. I

the LLM. It's very similar to goal. I

probably use this one a little bit less than goal cuz I find goal is actually very reliable. I've had goals that have

very reliable. I've had goals that have run for multiple days for particular things that I've wanted to set up. So,

for instance, I've wanted to set up parsers for very complicated sets of documents across a number of different websites. And when I have just been

websites. And when I have just been experimenting with this goal feature to see how far I can actually push it, you can actually have these run for literally days if you have a task that is bounded. And one of the things that

is bounded. And one of the things that is really helpful for these types of task is if it actually has something to verify its work. For instance, if you're trying to map something that's particularly big that actually has a

verifiable aspects about it where you can run unit tests or whatever on it, those can be particularly good task for how you actually verify this.

Increasingly, how I've actually been preferring to set up more long-running automations that are very, very helpful to my day-to-day work is within environments like CodeX, Cloud Code, as

well as Cursor. There's a ton of other IDEs as well that have a similar feature. And they all more or less take

feature. And they all more or less take the same shape. Essentially, there's

going to be an automations tab or a similar name for it within all of them in the top left-hand corner typically.

And then you're going to have a layout something like this. So, you're going to have the current automations that you have, and then you're going to have the paused automations. Now, these sort of

paused automations. Now, these sort of came and went as a little bit of an announcement. And then I actually didn't

announcement. And then I actually didn't see a lot of people focus on these, myself included. I didn't actually

myself included. I didn't actually leverage these a whole lot initially when they came out. I didn't actually think about how I could consistently leverage these things in my day-to-day.

As I started to have one that does something useful every single day, I've started to think of others that actually just push along a lot of minutia that I would have otherwise had to deal with.

Now, with my YouTube channel, I get a ton of emails. And I don't really have a whole lot of time to manage different requests or just people reaching out with different questions for various things. So, what I have is I have a

things. So, what I have is I have a automation where essentially what it does is I say, "Look through my inbox and go and put everything within my inbox on a linear board that I have."

And what it will do is every day it will check the inbox, it will check the linear board, and it will essentially see what are the highest priority things that I need to action. Now, how this can

also be used, and this is a relatively simple one, but you can also have this be updated in a way where you can leverage the internal files that you have within Codex or Claude Code, where

you can say at this interval, create an agent.md for this project or create

agent.md for this project or create relevant skills on all of the things that I might have done over the course of the week. Now, in terms of some other ways that you can actually leverage this is if you have a project, you can have

it scan for security vulnerabilities and those types of things at a particular cadence. You know, another way that you

cadence. You know, another way that you can leverage this is as a form of memory. Now, there's been a few posts

memory. Now, there's been a few posts that I've seen around where people have discussed an interesting idea where you have your LLM or your agent actually go through and essentially dream about all of the different things that had

occurred over the past day. And in a similar way for how we store memory is what we can do is we can have these systems create a synthetic representation in smaller, more coherent and accessible and progressively

disclosed ways to the model.

Essentially, a way that models can actually programmatically load up into their context window and know where to look when about particular things. And

this is the idea around continual learning, which I think we're only really going to be hearing more and more about over the coming months. It's

really an area of focus for a lot of people, a lot of researchers cuz what you can do with continual learning is essentially, once you have a system that can learn and doesn't just need to be

stuck with the pre-training of the model and the harness and it can actually take and explore different tasks within the world and ultimately build on those different things over time. That is a system that can progressively get

smarter over time and be more useful across a ton of different domains. So,

there's a ton of different ways in terms of how you can leverage loops. It can go from tasks just helping you push along within a slash loop. It can be a goal that can run over days and days across

different harnesses or it can also just be for tasks and things that you do repetitively every day, every 6 hours, once a week. All of those different things, if you think about it, of all of the different tasks that you might do,

if If something that you are repeatedly doing and it is on a computer, there is a pretty good chance that you're going to be able to offload a lot of these tasks to these types of automations. And

the one thing that I do want to mention with these types of automations is you don't need to have it go end to end. You

can still be in the loop. So, for

instance, when I have it draft my emails, I don't personally have it send emails. And oftentimes it doesn't

emails. And oftentimes it doesn't actually get all of the context right in terms of what I should do. I just use it as a helpful assistant, but over time you can actually have it improve those prompts in of itself for how you're

actually leveraging these things. It's

definitely a really interesting topic of discussion about how you can leverage these loops. But otherwise, I'm curious

these loops. But otherwise, I'm curious your thoughts. Are you spending your

your thoughts. Are you spending your time like Boris journey? Are you moving away from prompting? Are you starting to think more about building loops rather than actually prompting systems? Leave

them within the comments below. Are you

leveraging loops more? Are you actually spending less time prompting the system and now actually scaffolding out more automations and thinking things at a much higher level in terms of all these

different loops that your systems and agents manage. Let me know how you're

agents manage. Let me know how you're leveraging things like loops or automations within the comments below.

But otherwise, if you found this video useful, please like, comment, share, and subscribe. Otherwise, until the next

subscribe. Otherwise, until the next one.