Nobody Writes Prompts Anymore (Do THIS Instead)

So today I want to talk you through agent loops, how to use them, how I'm currently using them, the systems you can set up, and why you shouldn't be prompting and instead using loops and designing loops that prompt your agents for you. And this is a tweet earlier this month from Peter Steinberger, the founder of OpenClaw. Loop engineering is pretty much everywhere that I look right now. So I want to guide you through how I'm using it, the systems I've set up, and also why you don't need to write the prompt anymore.

Instead, you write the loop. So how does this work? What's the idea? Well, you stop prompting, you start looping.

So the biggest names in AI, and Jensen Huang was talking about this, where you can see this tweet from Anatoly, where he says basically nobody writes prompts anymore. The new job is to write and handle loops. And this is going to be a big thing this year. I think a lot of the systems that we see in the future, they're going to be self-iterating loops.

Because the difference is like, for example, if you're going into Claude and you're prompting it back and forth, you are the bottleneck. You are the constraint. You're the one who has to give all the feedback. You're the one who has to direct the agents.

But who knows how to communicate with agents the best? Agents themselves. So what you want to do is have your agents looping round, self-iterating and improving. And the way this works is that the future isn't a clever prompt.

It's a better loop. So you define what done looks like. An agent acts. An independent judge can check it.

It repeats until it passes whilst you go and do something else. And this is why looping beats prompting and the four loop systems we've built into the agent operating system. And if you look at this system, your agents act, they observe. If it's good enough, great, we ship it.

If not, it goes back. You reason versus a goal. And that repeats and goes again. Now we've seen these updates recently with, for example, like Hermes and Codex where you have this forward slash goal set up and that's similar.

And the way this works really is like you don't prompt. Instead, what you do is you engineer the loop. You build that together. And the smartest people in AI right now have stopped prompting.

Addy Osmani from Google, Google engineer, published an essay as well that gave it a name, which is loop engineering and an anatomy. So his line says it plainer than I can pretty much. He says, you don't really need to be good at prompting anymore. The thing to get good at is the loop that does the prompting for you.

And this isn't like one corner of the internet. The man who built the coding agent everyone uses says the same, which is from Boris Cheney from Anthropic, creator of Claude Code. I don't prompt Claude anymore. I have loops that are running.

They're the ones that are prompting Claude and figuring out what to do. My job is to write the loops. And on the biggest stage in the industry, NVIDIA's GTC keynote, Jensen Huang declared the age of agents. He didn't describe a better prompt box.

He described a loop. So you can think of the model as a brain, the harness as a body, and the tools it uses working in a runtime. It understands the user's intent, observes context, reasons, plans, calls tools, and juggles working memory of long-term memory. And this isn't like theory.

You know, it's already how the best shop in the world ships code. So 80% of production code at Anthropic is now written by Claude, which only became possible once engineers stopped reviewing every single answer and started building loops that verify the work for them. So the way this works is you observe, you reason, you plan, you act, you verify, repeat. And that's not a prompt.

It's a loop running on its own. And that's the new default for doing this stuff. And the way you want to think about this is that one makes you the engine, the other makes you the architect. So here's the difference in plain terms.

With loop engineering, with prompting, well, if you were doing prompting, which is the old way, you are the loop because you type a prompt and wait, you read the answer, you spot what's wrong, you type again and again, nothing moves unless you're sitting there. One mistake, you start the thread over and your output is capped by your attention and your energy. With looping, the new way, you write the loop, it runs. So you define what done looks like.

An agent acts, builds, writes, and searches. An independent judge checks it against a goal. If it's not done, it loops around again on its own and it keeps going until the goal is truly met. And it can run whilst you sleep and you wake up to done.

So if you think about where your time goes, it's the same job getting done. But prompting needs you the whole time. A loop needs you for about a minute. So with prompting, you're like just babysitting the thread.

It's you hands on the entire time. And that takes all of your time and attention. With looping, you set it up once, it takes about a minute, then you're free whilst it runs and it checks itself. See, stop being the bottleneck.

You define the goal once and the loop carries on. Now, the catch here is what most people miss, which is a loop only works if something other than the agent decides when it's done. The agent that wrote the code can't be the one that grades it. You always say, looks good to me.

So if you're building an app, a game, a website, a tool, whatever you're building, even a blog post, every loop has two halves. Which is a doer and a judge. That's whole secret. And it's exactly what we've built four different ways into our agent operating system.

So every loop system shares the same skeleton. A doer acts, so an agent does the work and builds a page. A separate judge checks. So a separate model grades it against your goal.

It doesn't need to be smarter, just independent. Then it repeats. So if it fails to check, it goes again with what it just learned. If it passes, it ships with no human in the middle and you set the gates.

Your only job is up front, which is you define what done looks like. The loop holds a line to it. So let's talk about how we've built this into the agent operating system. And the first method is loop engineering with a fusion.

So the way the system works is it loops until the gate passes. How does this work in action? So what we've got here, for example, if we have a look at the loop section, is that we define what's done. So it's like, okay, build a beautifully optimized SEO blog.

You can give it a starting point or not. You have a builder and you select the API. You give it the number of rounds it can actually self-iterate for. So how many loops it can go around for.

And then you've got a judge, which can be a totally different model checking the work. So you could have, for example, a frontier model checking the work and give a direction. And then cheaper or free models actually doing the work itself. And this loops round over and over again.

Now, another system that you can use is you can have an agent Kanban board. So you can have a planner, a builder, and a reviewer who won't pass bad stuff. So how does that work in action? Well, what you can do here is you can plug in a task like so, and then that gets triaged.

And you have a judge profile. So for example, if you're creating content, it will be a quality checker for the content itself. That checks the work, gives a verdict, scores it, and tells you whether it passes or not. If it doesn't pass, then the task goes back in doing, and it just runs over and over again until the work is finally completed.

So if you look, for example, at this blog post or the video that we've created, this was fully done with AI agents. I just gave it the goal and then it went off round and round. We had a builder, an editor, a judge, and these are all separate profiles inside Hermes that can all grade and work together in a loop. Just going round and round until the job is completely done.

Now, another option for this is that you could have a fusion boardroom. So what this means essentially is that you can have five different models that come up with an answer, and then the judge actually fuses all the answers together. The idea being the multiple minds together are better than one. And again, it's just having that quality control check in place to make sure the work is good enough.

So you can see, for example, we built out this full world, and we did it using Fusion. And Fusion basically is an API where you can have multiple models working together on the same answer. And then what actually happens after that is a judge checks the work and makes sure it's actually good. Here's another example of what we built with this.

And so you can go into Fusion here, you can type what you want, you ask your boardroom, so it's a panel of agents working together. And then when you actually finally get the output, it usually works pretty nicely, simply because you've looked at all the answers, looked at the mistakes, critiqued it, and then put them together in a fusion to make sure they're actually good. And you can get the API from OpenRooter via Fusion for doing this. Now, Sakana Fugu is a new Japanese model that just dropped, and that's supposed to achieve like Fable 5 level intelligence.

Basically, what happens here is that you have a council across multiple different models, they deliberate in parallel, search the web, and then a judge weighs it all into one verdict. And that's actually cheaper than Fusion. And the point is collective intelligence, not one model's opinion, but the cross checked result of many. You can see some of the stuff we built with this as well, like it's pretty cool, pretty amazing.

Now, if you want to get this whole system, every loop system lives inside the agent operating system. We've built this together so that you don't need to wire like four separate tools together. You get the loop, the agent Kanban, Fusion, and Sakana Fugu all running inside the agent operating system, inside the AI Profit Boardroom. So you get one dashboard, shared memory, shared context.

You pick the loop that fits the job and you let it run. So all four loop systems pre-built are wired in, ready to run. You get shared memory as well. You get four coaching calls a week, a 30 day roadmap, and 3,700 members inside the AI Profit Boardroom building with this stuff.

Now you will see this hyped up a lot, and I don't think it's necessarily fancier. It's just like a way of having agents run without you. Everything improves together. It's all quality controlled by an independent model.

And then this actually scales because one loop or a hundred is the same effort from you and repetitive work stops being your problem. So the future isn't a better prompt. It's a better loop. Another example of this is that we have the memory system inside the agent OS.

And what you can see here is like, these are all memories I've never built or touched any of them. But what I actually do is every time I speak to my agents, they automatically log their outputs inside our Obsidian memory. And so we can click on any of these, and these are all different memories, as you can see right here. And so what this means is my agents work in a positive feedback loop because when they are generating outputs, they plug it into this Obsidian galaxy.

And then when they're coming up with answers, they pull from that Obsidian galaxy. And so it works in a positive feedback loop where every time we use our agents, our memory improves, the context improves, we get more notes and we get a better system that's beautifully organized. So that's how to stop being the loop and start writing them instead. And I think the people who win the next year won't be the ones with the cleverest prompts.

They'll be the one whose loops run whilst they're doing something else. So the agent operating system inside the AI Profit Boarding hands you all five loop systems, including the memory, wired in and ready. So you can start designing loops today instead of managing your prompts. And inside there, you get the full agent operating system, zip file of the loops, the Kanban, Fusion, Sakana, and the memory all in one dashboard.

You get the setup walkthrough done with you step by step, four weekly coaching calls, daily tutorials, and a 30 day roadmap plus 3,700 members. If you're thinking like this sounds like technical, I actually would say it's simpler because this stuff is running without you. So it requires less energy. And I've seen all sorts of people like build with this stuff within like 30 minutes.

You can see an example from Rick here. He set up the system within 30 minutes. Jose built it on day one, like loads of people getting awesome results with this. So if I'm non-technical and I can build it and all these people are non-technical and they're building with this stuff, then you can do it too.

Right. And I've seen literally we've got 186 pages of wins and reviews and testimonials from people winning with this stuff. So I know like together we can all learn and grow together with this process. So if you want to get all this, you can get it inside the AI Profit Boarding community, link in the description or go to the AI Profit Boarding.com.

Inside the community, you can ask questions, get help and support in real time. Inside the classroom, you get all of our best trainings, including new daily updates. So I've actually just added a new tutorial today on Sakana versus Fable versus Fusion. And inside the AgentOS section, you can get the latest version.

This was just updated today with a video tutorial. And also you can get the sit file right here. You get the coaching course inside the calendar. You can meet people in your local area.

And there's a lot of cool people sharing amazing stuff about loop engineering inside the community. So hope to see you inside there. Cheers for watching.