How I effectively build medium-large project with Cursor. No magic.

I'm currently building a project with Next.js, FastAPI, Supabase, a shared package for type safety, Bash scripts, Terraform and Ansible for automated VPS provisioning, 3 external APIs, Docker, BullMQ for job queuing, and more. The MVP is scheduled to launch in a few weeks.

I can confidently say that Cursor has been a game changer, multiplying my productivity by at least 10x. I barely write code anymore — I mostly read it (sometimes just skim it) but I very carefully read all the descriptions and recaps that the LLM produces.

**The development workflow is everything**. I don't rely on Cursor or LLMs to "do my job" — it's an entirely different way of working. Honestly, I find the whole "*vibe coding*" trend overrated (or maybe just misunderstood). Cursor *should not* and *cannot* do your job the way you were doing it before AI. It's a new way of working.

You should see it as a **collaboration**, a kind of pair programming with a very special assistant — one that has some amazing powers but also real limitations.

For example: if you rely on AI to manage a complex codebase — with workflows, methods, and types spread across multiple interconnected files — it turns into chaos! But if you need to write a function that expects complex parameters, handles all kinds of errors, queries databases and APIs, and returns a well-formed, type-safe JSON, the process becomes a breeze. What used to take 3 hours can sometimes be done in a few seconds with AI. Add to that the ability to fix linter errors instantly, and you have a real turning point.

**So, how do you work efficiently with it?**

Imagine you hired a real-life assistant. Three things would become crucial:

* Get to know your assistant’s personality, strengths, and limits.
* Set up a well-structured organization for your two-person team.
* Focus on the quality of your communication.

Your codebase must be extremely well-organized and self-explanatory. You have to apply best practices like separation of concerns, clear naming conventions, and thorough documentation. It should be predictable — when you start building a feature, you should know exactly where every piece of code belongs. And for that, *you* have to know your codebase. Even with a million-token window, AI won’t save a messy or inconsistent codebase.

**Prepare**

Define and document your coding patterns early. For example, I have a clear backend structure for every resource:

* Route endpoints: API entry points
* Resource service: orchestrates workflows (no direct API or data manipulation)
* Resource actions: API calls and data manipulation
* Shared schemas and types

I document this in a `rules/backend-patterns.mdc` file, and Cursor includes it whenever it builds backend features.  
I also maintain a [`supabase-structure.md`](http://supabase-structure.md) file that a script automatically updates whenever the database schema changes.

Remember: your "rules" should evolve, and Cursor can help you maintain them using the `/Generate Cursor Rules` function.

There are no magic rules or magic prompts. I don't believe in that.  
*You* are the architect. AI can help you build your architecture, but at the end of the day, it’s still your job.

**Plan, Plan, Plan**

To get real efficiency, don't just plan features and tasks (although that's already good). You need to *precisely* plan the workflow for every feature you build:

* What types will you define?
* Which methods?
* Which database updates?
* Which files will you use?

Don't try to do all this planning upfront at the beginning of the project — it's normal for plans to evolve as complexity grows. Instead, plan carefully at *each step* of development. And don’t ask AI to write any code until you both fully understand the plan. I ask Cursor to write the plan in a MD file that can be referenced later in the same or a new conversation.

The beauty is: you don't have to write the plan alone. You *co-write* it with AI. It will help you remember things, suggest solutions, or even correct your approach.

Don't start coding until you're both convinced the plan is consistent — even for very granular tasks.

**Use Examples**

One of AI’s greatest strengths is recognizing and replicating patterns.  
If your codebase is well-organized and your patterns are clearly documented, you can feed AI examples of how things are done, and it will reproduce them very efficiently.

For example:  
*"Build the endpoint for resource X, following the general backend patterns and using resource Y as a model."*

**Put the "Cursor" in the Right Place**

One big challenge when developing with AI is deciding the granularity of what you ask.  
At the start of a project, you can go wide: ask AI to build a whole feature.  
As the project grows and gets more complex, you must become more granular: a feature, a part of a feature, a class, a function, a line of code.

Where you "*put the cursor*" — how much you delegate at once — is *the real challenge* to go from chaos to efficiency.

**Conclusion**

False beliefs and frustrations about AI mostly come from false expectations.  
If you thought AI would just "do your job" for you, that’s complete nonsense. It’s pure fiction.

You have a powerful new tool. But it demands that *you* adapt — that *you* change the way you think and the way you build software. It’s not about working harder; it’s about working differently, and if you do it right, it’s truly revolutionary.

Happy pair-coding!