Tips & Tricks 🎯 How to Make Cursor One-Shot Complex Projects

Best practices to make Cursor build an entire project on its own

Feb 23, 2025

Like many other developers these days, we use cursor to accelerate our work. We write less of the code ourself and rely to a larger degree on the output of Claude and similar algorithms. However, it doesn’t always produce the output we want and, in large projects, it often create more problems than it solves.

The reason is that cursor doesn’t see your folder structure automatically when generating new code and it doesn’t know what you want. But it is possible to create entire projects from scratch if you provide enough information and force the AI to follow a carefully crafted plan.

This story contains our most important tips to make Cursor build an entire project on its own with minimal intervention from you. I will use one of our projects to show you what it looks like in practice.

If your organization or team want our help to improve your Cursor workflow, let us know by reaching out to oscar@nextml.com.

#1 Define Your Cursor Rules

To define rules that cursor should follow for everything it, you define a .cursorrules file and put it inside .cursor/rules/. Here we want to describe things like our tech stack, preferred coding structure, and general guidelines. For the workflow you will read about below, it’s also important to

Here’s and example of what that file could look like (don’t worry if it doesn’t make sense yet).

#2 Familiarize Cursor With the Repo 🔍

Cursor doesn’t look at your projects structure automatically when you ask it to do something. That’s why it often adds files in the wrong places and use technologies like Typescript even if you don’t use it in the project.

To solve that, tell cursor to run ls or tree before doing anything else. That way, it adds relevant information about your project structure before trying to make changes. It’s also good to point our important files and documentation.

Giving cursor as much information as possible about what you’ve done before, what you want to do now, and what you plan to do later is critical for a smooth workflow.

#3 Tell Cursor to Create a Design Plan For the Interface ✅

Before you let cursor write code or change anything in the library, tell it to create a plan describing the interface of what you want to build. The interface can be a web interface, an API, an SDK, a feature in an existing repository, or something else.

Read the plan yourself, provide feedback to Cursor, and iterate until you feel that the AI has fully understood what you’re trying to build.

Note that this step and the following ones are markdown only and Cursor shouldn’t write a single line of code. We just want to align on a vision with the AI.

Here’s what a query looked like for te project above:

We're building a CLI tool to aid web development. We want to let an AI use this CLI tool to load a webpage it's developing and get console logs and a representation of the webpage. This representation will only be markdown to start off (HTML -> markdown). We will add other things later. Use markdownify and playwright and poetry. Think through step by step how to make this very easy to use for an end user. Focus only on the interface for now (don't think about the implementation yet). Write your plan in PLANNED_INTERFACE.md

#4 Tell Cursor to Create a Implementation Plan ⚙️

When the design plan looks good enough, we want cursor to create an implementation plan describing how it intends to implement the project. This should include things like a high level overview, folder structure, core functionality, and more.

Provide feedback on the plan and iterate until you feel that Cursor has presented a solid idea. Make sure that it understands your goals, requirements, and core principles that would make this project truly useful.

Example query:

Nice! Review .cursorrules and make a plan for implementing the planned interface. Think step by step and finally write it down in IMPLEMENTATION_PLAN.md. Speed is a very high priority. Are there things we can about this or potential alternative solutions that we might be able to use?

#5 Tell Cursor to Create a Todo List ✅

Now that we have both a design plan and an implementation plan, it’s time to let Cursor create a todo list. Tell the AI to define small tasks that, taken together, completes the implementation plan.

Iterate just like you did in the previous two step until the todo list looks good. We still haven’t used the AI to write a single line of code. All our work so far is intended to provide the best possible context to Cursor.

Here’s what the query could look like:

Please write a checklist in TODO.md of what to implement and how to test it (simply). Please iterate between implement, test, implement, test, etc. in the checkpoints Base this checklist on the planned interface and IMPLEMENTATION_PLAN.md

#6 Build the Project 🛠️

We have everything we need and it’s time to tell cursor to build the project, but not without additional rules. As part of each item on the todo list, we tell Cursor to write tests, and to iterate between testing and implementation.

In other words, when cursor is done with one task, it should run all tests to ensure that everything works. If it does, it can start on the next task, otherwise it has to solve what isn’t working first.

Forcing the AI to iterate like this when implementing the project takes time, so you need to run it in agent mode with YOLO enabled. That way, you can do something else while Cursor hacks away.

You might need to do a bit of handholding during implementation. After 25 steps, Cursor will automatically ask for your input. If everything looks good you can just tell it to continue.

Here’s what the query could look like:

Please start implementing this. Check off points on the checklist in TODO.md as you work. Implement and run tests by yourself. Don't stop to ask for confirmation.

Some General Tip 💡

Cursor perform better at small well-defined tasks and technologies where there are fewer correct answers. Some of the most effective use cases include configuring Kubernetes, creating database queries, and building FastAPI backends.

It’s also a good idea to work on smaller libraries or limit the scope of work in one way or another. Large and complex projects increase the risk of unintended behaviour and it’s not uncommon that the AI delete something that cause problems in other places.

We love to use Cursor for building Python SDKs and other small machine learning libraries that we can reuse in multiple projects. One example is a library called next-cvat that automates and improves the workflow with image annotation in CVAT, which we use all the tine.

Final Words 💬

Generative AI has changed software development for ever, and the capability of platforms like Cursor will evolve quickly. As a small but specialized machine learning and software development team, we always try to make our work as effective as possible. Right now, generative AI presents the best opportunity and while it’s far from perfect, we believe that most problems comes from bad context, not a stupid algorithm.