Transcription
I built a free AI coding platform that lets you create a 20-person dev team in under 60 seconds. Plus, you can switch devices mid-sentence, move and control everything from your phone when you go out. You never have to slow down. I've been coding for 30 years and all that work was building up towards this moment. By the end of this video, you'll be able to launch your own coding team working for you 24/7. Let's do it.
All right, so we're going to jump right into cluster mode and I'm going to demo the Popebot. This is an AI agent, a lot like OpenClaw, and I just developed this new clusters feature which allows you to create a cluster of AI agents. And just for some context, I have fully integrated the Pope with Cloud Code. And what I'm showing you here is the interactive mode. So I can type directly into Cloud Code from within the Pobot. And this just uses my Enthropic subscription.
Now I'm going to show you more about the interactive mode in just a bit, but first, I'm going to start with cluster mode. So I'm going to come over to clusters. And this is where you're going to be able to manage all of your clusters. You can create new ones. You can edit, delete. I'm going to jump into the Popebot. It takes you directly to the console. Now, this is where you're able to see all of the active containers that are running. So, if I were to start up a few agents right now, we're going to see those pop up right here on the screen. Just want to show you how that pops up. You can see what they're actually doing. You can see their tools that they're calling. You can see the prompt that initiated them, the user prompt.
And I will jump into the edit mode where you can actually define these different roles. So we have the CTO role, we have the security role, we have the UI/UX and developer role. Each one has its own system prompt and a user prompt. You can define how many can run at any given time. And you can also define the folders for that particular worker. And as well, you can define the folders for the cluster. So if you want, you can create a cluster of agents and they can talk to each other all through folders and MD files. That's probably the most simple way of doing it.
Now, because I have an active GitHub project, it's already got over a thousand stars. And because everybody is submitting enhancements and bugs, I might as well use GitHub as the mechanism for controlling how we get new tasks into the popot and into this specific cluster here that I've defined where we can run it through the CTO, the security expert, the user interface expert, and the developer. And so I've got these two issues here that are just test issues that will open up. One of them is simple. It's just going to update the event handler side menu. So, if I come over here, we're just going to swap these two here. And then I've got another one here, which is to allow multiple API keys in the settings and secrets. So, if I come back to the Pokebot here in the settings page, if we come to secrets right now, you can only set up one API key. So, if I were to delete this, it would disable anything that used this key. I'd like to be able to have multiple keys, and then if I disable one, it only disables the service that was using that specific key, and the other ones would continue to function.
Once I have decided I want to work on specific issues, all I need to do is come to the labels here and simply add the plan label. And that is going to trigger, if I jump back to cluster mode, back into the popot, that's going to trigger the CTO to now start to create a technical plan around that feature. And then when he's done, if it's needed, he'll send it to the security expert and the UI/UX designer. And then finally, once these two sign off, it'll go to the developer to actually be coded. And so we'll come over to this one as well and we'll hit plan and we'll be able to just watch this as I describe different things that are happening. So again, it's going to go CTO, then it's going to go to security or the UX, and then when they're done, it's going to go to the coder, and then the coder is going to push it back into GitHub.
Now the way that GitHub was able to trigger these processes is if I come back to these roles and we come down to like CTO, for instance, we have these different ways of triggering this CTO to start. So we've got the manual trigger. You saw me do that in the console. So now that we applied that, now we'll see that second CTO pop up. So jumping back into the configuration. So we've got the manual trigger, webhook. And so that's what GitHub used right here. It called this endpoint here to initiate the CTO to start. You can also trigger these agents by cron job or by file watch. So if you're using folders and they're trading files and updating files, you can use the file watch to monitor the files to trigger the agents.
So if we come back to the console here, we're going to see we have now two CTOs running, one on each feature, and one was more simple. So it looks like this one might be done. And again, you can see how everything was triggered. You can see the original system prompt and the user prompt. And once this finishes up, the CTO is going to comment back to the issue. This will be the first one that the CTO comments back on. There it is. It just popped in. So he came up with the technical plan. And because it interacts with the UI, you can see that he just tagged it with UI/UX. So now if we come back to the console, we're going to see that the UI/UX agent is now running and is going to evaluate that plan, that technical plan, and provide its own feedback. And again, you can monitor the performance of the console down here. Everything is totally tracked. You can even come and check out the logs. So, we've got the CTO and the developer logs all here.
And then once the UI/UX developer is done, he will add the label to, and I could do this manually myself. I could just hit code here, but the UI/UX agent will do that on its own. So, we can see that it figured everything out. It's just making a comment back to GitHub. So, let's just jump back there real quick. Now we have the code label and here was the technical plan from the CTO. Here's the UI/UX plan from the agent and now we can see the developer has started the work. Now over here we can see that the security expert is working on the API keys because that one involved security. So that automatically triggered that to work. And the UI/UX agent is finishing up its review of the keys here. Perfect. And the security expert looks like it's finishing up his job on the assessment of that issue. And now you can see that the agents are starting to finish up. And we'll go back to an empty console.
And so you can see if you're using GitHub, it's very easy to manage your entire project here, all of the to-dos, and then simply have the cluster of agents spin up working on as many tasks as you want all at the same time and doing the complete process and actually checking that code back into the system. So here we can see that we have the first feature that was finished by the first agent. Here we are. We can see what they did and we can see the files that they changed. Swapping those menu items. Pretty easy thing to do. But back here in the console, we're seeing the developer finishing up, actually about to submit the pull request right now. It's literally creating the pull request. You can always jump in and expand and see what the tool is actually doing. Put it review here. Finished up. If we come back to GitHub, pull requests, and here's the feature. All of the files changed, ready to roll.
All right, so now let me show you how to set up your own cluster from scratch. I'm going to jump back to clusters here. And when you're on the clusters page, you just go new cluster. And it starts off with the main definition of your cluster. And there's a main system prompt. And this system prompt is distributed to any worker that is ever created. And of course, you can rename it cluster demo. And here, I usually like to define something that's pretty global, like the mission and vision and the goals and the values of the cluster. I like to give it the current time in case it needs it. And we'll talk a little bit more about this as well, but there's a bunch of different variables and placeholders that you're allowed to dynamically place into the system prompt to give it information about the job that's running at that moment.
And then like I said before is that for every cluster you can define different folders that will be inside that cluster that will be available to all of the workers that are working within that cluster. So if you want to create an inbox for incoming tasks or different folders for sharing tasks or for discussions or to drop reports, you can put all of that here. So if I do inbox, outbox, and reports, it's going to create those folders and share those folders with all of the workers.
Now the way I manage workers is through roles. So, if I wanted to add a new role like I did in the example, like the CTO, I just click on new role and we can rename it CTO or whatever you'd like. And then we have a role system prompt. And here you can see we're using some of those variables now, some of those placeholders. And so when this agent runs, it will replace these placeholders with whatever it is. So self role name will be CTO and self worker ID will be the actual dynamic ID of this worker, so that it can find itself around. And then we're also inserting this workspace placeholder, which is actually the directory structure of the cluster. So you can see what we're doing here is we're giving the worker context about who it is, what specific ID it is, and also the directory structure.
And then you can define the specific prompt that it will execute as soon as it boots up. You can define how many are able to run at any given time. You can define whether it's supposed to clean up the directories that it created when it's done. You can define its own folders. So if I type test one, test two, test three, then we're also going to have these folders created for us during runtime. And then we can also define the different types of triggers like manual. So manual is triggered from the console itself like I did at the beginning of the video. If I just click this, it's going to run this CTO agent. And let's actually do that here. So we can see the prompt. We'll be able to see how it replaces these values in real time as it launches. So, we'll launch the CTO. Oh, actually have to just enable it. Turn it on first, otherwise it's not going to boot up.
Back to the console. See that CTO boot up now. And if I come over to the system prompt, notice here, your role CTO. See how it inserted those in real time. And then it inserts that entire directory structure, the cluster and the self, so that it has context of everything about the cluster and where it can put files. And obviously, that's also supported by the prompts that you give it as well.
And then we have the webhook trigger. This is what I was using inside of GitHub. I built a little integration inside GitHub that is calling these webhooks to trigger these agents to launch from outside of the popot. And then you can also set up a cron. So you can set up a schedule to run every minute or every hour or every day. And then there's a file watch. So this one's pretty cool. Here's where we define the different folders that we watch. And then if files change within these paths, it will automatically launch this particular agent. And then you can just create as many different roles as you want, each with different system prompts, different user prompts, different concurrencies, all different settings. So instead of having to define every single worker or agent, you actually just define the roles, how many can run at a given time, and then you can launch as many of them as you want.
And then of course, we also have the logs. I don't think we'll have much in there yet. So I'll just jump back to the popebot. We can filter it by the different roles. And then you can see everything that happened, how long it took, the entire log here, all the different tools that were used. You can open everything up. You can inspect it. You can see the exact trigger that triggered it, whether it's a webhook or a cron or a manual or a file watch. You can monitor the system prompt that was used to generate this output, and then also the very specific user prompt.
And so obviously in this situation, I had GitHub hit the webhook with the issue details in here and exactly what to do for each of the different agents. So the CTO was told to clone the repository, develop a technical plan for a specific issue, to make sure to download that issue and all the comments and to comment back with its plan. And then here you can see if the plan involves UI or front-end changes, add the GitHub label UI/UX. And if it involves security-sensitive changes, add the GitHub label security review. And that's what triggered the UX developer to run and the security expert to run. Here we can see what the security expert did. You can monitor everything. Again, the trigger that did it, the system prompt that was developed, and the user prompt.
Now, if you're enjoying this video, make sure to like and subscribe. I've got a bunch of crazy, insane stuff coming. You don't want to miss it.
All right, so now let me show you the Cloud Code headless and interactive feature that I've just built out. And this is just as cool, just in a different way. So I haven't explained everything that the Pope bot can do, but it is also an AI agent, just like OpenClaw. And from here we can send the agent messages and we can have it do things. In the last video, I created an AI content machine, but I've just introduced this new feature here which lets you go into code mode. So in the case where you want to be a little bit more hands-on, where you want to interact with cloud yourself instead of through a cluster, you can turn on code mode. You can select the repository that you want to work in. I'm going to go ahead and again, I'm going to select the popot and then from here I'm going to go ahead and say, I'd like to create a new new feature.
Now the first thing that it's going to do is that it's going to go into that repository and it's going to use a tool to get access to the cloud.md and the readme so that it understands more about that project and it's preparing to check out the code in order to help you implement the feature. Now, there's two different ways that we can use this feature. We can use it in headless. And I like to use this on my cell phone, and I'm going to show you that in just a minute. We have complete mobile support here, so that if I'm working here, and then I go to my phone, I don't have to change anything. I don't have to change a setting. I can just boot this up on my phone.
Now, from here, I could continue to chat back and forth with the AI agent and we could develop a plan. And once we had that plan, if I wanted to interact with cloud code directly, I just turn it into interactive mode and it's literally going to pop up cloud code and it's going to take that plan that we just developed and it's going to insert that context into this session and I could just simply start to work on that feature. So I could just say execute the plan and it would start to execute it.
Now there's also this here. So if I want to create additional shells where I want to just have other terminals where I can interface from a command line perspective in the same codebase. So here, and I can open up as many of these as I want, just like you could if you were using the terminal here. But what's cool about this is that if I now go to my phone, everything that I'm doing here will already be there. I don't have to send anything there. It's just there. In fact, why don't we go ahead and just look at that right now. I'm in my phone here. I'm going to click on the pop. It'll open up. And if I jump over, we can see all the different chats. I can filter just by the code chats and I can come right into the exact same session that I'm on. And right here, you can see where we have the different tabs that we were just working on. Type in from my phone. And if I were to jump back here, we're going to see that I just typed hello, and I'm back here. So, I didn't have to actually transfer the session back and forth.
And what's also cool is we have these built-in buttons down here which help you automatically commit your changes back to GitHub once you start the session. You can merge them back. You can reconnect. You can close the different sessions as well. And then you can also close the interactive session. And when you do that, it takes you right back to the headless mode where you're interacting with cloud code here. So I could say something like, create testing.md file with contents hello inside our project.
So now if we do it this way, instead of it launching an interactive mode, in this case what it's going to do is it's going to start a headless coding session and this is what's great on the mobile. If we come back to my mobile app, you can see it's all happening real time. So if I start something on my computer or if I start it on my phone while I'm traveling, and this is a much easier environment when you're on your phone. Although from my phone, if I hit headless again, you can come right back into the interactive session. And then again, I was modifying the Pokebot project. So if I come back to the Popebot, notice there was a commit one minute ago. We asked it to create a testing.md file with the contents hello. And there it is.
And just like the cluster mode, you can always see what's going on inside of the tool calls that's happening inside of Cloud Code when this is running. And then it's very easy to filter between all of your chats, your regular chats with your AI assistant, and all of your code chats. And by the way, if you need support, make sure to click on this link here and we'll be able to help you out.
Now, I will show you how to install this by yourself in just a moment. But just keep in mind, it's totally mobile-friendly. You can do everything on mobile that you can. And we've designed everything to work just the same way, just reformatted. You can go into clusters. You can be on the go. You could be anywhere you want and you could create a brand new cluster, set everything up, all your roles, everything. I've got other videos that explain more about the chats and the runners and the approvals. Those are super cool, too. You're going to definitely want to check those out.
Just like in any AI chat, you can star specific chats so that you can keep track of them, put them to the top if you're working on anything important like a specific feature. Even in cluster mode, when you go in here, you can monitor all of the different agents, view the trigger, the system, the user, and then you've got your settings. This is where you can view all of your cron jobs, all of the various triggers in the system, your secrets, everything.
Now, to get instructions on how to set up the Pope for free, if you just come to the GitHub page, the link is in the description below, and you scroll down to the getting started section, there are a few things that you need to install first, and then once you have those, it's really just a two-step process. You just cut and paste these commands and walk through the steps. I have other videos that walk through this step by step. So, make sure to check those out if you want a step-by-step video tutorial.
Now, if you want support on setting up the Popbot or you want to learn how to build amazing technology like this, make sure to jump into the No Code Architects community. I've got a new course that's coming out. I'm going to be dropping a new module every single day. It's going to go through the basics and the fundamentals, even if you're starting from scratch, all the way up to advanced stuff like you're seeing me build here. We've got calls on the calendar to support you and a great group of people inside the community. I'd love to see you there.