Transcription
Hello, vibe coders. Following up on the last guide about Cursor, I decided to make another video where I will delve deeper and examine in more detail the method of orchestrating sub-agents in Cursor. Sub-agent orchestration allows us to increase the autonomy of neural networks. That is, we can literally load some huge list of tasks, entire roadmaps there and leave, while the agents complete this list of tasks. Moreover, due to the fact that we will use sub-agents, each working in its own context, we can not worry that our context will get clogged somewhere in the middle of the process and the neural network will start hallucinating. In this video, we will create such an orchestrator together, understand its operating principles, after which you will be able to create such systems yourself. Also, at the end of the video, I will provide a link where you can download the ready-made solution, so that you don't waste your time and tokens on neural networks. Everything is as usual, I provide the good stuff, and you provide a like and subscription, and we begin. After I tried this approach, for the first time, I truly felt that neural networks can be given some, well, quite large tasks. not even one big task, but a whole list of tasks, like we wrote the roadmap together, well, meaning very large, and leave somewhere, to drink tea, eat for half an hour, an hour, maybe even more, and the agents will indeed continue to work on this task. At the same time, the context will not get clogged, and they will not start hallucinating. This is cool. I'll say right away that such a system consumes quite a lot of tokens, but nevertheless, such a system can work for a sufficiently long time. And if we were to manually write all these prompts and control the neural network at each step, perhaps we would consume fewer tokens, but I have a feeling that not much less. Well, meaning the difference between us writing prompts ourselves for an hour, or giving some big task or a whole list of tasks and leaving the computer for an hour, is not fundamentally different. That is, in the first case, the neural networks work for an hour, we just launch them manually. In the second case, the neural networks work for an hour, they just launch automatically. Well, I don't know, there might be some difference. Just be prepared for the fact that all this, of course, consumes tokens. And this video is not about how to save on requests to neural networks and thereby less often hit limits. There is a separate video about that. This video is more about how to get the maximum autonomy from neural networks without significantly losing quality. That is, so that agents not only write code but also automatically review it. And we needed to be minimally involved in this process at all. So yes, a lot of tokens will be spent, but we will increase autonomy, free up our time, which is also worth something, and I hope, is worth more than these tokens that we will spend on neural networks. Okay, let's start. Now I have an empty folder open in Cursor. I named it Cursor Demo. In general, it makes no difference, just an empty folder. And we will start by creating sub-agents, because this entire system is built on them. It is they who ultimately allow the neural network to work autonomously for a long time without clogging the context. Because each sub-agent, when it starts performing a task, does it in its own context, without polluting the general context of our main agent. And, consequently, this is precisely what allows us to call sub-agents many times without losing the main context of the narrative, well, meaning the tasks of this process at all, but rather to solve all the necessary tasks sequentially using sub-agents. Okay. How do we create a sub-agent? Firstly, of course, we can manually create a Cursor folder here, create an Agents folder in it, and put the corresponding sub-agent files there. But we will go a different way now. We will do it through settings. Open Cursor Settings. Go here to Rules Skills Subagents. And here we find the Subagents section. Here it is, actually, we have it. And we need to click the new button. Do not pay attention that there are some sub-agents in the list. These are actually Claude's sub-agents, which are in my user folder. Well, meaning in the global folder that is available in all projects. Specifically in this project, there is nothing right now. No sub-agents, no files at all. Do not pay attention to all this. We will not use this now. The fact that the list might be empty is absolutely normal. In short, let's create our sub-agent. Click the new button. And a prompt for creating a sub-agent is inserted into our chat. The first thing we see here is the Create Subagent command. This is a built-in Cursor command that, I think, cannot be unseen or edited. Well, and it's not necessary. Just keep in mind that this command is already built into Cursor, and it contains some instructions for creating a sub-agent. And then Cursor suggests the following prompt start: help me create a sub-agent for Cursor. The first sub-agent we will create now will be a regular worker that will implement code and perform some tasks. Next, I wrote a description of the sub-agent, that it will write code, implement functionality, and perform some development tasks. And I want to name it worker, meaning the one who will actually be responsible for task execution. I send this prompt, I write here in English, because English characters consume fewer tokens. Therefore, all these system prompts related to rules, skills, and so on, are best written in English. Accordingly, for sub-agents too. Next, Cursor asks us: "Can you create a corresponding folder for agents." We, of course, allow it. It's embedded somewhere here in the command, in which directory agents should be created. Now, in theory, it should create a folder for us here. It turned out that it created a sub-agent in the user folder, but we need to create a sub-agent in our project folder. I won't even cut this out, because if you suddenly encounter such a situation, you will know what the problem is. Usually, it created sub-agents in my project folder, but for some reason, it decided to do it in the user folder now. Now I will undo all changes by clicking this arrow. And, in theory, it should have deleted that agent. And I will add here that it needs to be done in the project directory. I told it that it needs to create an agent in the project directory. Now, I think, it will do it correctly. Yes, indeed, its path has changed. Now it has created the Cursor folder inside our project folder. And in the Cursor folder, an Agents folder has appeared, in which the worker has appeared. So, here is our sub-agent, which will implement tasks. In fact, we can already use it without any other settings at all. But we can use it more in manual mode. It, of course, has a description field, this field, which is also displayed here. And here too, it can be edited, they are linked to each other. And based on this description, in theory, Cursor can understand when we need to call this sub-agent. But, judging by practice, this happens, well, every other time. That is, it can potentially do it, but it might not. If you want Cursor to understand when to call this sub-agent itself, and it somehow doesn't understand, then the first thing to pay attention to and edit is this description. That is, this description is loaded into Cursor's context every time we send a prompt here. It may not count the main content of the agent, but it sees the description of the agent. And if at some point it understands that the description fits the current situation, and at this moment the sub-agent needs to be called, it will do so. But this is not the only way to tell it about it. We will get to that a little later, when we configure orchestration. But let me just demonstrate for the sake of completeness that it can be called right now. To do this, it is enough to just type the name, or rather the name of our agent, through a slash. In our case, it's worker. Cursor suggests our agent here. If you click on it, then, actually, it is highlighted. And in this way, we refer to our sub-agent. I can give it some prompt. For example, write a Redmi file in the root of the project, which states that this is a test project for demonstrating orchestration. Let's say I write him such a prompt. In fact, this is not critically important right now. For now, I will choose the Haiku model, just to save a little tokens. And by the way, yes, pay attention that in the settings of our agent, the model is highlighted here, and it says inherit. This is the default value, but we can also choose a specific model, and then this sub-agent will work on this model. That is, if the sub-agent is involved in some complex tasks, you can set a better model for it, for example, Opus. Or, if the sub-agent is intended for performing some very simple tasks, you can set a simpler model, for example, Haiku. Note that it has finished performing our task, created the items, it took a little time. Obviously, this task is not large, but the main thing that interests us is this block that appeared in the context. If you click on it, the context of the called sub-agent will open. You may notice that the content here differs from what we see in the main chat. And this is normal. In the main chat, we have the main context with our agent, and this is the context of our sub-agent, which does not go into the main chat. Well, meaning it passes some result of execution to the main chat, but all the main work remains in its own context. Due to this, the use of the context window in the main sub-agent is saved. In this case, we spent 16%, which, actually, is not small, but here you need to understand that when we send a prompt, it also sends some system prompts of Cursor there, including some rules, if we have them, for example, from user rules, which are sent everywhere. Here in the User Rules section, yes, I have some rules there. It's not that important, actually, what's written there. They are just sent there too. And plus, yes, some master prompts from the program itself, from Cursor, also go there. In short, the first request may take up more context than expected. But, let's say, if we pass something else here, then the next increase in context will not be so large. Well, especially if we call a sub-agent and it takes over the work. So don't be scared. Okay? Now we have demonstrated the work of sub-agents in general, it is clear how they are called, how they look. They look, in general, accordingly. The name of the sub-agent is written. It was called in its own context and did some task. Now I will delete this file. We don't need it for now. Now let's create another sub-agent, just so we have someone to orchestrate, so to speak, so that they run in sequence. And we will do it the same way we did it with the first agent, through settings in the Subagents section, click New Agent. And now I will write a new prompt here for creating the second sub-agent. I will write a fairly simple prompt here: subagent reviewer, which will check the quality of the created code. And I will also mark that it needs to be created in the project directory. Usually, it figures this out itself, but just in case, I will tell it, since we encountered such a moment today, I will immediately choose the 4.5 model and press Enter. Okay. Now we have two sub-agents. these are Worker and CodeReviewer. For now, let's agree to all changes. I will not go into detailed configuration of these sub-agent prompts now, because again, this video will be very long. It's probably going to be long anyway, but at least not 2.5 hours. This can be read and edited, naturally. That is, you can treat these sub-agent creations as some kind of template, I don't know. In any case, they need to be checked, reviewed, verified for compliance with your specific situation, for your specific project, supplemented with some information for your projects, or, conversely, removed some unnecessary instructions. But for now, we will not do this. Let's now move directly to the orchestration process. Well, meaning, we have two sub-agents. Now, so as not to multiply these entities too much, let's understand how it works with a simple example. Initially, I planned to do the orchestration process, that is, sequential and looped calling of sub-agents, through hooks, but I couldn't do it through hooks. More precisely, it worked somehow, but not as I would like. That is, one sub-agent was called, and then the hooks that called subsequent sub-agents were called somehow strangely. That is, the sub-agent instructions seemed to be called directly in the context of this one sub-agent. And in the main chat, there was only one sub-agent, but I wanted to see these blocks sequentially, that first one works, then the second one works. In short, I couldn't do it through hooks. But I managed to do it perfectly through skills. And this is precisely one of the cool examples of using skills. In the Cursor guide, I already said that skills are designed to describe some processes. And now I will add that these processes can be either small, for example, working with git, or global processes. That is, in general, implementing some tasks and working with agents, sub-agents, when to call whom, when to do what and how. In general, we will create all this now. Go to settings again. I will try to show as much as possible through the graphical interface all these creations. In fact, you could just create these files manually, they would work exactly the same way, but for simplicity, I will show how to do it through the interface. Go again to settings in the Rules Skills Subagents section and next to Skills, click new. The Cursor command Create Skill is called again, asking us to help create a skill for Cursor. And here we will now need to describe the process of working with sub-agents, their sequential calling, how we want the Cursor agent to do it. Write a skill that describes the process of sub-agent work as follows. When the agent receives a task for implementation, creation, in general, some development task, first the Worker sub-agent should be launched, which should do this task. After its completion, the CodeReviewer sub-agent must be launched and check the quality of the worker's work. At the same time, if the CodeReviewer finds critical errors, shortcomings, or opportunities to optimize the code, it should write about it, after which the Worker should be launched again and implement all this optimization proposed by the CodeReviewer. I have translated the dictated prompt into English. Let's send this prompt and see what Cursor creates, what skill it makes for us. Interesting point. We did not specify here which skill we want to create, global, i.e., in the user folder, or local, in the project folder. And it asked us here. It would be nice if it also asked us for sub-agents. Well, maybe we were just unlucky and something glitched. It decided not to ask. In any case, let's do it in the project folder. I click continue. And now it should create a skill that will appear in the Cursor folder in the Skills folder. So, it has finished working on the skill. Let's see what it came up with. In the Cursor folder, a Skills folder appeared, and in it, a Subagent Workflow folder appeared. Skills are created in folders, that is, unlike agents, which are a single agent, a single file, skills are entire folders that contain the main skill.yaml file. And there may also be other files, for example, scripts or additional instruction files. But now we don't need to create them. Let's see what it came up with. I will agree with its changes. In general, here it wrote a description about orchestrating worker, code reviewer sub-agents for task implementation. Let's try to perform some task and see how well it did, how well it considers this skill. Preliminarily, I will create a new folder, which I will call app, so that it creates some new project inside it. Create a T3K project in the app folder with a main page that writes Hello Vipe Coders. A simple enough prompt. Instead of the app folder, I will literally send it a link to this folder, so that it doesn't get confused, and ask it to do it. T3, in a nutshell, is a set of tools for developing frontend with NextJS. Note that now it is not calling any sub-agents, that is, well, by and large, you can even stop here. We were primarily interested in the issue of calling sub-agents. And as you can see, neither the description in the agents nor the description in the skills helped us automate this process, so that it understands us right away. We wanted it to launch one sub-agent, then the second one to check it, but no. Let's go back, and now I will explain what can be done. Firstly, you can, of course, tell it in words: "Use the subagent workflow skill." That is, explicitly specify which skill it needs to use. Well, firstly, it's not written quite correctly here. Well, let's try it for the sake of interest. Let's see what it does this time. We have now explicitly told it to use the skill. And yes, it started launching the worker. After which, well, let's see how it does it. It should launch the reviewer when the worker finishes. But again, writing this every time, using the skill, is not very convenient. Therefore, we will now optimize this process so that we don't have to tell it about this skill every time. In general, I don't think it was necessary to write the skill name directly. You could have written it in free form, like, using sub-agent orchestration or something like that. But in any case, it's inconvenient. We need a simpler solution. We will get to it now, let's just see what it does, and then go back to configuration. Well, Cursor has finished creating the application for us, and note that the context is filled by only 18%. That is, if we compare it with our first prompt, when we asked it to make a Redmi file, the task is actually much smaller. The difference is only 2%. That is, sub-agents take over all this main load of context usage, and only pass the result to the main chat agent. And, accordingly, you can work longer in the main chat. We can launch what we got. In fact, this is not the topic of this video at all, and it's not so important what we get there. If we go from the browser, then yes, Hello Vipe Coders, everything is great, everything works. Okay, so far, clear. The project itself doesn't interest us much now, we are more interested in configuring our agent ecosystem. So let's get back to our problem. That writing about skills every time is not very convenient. And this can be solved, for example, by using a command in which we will explicitly specify that we need to use such and such a skill. Let's create our custom command, go to Cursor Settings again, to the Rules, Skills, subagents section. And here, if you scroll down, we have the Commands section. Let's click New and select Project Command. Next, we need to come up with a command name. I will call it implement and press Enter. Actually, here is the command file we created. Commands are stored inside the Cursor folder in the Commands folder. And yes, they are essentially just a separate file, which, in general, contains instructions for executing the command. By and large, it's like a pre-written prompt that is called in the chat and, well, roughly speaking, is simply substituted into the chat. We can already call it, although it won't give us much. If we write implement like this, we see a hint here that we have such a command. If we click on it, it will be highlighted and, actually, the instruction from this command will be executed. But before executing it, let's write the instructions in it. I will also do this through the neural network. Create an implement command that should call the development process described in the Workflow skill. In general, a simple enough prompt. The only thing is that I will now replace the name with links, directly with files, and edit it a bit to make it correct. Like this. Everything is good. Let's send it. And now Cursor will create this command for us, which will specify specific instructions that we need to use the skill. In fact, you could also specify in the skill here, for example, use this skill whenever the implement command is called, but for now, this is probably redundant. Cursor has created the command for us, we agree with it, everything is great. And let's now try to execute this command and add something to our application. To do this, we call our command and write some prompt. Add a button to the main page and a click counter. In general, a super elementary task, but the main thing for us now is to see how the process will work. I send him this prompt, and let's see what he will do. Firstly, as we can see, he read the skill and, actually, started execution, meaning he activated our worker, after which our code reviewer should be activated. Cursor has finished performing our task. It first called the worker for implementation, then launched the code reviewer. And we can see that the code reviewer found some problems that are worth fixing, after which the worker fixed these problems. Well, cool. That is, orchestration is already working in some form, right? This is a maximally simple system, but at least from this example, you can understand how to build such processes. Let's see what the code reviewer answered. Gave an assessment of the implementation, found some potential problems and suggested fixing them. After which the worker was launched and fixed these problems. Well, by the way, cool. I will not explain in detail what he did here now, but I will just say that the fix is indeed relevant. And it's good that the reviewer noticed this error and potential problem. Let's see what we got. The click counter works. Everything is great. So, what do we have at the moment? Orchestration is already working in some form. We have two sub-agents and a skill that launches them. And, in principle, it does it well. But let's expand the capabilities of our orchestrator a bit. That is, now we have only two sub-agents. This is a simple worker and a guy who checks him. But if we work with very large tasks, for example, throw a roadmap here or just write some very large task or a list of tasks, then perhaps our orchestrator will not work perfectly in the sense that the worker can take on all tasks at once and clog its context, then the sub-agent, after which it will start hallucinating. We wouldn't want that. Therefore, we need to come up with something like a planner, a sub-agent, which will distribute these tasks. That is, a sub-agent that will create a list of tasks and then pass all these tasks sequentially to the worker. More precisely, our main agent will pass them, but the planner will create a list of sequential tasks to be performed. Let's create such a sub-agent. Go to Cursor settings again, to our favorite Rules Skills Subagents tab, and create a new sub-agent. Here I will write the following prompt: subagent planner, which will create a plan for implementing large complex tasks, break it down into subtasks, for each of which it will also create a file in which it will describe this task. Well, let's do something like that. Only now we need to translate this into English. And for now, that's enough. Let's send him this prompt. Here, by the way, it's interesting. Now we again didn't tell him what to do in our project folder. I hope he figures it out, or at least asks. Yes, indeed, it started doing it in the project folder. This is exactly what we needed. Cursor has finished creating our sub-agent. Let's see what it came up with. In general, it wrote some description. We are more interested in the actual instructions. Here is a description of its plan of action. That is, first it should understand the context, then create a master plan, after which it should create files with tasks. And it will do this in the folder tasks. Well, for now, this suits us. In this case, I want to show precisely the principle of how it should all work. And you can configure all this as you like. The only thing I would like to add here is that I would also like it to create files for the plans. Let's tell Cursor about this, so that it adds it. I want the planner to also create files with plans, in which it will indicate links to tasks. I will translate this into English immediately and send this prompt. Cursor has supplemented our planner's instructions, added here that it also needs to create files for plans. And for now, this suits us. I don't want to go too deep into this. The most important thing now is to show the principle of operation. Now we have a planner that breaks down large complex tasks into subtasks, after which our Worker should pick them up, and CodeReviewer should review them. Our current skill does not reflect this process, so we need another skill. Let's create it. Also through Cursor Settings. Go here to the Skills section. Click New. And now I will write him a description of the skill I want to get. Create a sub-agent orchestration skill that will reflect the following sequence of actions. That is, upon receiving a large complex task or a list of tasks, the planner, a sub-agent, should be called, which creates a plan for implementing all tasks, creates files with tasks. After the planner finishes its work, for each task, first the worker should be called and do this task, after which the code reviewer sub-agent should be called and check the implementation that the worker did. And this process should occur iteratively until all tasks are completed. Okay. Well, something like this, I think, will suit us. I will also translate this prompt into English. Uh, let's look at the sub-agent names. So, I've slightly edited the prompt. I think this will be enough now. I send the prompt to Cursor. Cursor looked at our sub-agents, also looked at subagent workflow and proceeded to create a skill for us. But here I want to note that for some reason it decided not to create a skill, but to edit the current skill. Let's stop it. I still want to separate this into two skills, because the first skill, which we have created now, we can apply for some small tasks, but for complex tasks, I would like to use the orchestration skill. I will undo the changes and add the following here. Create a new skill Archestrate workflow. That is, I explicitly tell it that it needs to create a new skill for this. Of course, now you can edit the previous skill, the name, something else, but for now, let's not go into this. That is, in principle, it can all be edited as needed. For the example, this will be enough for us. Cursor has created a new skill Orchestrate Workflow for us. And by analogy with the previous skill, let's create a specific command that will launch this orchestration. We already have Cursor settings open here. Go down here to commands, click New Command, Project Command, and here we will write the command Archestrate. Okay, I have created a new command file and will fill it using the neural network as well. Edit the Orchestrate command so that it calls the orchestrate workflow skill and launches the process of complex development of a large task or list of tasks. Now I will also immediately send him the context of what we have, so that he explicitly looks at our files. You could, in principle, not do this, but I feel calmer this way. And instead of Orchestrate workflow, I will also send him our skill. I won't even translate this into English now. In principle, I think he will figure it out and create it in English. If anything, I will ask him to translate. Yes, indeed, Cursor has created the command in English. For now, this suits us. In principle, we can already use it. Let's check how it works and ask it to do some, well, a big task. We call the Archestrate command. And now I will write him some big task. Look at the application that is in the app folder, and instead of the main page, create a screen with a game. A game in which two players will participate. They take turns pressing a button. When the button is pressed, a random number from zero to 100 is generated. And the player whose number is closer to fifty wins. Let's do something like that. It's not important. The main thing is that it's a task that cannot be solved in one action. I will immediately send him the app folder here and won't even translate the prompt into English. I'll send it to him like that. And let's see what he will do next. That is, in theory, he should first call our planner, but for some reason he decided to call the worker immediately. Let's stop this process, because I still wanted him to launch the planner. And let's look at the command again, Orchestrate. There is an error here in that the skill is written here not as Archestrate workflow, but as subagent workflow. Therefore, it was launched. Therefore, let's change this path to the skill here to Archestrate workflow. And now this skill should work correctly. Well, because we explicitly specified it. Before that, of course, another skill was specified, so it was launched. Cursor has studied the Archestrate workflow skill. Now it should launch the planner for us. The planner is launched. We can see what's happening in its context. First, it creates a Tasks folder in Cursor to save tasks. We allow it to do this. This needs to be done once, after which the Tasks folder will be created, and it will not ask us about creation. We can see that it has created a plan and now, in theory, it should break down the individual implementation tasks for us. The first task is ready. Uh, the second task is ready. So, our sub-agent planner has created seven tasks, finished its work, after which our Worker sub-agent is launched and begins to implement the first task. Note that it does not take the entire plan and all tasks at once, but will sequentially perform tasks from the first to the last. It has implemented the first task. Now our code reviewer is launched and looks at, actually, the work done by the worker. The reviewer has finished its work, apparently found no problems. Says that the first task is done correctly. And then the worker moves on to the second task. Thus, Cursor has reached the last task. The last one even launched the browser inside Cursor and checked that everything is clickable and works. Well, meaning, it is currently in the process of this check. I saw that it was scrolling, clicking, changing something in the browser. Let's wait for it to finish and see what it did. Don't be alarmed by this white background. I think it's just testing the mobile screen resolution. Well, Cursor has finished the full execution. It went through all the tasks, did everything, reviewed everything. You can look at this whole history. That is, first the planner was called, after that, for each task that the planner created, worker, code reviewer, worker, code review, and so on were called. In the end, it tested that everything works, the code reviewer worked, and Cursor wrote that everything is ready. Let's see what we got. To do this, I will open this history in the browser after all. And number battle. Cool. Let's start game. Generate number. Well, 8350. Player two wins. Okay, great. Play again. Start game. This is the first player. And the second player is 23. Well, again Player 2 Wins. Well, in short, there's not much to look at with random numbers. It just works, that's the main thing. And we're not even that interested in this project. First and foremost, we are interested in the approach to development through AI agents. The execution of this task took about 20 minutes, probably. But during all these 20 minutes, no actions were required from me, except for allowing Cursor to create a folder with tasks at the very beginning. Given that when it created it, it will no longer ask about it. Accordingly, 20 minutes of autonomous work, sequential task execution, review, everything is great, everything works. Among the noteworthy moments, we can see that only 28% of the context is filled. It is also worth noting that potentially, of course, this task could have been simply thrown into one chat and asked the agent to do it without sub-agents. And probably, it would have coped. But when we do it sequentially, break it down into plans, launch a sub-agent for testing and code review, we reduce the probability of errors, low-quality code, and so on. In general, the principle, I think, is clear. In this case, we used a relatively simple system of three sub-agents. Plus, the tasks remained in place, they could have been, for example, cleaned up, integrated into the workflow, and so on. But I think, from this example, it was already clear how it all works in principle. And then you can create your own orchestration systems as you need them. And if you want to save time on setting up your orchestration system, you can download my ready-made Cursor setup from my website. I will provide the link in the description. This setup currently includes a number of agents. a more advanced version for all this orchestration. It also includes implement commands, a set of some rules for git, documentation, testing. It also includes skills that help with orchestration, security checks, various vulnerabilities for working with git, code quality checks, and so on. It also includes a config file where you can configure your paths for storing documentation, or disable documentation recording for each of these sections. You can disable everything if you don't need it. I will leave the download link in the description. It leads to my website. In the Resources Hub section, there is the Cursor AI setup. I will say right away that the setup is paid, but by purchasing it, you will, firstly, receive support from me for its use. You can write me some questions. Secondly, the setup will likely be updated over time, and a new version will be promptly uploaded here. If Cursor introduces any new functionality that is appropriate to include in the setup, I will do so. I will also rely on your feedback and reviews, and if something is appropriate to add to the setup, I will do so, and you, in turn, will be able to download the updated version. I tried to make this setup as universal as possible. It is suitable for any project, and you can also supplement it with your own specific requirements and instructions for your specific project. In principle, based on this video, you can set up this system for yourself. But if you want to save your time and money spent on neural networks, then please, there is a ready-made solution. I bid you farewell. If you liked this video, give it a like so that YouTube recommends you more useful content. Subscribe to the Godny Vibe Coding Telegram channel. I publish useful materials on vibe coding there. We also have a vibe coder chat where you can chat with other vibe coders, ask questions, answer questions. In general, join our vibe coder community, subscribe to the YouTube channel so you don't miss new videos. And with that, I bid you farewell. All good code and see you soon.