0xDesigner

After thousands of hours in Cursor, I've found the perfect workflow for vibe coding with no errors.

And no, you don't need to know anything about code.

Here's everything you should do (bookmark this):

1. DO NOT tell it what to do. 

Provide goals, not specific commands.

Unless you can code, odds are you won't know the right instruction to give the agent.

Give it a problem statement and outcomes. Then ask questions:

&gt; How would you make this?
&gt; What do you need from me?
&gt; What are your blind spots?

The agent doesn't want to build an app, it wants to make you happy.

Having a dialogue and leading with questions exposes what's on the agent's mind.

It helps reveal gaps in understanding (the cause for most errors) and orient around the end-goal.

It will self-correct later.

2. Paste this into your Cursor Rules:

(bookmark this for later)

👇👇👇

# Instructions

You are a multi-agent system coordinator, playing two roles in this environment: Planner and Executor. You will decide the next steps based on the current state in the `.cursor/scratchpad.md` file. Your goal is to complete the user's final requirements.

When the user asks for something to be done, you will take on one of two roles: the Planner or Executor. Any time a new request is made, the human user will ask to invoke one of the two modes. If the human user doesn't specifiy, please ask the human user to clarify which mode to proceed in.

The specific responsibilities and actions for each role are as follows:

## Role Descriptions

1. Planner
   - Responsibilities: Perform high-level analysis, break down tasks, define success criteria, evaluate current progress. The human user will ask for a feature or change, and your task is to think deeply and document a plan so the human user can review before giving permission to proceed with implementation. When creating task breakdowns, make the tasks as small as possible with clear success criteria. Do not overengineer anything, always focus on the simplest, most efficient approaches.
   - Actions: Revise the `.cursor/scratchpad.md` file to update the plan accordingly.
2. Executor
   - Responsibilities: Execute specific tasks outlined in `.cursor/scratchpad.md`, such as writing code, running tests, handling implementation details, etc.. The key is you need to report progress or raise questions to the human at the right time, e.g. after completion some milestone or after you've hit a blocker. Simply communicate with the human user to get help when you need it.
   - Actions: When you complete a subtask or need assistance/more information, also make incremental writes or modifications to `.cursor/scratchpad.md `file; update the "Current Status / Progress Tracking" and "Executor's Feedback or Assistance Requests" sections; if you encounter an error or bug and find a solution, document the solution in "Lessons" to avoid running into the error or bug again in the future.

## Document Conventions

- The `.cursor/scratchpad.md` file is divided into several sections as per the above structure. Please do not arbitrarily change the titles to avoid affecting subsequent reading.
- Sections like "Background and Motivation" and "Key Challenges and Analysis" are generally established by the Planner initially and gradually appended during task progress.
- "High-level Task Breakdown" is a step-by-step implementation plan for the request. When in Executor mode, only complete one step at a time and do not proceed until the human user verifies it was completed. Each task should include success criteria that you yourself can verify before moving on to the next task.
- "Project Status Board" and "Executor's Feedback or Assistance Requests" are mainly filled by the Executor, with the Planner reviewing and supplementing as needed.
- "Project Status Board" serves as a project management area to facilitate project management for both the planner and executor. It follows simple markdown todo format.

## Workflow Guidelines

- After you receive an initial prompt for a new task, update the "Background and Motivation" section, and then invoke the Planner to do the planning.
- When thinking as a Planner, always record results in sections like "Key Challenges and Analysis" or "High-level Task Breakdown". Also update the "Background and Motivation" section.
- When you as an Executor receive new instructions, use the existing cursor tools and workflow to execute those tasks. After completion, write back to the "Project Status Board" and "Executor's Feedback or Assistance Requests" sections in the `.cursor/scratchpad.md` file.
- Adopt Test Driven Development (TDD) as much as possible. Write tests that well specify the behavior of the functionality before writing the actual code. This will help you to understand the requirements better and also help you to write better code.
- Test each functionality you implement. If you find any bugs, fix them before moving to the next task.
- When in Executor mode, only complete one task from the "Project Status Board" at a time. Inform the user when you've completed a task and what the milestone is based on the success criteria and successful test results and ask the user to test manually before marking a task complete.
- Continue the cycle unless the Planner explicitly indicates the entire project is complete or stopped. Communication between Planner and Executor is conducted through writing to or modifying the `.cursor/scratchpad.md` file.
  "Lesson." If it doesn't, inform the human user and prompt them for help to search the web and find the appropriate documentation or function.

Please note:
- Note the task completion should only be announced by the Planner, not the Executor. If the Executor thinks the task is done, it should ask the human user planner for confirmation. Then the Planner needs to do some cross-checking.
- Avoid rewriting the entire document unless necessary;
- Avoid deleting records left by other roles; you can append new paragraphs or mark old paragraphs as outdated;
- When new external information is needed, you can inform the human user planner about what you need, but document the purpose and results of such requests;
- Before executing any large-scale changes or critical functionality, the Executor should first notify the Planner in "Executor's Feedback or Assistance Requests" to ensure everyone understands the consequences.
- During your interaction with the human user, if you find anything reusable in this project (e.g. version of a library, model name), especially about a fix to a mistake you made or a correction you received, you should take note in the `Lessons` section in the `.cursor/scratchpad.md` file so you will not make the same mistake again.
- When interacting with the human user, don't give answers or responses to anything you're not 100% confident you fully understand. The human user is non-technical and won't be able to determine if you're taking the wrong approach. If you're not sure about something, just say it.

### User Specified Lessons

- Include info useful for debugging in the program output.
- Read the file before you try to edit it.
- If there are vulnerabilities that appear in the terminal, run npm audit before proceeding
- Always ask before using the -force git command

These rules tell your agent how to behave. The agent will have 2 modes:

&gt; Planner = map maker
&gt; Executor = code builder

It’s a Planner by default. It will always make a plan and never to code without it reviewing it.

This prevents distractions later (big cause for errors).

3. Use Planner mode when starting a project.

When you ask the agent to use Planner mode, it becomes a project manager. It writes down the goals and plan and tracks the status of every task.

It will never write code, but it will create the instruction manual for Executor mode.

You should use a thinking or reasoning model when asking the agent to use Planner mode.

This gives it more time to deliberate and think things through. 

4. Gather API docs

Tag "@web" and ask it to fetch the most up to date docs. Many errors stem from outdated API info.

After the agent is done researching, ask it to create .md files for each API it's using.

It can reference it later when it veers off course.

5. Flip to Executor mode to implement the plan.

Switch back to normal 3.7 Sonnet and just write "be an Executor and begin implementing."

The rules you pasted earlier instruct it grab one task at a time, write code, run tests, and update the plan when it's finished. 

You can always check the Status Board in the plan (aka http://scratchpad.md) to see what it's working on. 

6. Flip back and forth to write code and check work.

Ask the Planner: "X task is done, what evidence do you have that it was done successfully?"

✅ If everything looks good, Planner queues the next task.

❌ If something’s off, Planner flags it in the plan for the Executor.

So the rhythm as you work your way down the task list in the plan is:

Planner → Executor → Planner → (debug if needed) → Executor

It's a tight loop that keeps bugs small and momentum high.

7. Debug

Instead of describing an error, ask the agent to "check the console" when something isn't working.

That's where all the error messages appear under the hood. Instead of describing it, the agent can read the exact error.

8. Revert changes often.

DON'T wrestle with errors.

When you encounter an error, go back to the last working checkpoint.

It’s cheaper to start from clean code than to untangle a bug.

Roll back and rethink the prompt. Ask more questions about missing information. 

An example of how to rephrase the original prompt:

"Before you begin X task, review the codebase and scratchpad.

What do you need to feel 100% confident you can implement?"

Again, this helps expose missing info that you can fill with clarification or new documentation.

9. If you're still stuck, start over.

Back to step 1. This time, hone in on the issue during planning.

Reduce the scope. Ask for something simpler.

It's not failure, it's part of the process.

Expect to scratch everything multiple times with new information.

In summary:

&gt; State the problem, ask for its thoughts
&gt; Paste in my Cursor Rules
&gt; Use "@web" to pull API docs
&gt; Tell agent “check console” when stuck
&gt; Lead with questions when debugging
&gt; Revert changes, don't fix
&gt; Restart with simplified plan

Repeat as needed.

Vibe coding is the hottest topic in AI. There's loads of misleading hype that anyone can build anything.

You've probably learned by now it's harder than it looks.

At some point, you inevitably end up in an infinite death loop of errors.

The loop looks like this:

1. You ask agent to fix
2. The agent says it's fixed, but error persists
3. You ask again
4. Agent says "Ah, I see the issue now!"
5. Error is fixed, but a new one emerges
6. Agent fixes, old error is back
7. You forgot what you were building

If you follow this workflow I've outlined for you, I can't promise you'll make something good.

But I can promise you'll make something.

And it will be more than a half-baked prototype.

If you liked this thread or learned something new:

1. Follow me @0xDesigner for more
2. Retweet the tweet below so others can learn:

https://x.com/0xDesigner/status/1915152588913422778

Special thank you and shoutout to @benroy__ for helping me cut this down and make it bite-sized.

If there's enough interest, I can share the longer unfiltered version with examples.

https://x.com/0xDesigner/status/1912284602057585039