Transcription
[Music] If you haven't been vi coding enough, you must have experienced problems where you ask your cursor to implement a small change, but it just messes up your whole project, or your cursor is not aware of all the dependencies in your codebase and implements something that leads to loads of errors.
This is a very common issue of AI coding agents in general, no matter which platform you're using. But there's one technique that shows promising improvements that will make your cursor make way less errors: giving your AI coding agent a task management system. It helps it to understand the overall implementation plan and also control the amount of context that goes into each step when it is implementing specific tasks.
I was able to build a fully functional multiplayer online drawing game where both players can draw an image of a given word, and we send the result to GPT-4, where it looks at the image and gives an evaluation and picks the winner. And this whole game is actually implemented by my cursor with just one shot, without much error, which is absolutely insane.
That's why today I want to show you what my workflow is and how you can adopt it for your own project. And before you use any of those tools I just introduced, people have been hacking together task management workflows to improve performance for a while.
At its core, it basically means you ask your cursor to break down your complex PRD into small tasks and have a document where your cursor can have access to, to track and maintain what tasks are coming and what tasks have already been done.
And this is a quick example from Elle. The most basic implementation is in your cursor project; you will create a cursor rule, and it looks something like this. Basically, a rule where you tell your cursor to always refer to task.md to keep track of what tasks have already been done and what tasks haven't.
And with this, we can just create a task.md file and give a prompt: "I want to build an X app; help me break it down into small tasks of our core 'me' feature and add them to task.md." So your cursor will create a list of tasks here, and after your cursor finishes every single task, it will just come back and mark those tasks as completed. So it has a context of the overall implementation plan.
With this method, it already helps a ton for executing complex tasks with your cursor. But tools like Cloud Taskmaster and Boomerang Task from RuCo bring even more sophisticated task management behavior into AI coding agents.
For example, for Taskmaster AI, it is a command-line package that you can run in your cursor or Windsurf data, where it utilizes Cloud 3.7 or more advanced models to look at the PRD you have and break that down into small subtasks by running a simple command line like `taskmaster parse PRD`.
And what's really amazing about it is that it will break down tasks in logical order, considering all the dependencies between different tasks. So you won't have situations where your cursor implements something but requires other dependencies that haven't been implemented yet.
It also has useful command lines like `analyze complexities` to use perplexity and Cloud to analyze how complicated each task is, and if a certain task's complexity score is very high, it will allow you to expand on those tasks further and by breaking down those complex tasks into even smaller bits. The success rate of it delivering a functional application just increases dramatically.
And RuCo's Boomerang Task is also something similar. It gives AI agents tools like "new tasks" to break down a complex project into small bits and keep track of progress.
Those tools have completely changed my workflow. So I'm going to quickly take you through what's my new best-practice vibe coding workflow with those new tools.
But before we dive into that, I know many of you are trying to build AI agents for business. But there are many pitfalls I saw people fall into at delivering successful production agents. That's why I want to introduce you to this research HubSpot did where they interviewed tons of businesses and startups who have been launching AI agents for the past 12 months to understand which AI agent use cases actually drove huge amounts of business value and ROI versus ones that sound fancy but are actually very difficult to deliver value, and which signals customers are deploying huge amounts of budgets to buy AI agent solutions.
They include lots of real-world success stories and articulate those learnings into frameworks that you can use to build your next agents from, which use cases are more suitable for chatbots versus actual autopilot agents, how do you determine which tasks are best for AI agents versus more traditional workflow automation, as well as a list of common pitfalls that many other people encounter, including myself, when deploying production agents and best practices of how other people resolve that, like what's the best practice for you to build integration into existing systems.
This helped bring a lot of clarity to many mistakes I personally experienced. So if you're planning to build agents, I highly recommend you go and have a read, and this is totally free. I have put a link in the description below for you to download.
Now let's talk about my new AI coding workflow with task management systems. Firstly, let's talk about RuCo's Boomerang Task feature. And if you don't know RuCo, RuCo you can almost consider as an open-source cursor that lives inside Visual Studio Code. It is totally free to use. All you need to do is just provide your own entropy key, and then it will just work like any other AI coding agent that you've been using.
But what's really cool about RuCo is that, unlike Cursor where you only have a few predefined agent modes, RuCo allows you to create your own modes. Like, at default, they will provide a coding agent, an architect agent that will help you do the planning, a debug agent that helps you figure out where the error is. But you can also build custom modes like a "Boomerang" mode where it will be focusing on planning and breaking down the plan into smaller, manageable pieces.
Think of it like delegating your work to specialized assistants. Each subtask runs in its own context. So I can choose a Boomerang mode that I just customized and then say, "Help me build a to-do app." At the top, you can see that it will keep track of how many tokens consumption is, as well as the total amount of API cost, and it will firstly delegate a planning task to the architect agent, and this architect agent will have this system prompt where it will continuously confirm with me about the requirements, and then it will start planning out the project, breaking it down into specific features, figuring out things like user stories, key feature components, project structure, state management, and many more. So it has a full understanding of all dependencies between different functions. I can give feedback in the middle, and once the plan is finished and broken down into small tasks, it can switch to the code mode to start generating the code, and the code agent will start executing different tasks based on the plan and then complete the actual application for me. And you can see the result here is very high quality, and it even has functionality built in where the agent will be able to run the application in the browser, see the result to automate testing as well. And with this one, the result already feels better than what I got out of the box from Cursor.
But on the other hand, Cloud Taskmaster integrates much more deeply into Cursor and Windsurf. First, let's install the Taskmaster AI. You can open a terminal in any folder and do `npm install -g taskmaster-ai`. And once it's finished, you can run a few different commands. One will be `taskmaster init`. This will set up the project inside the folder. So you can just do `taskmaster init` directly. But I would suggest you set up the project first. Like, if you're building a Next.js project with Chess.js, you can just do this command.
And once it's done, we can do `cursor my app`. Inside here, we can do `taskmaster init`. This will ask for the project name, and I'll just call it "my app." The description doesn't really matter. You can skip all those things and then just let it set things up. And what will happen now is that on the left side, you firstly see it add a few cursor rules. Some of them are generic ones; like this cursor rule basically teaches your cursor how it can add new cursor rules. So as you go deep into the implementation, you can ask it to reflect and create rules about the mistakes it makes, for example, and it will follow these rules to create the next cursor rules, and this self-improvement is basically the same thing; it kind of tries to get your cursor to do this proactively, and the step workflow is where it teaches your cursor about all the commands it will need to actually check all the tasks in the backlog, and if you're using Windsurf, there will be a Windsurf root here as well. Inside the scripts folder, it provides a structure about what a PRD can look like, but the most important one is that it will have this `v.exam` example file.
What you need to do is swap out this entropy key as well as the perplexity key here. Entropy is a model that will be used to break down your PRD into small tasks, and they also use perplexity to do some research. So if part of a task is using a new package that just released, then it will actually use perplexity to fetch the latest developer documents and include those into the task information. So I recommend you add both API keys here, and once you did that, we can start creating our PRD.
There are many different ways you can create PRDs. If you're in the AI Builder Club, building already, you will have access to tools like 10x Coder, The Dev, where it will help you generate PRDs automatically and fill in all the gaps for the features that you might not think of. So if you're already in the AI Builder Club, you can use this tool to get the PRD here. But if you don't have access, you can also just chat with a cursor agent; use that to help you generate a PRD. For example, I can just say, "Help me build an online game like Scribble, but instead of a human guessing a word, it will be a large model guessing a word. So each round, all users will be given the same word, and they have 60 seconds to draw the image. In the end, all images will be sent to OpenAI, and let it choose which image is closest to the word. Now play the role as the engineer manager; help me think through what are the core features of implementing such a game," and then it will spit out the core functionalities. Obviously, I can chat back and forth, but once I finish, I can just say, "Great, now let's help me build the core MVP features requirements into prd.txt using the example prd.txt as reference," which is what we have showing here, and then you will see a PRD has been created with a good amount of details, and I will accept that.
So now since we have this PRD generated, the next step we can use this command `taskmaster parse PRD` to break down this PRD into small tasks, and this is where the power of Taskmaster begins. So I will do this: `taskmaster parse PRD scripts/prd.txt`. Okay, so I had this error; I just need to make sure you remove this example and let's do it again. So now it will start creating task files based on this PRD, and you will see here where we have a tasks folder. It has all the tasks that were created from Taskmaster. What we can do is we can do `taskmaster list`, and this will show you the list of tasks that it has been created. What's really cool about Taskmaster's task list is, on the right side, you can see here's a dependencies column. So when breaking down tasks, it will actually list out the tasks in a logical order and make sure there are clear dependencies mapped out. So when it implements, it can implement in the right order. Meanwhile, there are also some pretty useful commands. You have this command called `analyze complexity`. What this will do is that I can do `taskmaster analyze complexity`. This will basically send all the tasks I created to Cloud 3.7 as well as Perplexity; basically ask it to just evaluate how complicated or how difficult it is to implement this feature. And once it is done, I can do `taskmaster complexity report`. It will show me the evaluation of each task and its complexity score. But what's really useful is, for those complex tasks, it also gives you the prompt that you can copy. At the moment, you can't really copy this directly; if the UI just breaks up, but you can just copy the first one and go to the complexity report and find the specific ID, which is this one, and we can copy the expansion prompt. So here it generates a prompt: "Detailed technical implementation of HTML5 canvas component, including drawing tools, input handling across all devices." So I can just do this, and now it's breaking down that specific task into smaller ones. And as we know, once a complex task is broken down into smaller ones, it is more likely to succeed without any error. And you can continue doing that by adding another one for task number five. So you get the drill. Basically, you can do this process back and forth for a few times until you're happy with the backlog here. You can also do things like update as well. So if later down the road you decide to, like, change the plan, you can also do `taskmaster update ID=4` and `prompt=something like "Make sure we use Three.js"`. And what will happen is that once you give this prompt, it will actually update the whole plan based on this new instruction, which is really, really helpful. But once it's done, you can do `taskmaster list --subtasks`. This will show all subtasks here directly. So it will make it easier for you to review all the tasks here.
So that's pretty much it. Once we've done this, you can just go to the cursor agent and say, "Let's start implementing the app based on the tasks we created using Taskmaster. Let's check the next most important task first." So you might have this error here that it is reusing the wrong command. So I will just tell it, "Do not use script dev.js; use Taskmaster instead. Just list all tasks created and follow the plan." Then it will see the plan and decide to implement the first one first. And as it works on the task, it will also set the status of this task to be in progress. And here, since I actually turned on the YOLO mode of Cursor, which means it didn't ask me for permission for running any command lines, I can basically just go drink a coffee and let it do the work. And as it completes, it will mark this task as done and move on to the next one by doing `taskmaster next`. But now when you're in YOLO mode, I think Cursor, it will limit to 25 courses if you're using the Cloud 3.7, but you can actually put on Gemini 2.5 Pro Max. This will allow you to skip this limit and just do like 2002 courses without any pause here.
All right. So it's actually pretty crazy. It just continues executing tasks one after another and generates a whole bunch of files, probably a few thousand lines of code. And let's just run that first. So I'll do `npm run dev`. All right. So if I try to open this, it has a lobby building and authentication building. So I can give a name, choose an avatar, start playing, and my user has been created. I can set how much time we have for drawing, the difficulty, and whether it's a public game or not. So it's pretty good. I can create, but okay, looks like the actual game inside hasn't been done yet, but it's pretty impressive about how much it is able to deliver in just one go. And I can come back to do `taskmaster list --subtasks`. So you can see that it did the first four tasks, but it hasn't fully finished the development game run logic into my UI component. Maybe that's why the actual game room is not showing up. So I can ask it to continue to implement, but you saw that I had this error here, and then I can prompt it now: "Refactor the errors you made and create new cursor rules to make sure you don't make those mistakes again." Now you can see that it's actually adding new cursor rules about Next.js app routers. Though, for some reason, it didn't actually create content, which is a bit weird, and accept this one. So for now, I just copy-paste manually; I probably need to update cursor rules to make sure it will be saved properly. But now I'm going to continue the task. Now let's check what is the next task to complete to a point where we can do some quick testing of the drawing.
Okay, after another 15 minutes of it just doing the task by itself, I got this game that's kind of fully functional where I can give it a name, choose my avatar, start playing, and also create a room called "Jason's room." I can set a timer about how long people can draw, as well as the number of rounds, the difficulties, and if I create a room, other people will be able to see the room I created as well. Click on join; we will see multiple players in the room. And if I start this, I will have this canvas where people can start drawing to describe what this word is. And on the top right corner, there's also a timer documenting how much time is left. And once it finishes, it will send both results to ChatGPT, and GPT will look at the image and give the description and evaluation, pick the winner to get points, and then move on to the next one. So it's pretty amazing that it did a whole multiplayer game like this by itself in 20 minutes.
So this is how much performance gain you can get by equipping your cursor with the right task management systems, and what's really exciting is that this is just the beginning. I can imagine those tools and systems becoming way better in a few months' time. I also interviewed the creator of the Taskmaster project, where he gave a more detailed breakdown about the best-practice workflow to fully unleash the power of Taskmaster and exciting things that they are working on right now. If you're interested, you can join the AI Builder Club where I put a full interview and workflow inside the community for you to check out, as well as a bunch of other learnings and tips from industry experts for both vibe coding and building production-ready AI agents. And you will also have access to tools like 10x Coder, The Dev, where it will help you generate bulletproof Cursor PRDs, as well as Next.js boilerplates that already have all payment, backend, and database set up so you can launch your SaaS in just a weekend. I'll post a link in the description below for you to join if you're interested. I hope you enjoyed this video; I'll continue sharing new tips and workflows I learn.