Transcription
So, there's been a lot of different AI tips, tricks, hacks, various things that have improved my AI workflow, but there's been one thing that has been the biggest step change, and that is AI swarms. I think it's made it to where I've had I've been able to move five times faster and produce things that are 10 times the quality. And all this with AI doing most of the planning, most of the scoping, most of the work. And now I'm going to share that with you. So, I'm going to walk you through the system, walk you through the methodology behind it, and then show you how you can set it up yourself. Let's get started.
So the idea behind this actually was from science fiction. When I was growing up, I would watch science fiction with scary AIs like maybe Howal from 2001 of Space Odyssey where these AI agents would just know everything and be all powerful and super amazing. And then that was one of the first things I learned when I was trying to optimize for AI is that AI very quickly deprecates as you're starting a new chat. It's a super genius for the first few messages and then it slowly gets worse and worse. And that's one of the things that we do in our our course on context engineering that we have on school. We really focus on making sure that people understand how to produce really great results by having new prompts constantly, new chats constantly, because that's the number one thing I see people getting wrong. They'll have this really long chat and they'll say, "Hey, this this chat knows so much about me. It has all this context. I just need to keep using it and not realizing that these AI agents get worse over time as you overfill their context."
So, with all that said, once I thought that through, it seems like the most powerful AI won't be some super AI. It'll actually be a swarm of tiny little AIs where each one is specifically focused on a very narrow problem and it does it amazingly well before its context window gets filled up at all. And so that's where AI agent swarms come in. So, first of all, there's some things you don't want to use swarms with. If you don't know what it is you want to build, don't use a swarm because it'll build, you know, it'll just very quickly build you the wrong thing you didn't know that you wanted.
So, the reason I'm bringing this up is because all these people on Twitter and YouTube are talking a lot about Ultra Plan, and I think ultra plan was a really cool idea, but it does seem like it's really for a specific use case, like if you're trying to like refactor a codebase. Um, maybe trying to if you want to draft a plan in the cloud and have it analyze your GitHub and then just a lot of people that I work with aren't GitHub experts. They they aren't yet using cloud in the cloud. So, to really get the benefit of ultra plan would be like several extra steps. And also, I don't even think it would give you what you need. I think it it's a little bit more designed for like a super developer versus like a super business user. But I do think Swarms serve the promise of like an ultimate plan mode. I love plan mode. I think it's great, but I think swarms forces the plan mode to be in a structure to where multiple AI agents can operate in the best and they can all still coordinate back together.
So, let me just give you a quick example. So, here I just have like a visual that I'm showing. And what I would maybe do is if I had a big project, say I want to release a new feature for my app, what I would do is I would first plan it all out and you know I prompt and say use the swarm. I also have these two systems. I have like a setup that explains exactly what a swarm is and all the systems for it. So like that's what I have. I have this in my school community if you want to use it or you can just watch this video and implement the same thing on your side. But if you want to you can just join our school community AI impact and then you can take my exact swarm system give it to your cloud code so you can use it yourself.
But the way the swarm system works is you would first have multiple waves. So instead of having like one AI agent chat that goes on and on and on and then eventually you finish with that one and you start another AI agent chat and it goes on and on and on, we instead would have like five AI agents happening at the same time. And the cool thing is this was a feature that was released like 3 months ago where one AI agent can actually have multiple agents under it that it can manage. That's super cool and it took me a little while to realize how to put that together, but the swarms I think is a key part of it. So here what we would have is maybe we would realize, hey, there's five different areas of this new feature that's going to be released that we need to plan. So in wave zero, all we would do is just plan. We'd build documentation and all that documentation is going to be referenced by future agents. And so we might have like three that are using sonnet that are like fast, you know, kind of interesting AI use cases, but then you'd have opus. If maybe there's like some really hard feature that needs to be perfectly architected and we haven't even thought it all the way through yet, you'd maybe use the harder deep reasoning AI model that's more expensive. And then maybe there's something that's like super easy and you're just like, "Hey, just like store all this documentation or like reorganize a file." And for that one, you could use the dumb AI, which is Haiku for Claude. And that's like super cheap. Um, and so for some use cases, that's the perfect one. And so that way all five of these can be happening at the same time. We could be prepping everything before the swarm even gets started.
And once they're all done, you then have a checkpoint swarm, a checkpoint AI that analyzes all five of the mini agents. It reviews their work. It reviews all their notes. And then it basically says, "Hey, did they do a good job? Is there any other follow-ups? What else should we do?" And then it starts planning, okay, what what's the wave of the next AI agents that we should do? And so then it'll plan five AI agents that it that will run. And this is when they'll start building things. So for this wave one, you would then have five agents that all start building separate pieces. Maybe this one plans the user interface. Maybe this one plans the API connections. Uh maybe this one plans the database structure. Maybe this one plans any automations. And this one plans the training for the program, right? And then at that point they all run. Maybe that takes like an hour. Um but then at the end of that you have a checkpoint where the agents can then review and make sure everything works. I also like to ask my checkpoint agents to do like quality control review. Sometimes that takes an extra hour for the checkpoint. Uh maybe I'll even do a whole wave or a mini swarm just for the quality control. But I found that that works really well because it'll capture issues right as they're happening and then fix them.
And then finally, you might have like a finisher wave that takes all the foundation built by the first wave, the heavy lifting that's done, and then it comes through and finishes up a few other things and just puts maybe like a shiny user interface to make it really pretty to work with or add some cool additional features or add some documentation. So, this is a system that is really cool because before this would have taken me like three or four days of like chatting with AI. But now I can chatting with each of these AI agents to get all this done. But now I can just chat with my swarm commander is what I call him that plans all this out and then has it all launched and it can sit there and make the whole plans.
So, all right. So, this is like the overview of what it looks like. If you wanted to, you could do this as a human. You could like plan out here's all the agents that we need. You can then sequence them and say, "Okay, which agents could be done in this time? Which ones happen here?" You could then write really clear instructions like prompts basically for each one of those agents and you could also create shared documentation to say, hey, once you finish this, go update the master doc and go update the main architecture document. So you could do this as a human, but I like having my swarm commander that plans out the swarm and does all this for me. So it'll I'll chat with it and then it'll do these four steps to plan out the swarm.
But here's the key innovation with swarms. People are so used to just having one chat with all of your context, all of your knowledge, everything that is accumulated as you as you continue with that chat and discuss everything with the AI. But what you need to swap to is having your context live in files that are well structured that future AI agents can reference. So instead of that being just in like the local AI agent memory that's going to be forgotten or overstepped with context eventually, you want to have it all moved to really good documentation that's well structured with great indexes so future AI agents can all understand that same context and build upon it. So you can see here like I might have had a big swarm and every single orchestrator agent is updating the brief. Um, agent one updates the brief, but it also goes through and updates its own findings in wave zero research agent. Agent two is maybe focused on architecture. So, it'll also update the brief, but it'll also update the waves. It has its own file that it updates. And you have the checkpoint file and then you review everything if you want. You the human can come in and take a look. And then you move on. So, each agent has its own file that it's updating and then also updates the overall brief as it completes things.
And here's what you'd see. like one context window would just get to where it's so full and AI gets really dumb once the context is full. But when AI is less than 70% context, then it's in a really good spot and that's when AI is like super genius. So if you're filling up with one chat, yeah, that's easy. Yeah, that's convenient, but there's just no way you're going to get as much productivity as you would with a swarm. And then what I do is in markdown, I just have a folder where I'm storing all this. So I store the brief, I store a summary, I store all the agents, like what their prompts were, and then I store their output. So what happened with wave zero was continuing? What happened with each of the checkpoints? And it's so much better to be on the swarm system where there's fresh contacts for each agent and quality is really like continues at scale instead of quality dropping as the as the session gets bigger and bigger. So now with a swarm system, you can get things done much faster, but you can also get done much bigger projects because you know that you're dealing with fresh context at every step with a perfect AI agent designed for every step instead of having just one super genius AI agent that's a genius for 20 minutes and then becomes really degraded after like an hour of work.
So yeah, so just to show you an example, this is an actual swarm that built 105 documentation files. And so it was a documentation one, so a little bit different than others. All I was wanting it to do is update build a giant um documentation that's like more AI first designed. So what it did is it first wrote a brief and I have like my swarm brief. This is what all the other agents will reference. And so it wrote out here's the goal, here's the context, here's the constraints, here's what success criteria looks like and here's all the relevant files. The reason for this is that every AI agent in this form is going to then reference this. So, this will make sure that there's no mistakes where it's like not understanding something important or it builds something you didn't want because you don't want to play the game of telephone where each AI agent over time once you're on your 30th AI agent doesn't even understand the original goal and it goes off and builds something that it's excited about but it's not what you wanted. So, this swarm briefing kind of maintains that northstar vision that all of them can reference.
And then you have the orchestrator that'll plan the swarm. It'll actually define and say here's what all the agents that are needed are. Here's what each one should do. And then it also gives like a starter prompt for each one with some different with relevant documentation that it can point to if there is any. And then you can start executing and you can have those checkpoints in between where you can say like hey so here you can see I had like one that was exploring the structure of the codebase, one that was exploring the schema, one that was exploring the API, the user interface and the library. So instead of one AI agent doing all five of these, I had five super fresh, super genius AI agents just at this one task. And then we had a checkpoint where all of this was reviewed and we said, "Hey, how does the quality look for each of these?" And it reviewed and it even saw like, "Okay, some of these maybe they're like four out of five." And then we could either go back and redo it again until they're all five out of five. Or we can say, "Okay, four out of five is good enough for this. Let's move on."
So then we had another wave that actually started writing a knowledge base. And so one of them wrote for agent loop, for prompt assembly, for O for OOTH. And then another one wrote for tools, workflow, SSC, billing, governance. Another one wrote for briefing, like all these different things that are part of my knowledgebased system. um it went ahead and wrote um different agents for each of those. And then we had another checkpoint where basically all the agents would report back on what happened and the checkpoint agent would review and make sure that they all did proper work and that we're happy, we're ready to move forward. And then the same thing, but we had another wave that focused on a different things that required the first wave to be complete. And then we had a third wave that was basically the same system, but just it couldn't be built until wave 1 and wave two were done. So we just had all these agents and their task saved for the end.
And then at the very end, we have a swarm summary. And so what this does is it goes through and it reviews the original plan. It reviews what all the different agents did, like a summarized view of them. And then it discusses any architecture decisions. It gives an agent performance. It gives any key learnings that we can have for the future. It gives any follow-ups that maybe the swarm wasn't able to complete. Maybe there's a future swarm we need to plan. Um, and then it gives a retrospective for what is it that went well or what didn't. Um, and so then at the end you have great documentation because let's just say you realize something went wrong. You could even go back and look in your swarm documentation to see where was it that something went wrong and why and then either try to fix that now or fix it in the future. But it's really cool for that kind of purpose. So yeah.
So, if you want you can watch this YouTube video and basically explain the swarm system. Explain that you want to have a multi- aent system that handles things in parallel when possible or sequential when necessary. Basically that's how I started with mine and then I slowly built up my swarm system more and more. Or if you'd like, you can join our AI impact school and instantly we have a comment just three days ago where I shared my swarm system and you can just use that right away. So it's up to you. But I definitely think that if you're using Claude Code, this is the number one thing that I've seen. There's nude hacks, new trends every few days. A lot of those are helpful. A lot of them are not just hype, but this is the one thing that I would say has maybe 10xed or 100xed my productivity in some cases. So I'm excited to share it with you. And if you're interested in more things like this, I'm happy to share. So feel free to subscribe to the YouTube channel or or join the school community and we'll see you in our next video. I'm now planning one where I show my knowledgebased system. Knowledge bases are getting more and more important for AI. It's something I've been working with working on for 10 years. So I'm also going to share my system called building an infinite brain instead of building a second brain which is what a lot of other people are doing. So definitely subscribe so you can check that out too if you like this video. All right.