If you’ve been coding for a while, you’ve probably tried dozens of IDEs and editors. Each new tool promises to be the silver bullet that solves all your development problems. Most fall short.
When I first heard about Cursor AI, I was skeptical. “Great, another VS Code clone with some fancy autocomplete,” is what I thought. I couldn’t have been more wrong.
My First Week with Cursor: The Initiation Phase
My introduction to Cursor was like learning to drive an F1 car after years of riding a bicycle. The power was immediately apparent, but I wasn’t leveraging even a fraction of its capabilities.
I started with simple code completions and occasional questions about syntax. “How do I define a React component that takes these props?”, “What’s the best way to structure this API call?”. Basic stuff.
Even with this surface-level usage, I noticed my productivity climbing. The editor understood context in a way other AI tools didn’t. It wasn’t just pattern-matching; it genuinely seemed to grasp the architecture of my application.
But I was still in the kiddie pool of Cursor’s capabilities.
Discovering Cursor Rules: Teaching AI Your Development Style
The breakthrough came when I discovered Cursor Rules. Think of these as personalised instructions for your AI assistant—like training a new junior developer on your team’s coding standards and best practices.
Cursor Rules come in two types:
Project Rules: Specific to a single codebase, stored in
.cursor/rulesfolderGlobal Rules: Applied across all projects
But to apply the best rules for your project requirements, language and framework—You might have to put in some efforts, but here are a few things that made my process easier:
Refer to the rules that have been used by people in the Cursor Community for the same tech stack that you are using for your project. Here are a few popular links that I used for getting some quality Cursor rules—Cursor Directory, Awesome Cursor Rules.
Be clear with what you need from Cursor rules and what you don’t, if there is unnecessary stuff in the Cursor rules, that might cause issues in generation because of unwanted context.
Ask any of the existing LLMs to generate Cursor rules for you by giving the project requirements, tech stack, the libraries used, and the best practices that are being followed.
Pro-tip:You can even ask Cursor to do it by going through your codebase and updating the Cursor rules tailor-made for your project.
The results were immediate and striking. The AI wasn’t just helping me code faster, it was also helping me code better. The generated code looked like what we write in our project, following almost all of our established patterns and best practices.
The Model Matters: Finding My Perfect AI Partner
Different Models come with different capabilities, and Cursor offers several options. After weeks of experimentation, here’s what I have learned:
Claude 3.7 Sonnet: My go-to for most tasks. Great balance of speed and capability. Can maintain a good amount of context across chat.
Claude 3.7 Sonnet with Thinking enabled: When I need more complex reasoning or planning for a feature. Takes longer but produces better results for complex tasks.
GPT-4o: Excellent for explaining code and concepts, but I found Claude to be better for actual code generation and agentic capabilities.
Cursor-small: Perfect for inline chat and quick completions when I’m in a flow state.
I discovered that matching the model to the task made a huge difference. Need quick code completion? Cursor-small. Planning a complex feature? Claude with Thinking enabled. Different tools for different jobs.
Auto-Run Mode: When You Trust Your AI Co-Pilot
One Friday afternoon, I decided to experiment with Auto Run mode—Cursor’s feature that allows the AI to autonomously execute terminal commands and tools. I can also set up my allow/deny lists for the terminal commands (just to be on the safer side).
I asked Cursor to fix a failing test. I got up to grab coffee, and when I returned five minutes later, not only had Cursor fixed the test, but it had:
Run the test suite to verify the fix
Made additional refactoring to improve code quality
Run linters to ensure code-style compliance
What would have taken me, maybe around 30 minutes of focused work, happened while I was chatting with my colleagues in the pantry.
It felt like having a ‘pair programmer’ who kept working even when I needed a break. A game-changer for those tedious, repetitive tasks that drain your mental energy.
While it might seem like a productivity dream to have Cursor handle everything, you’ll often need to thoroughly examine the modifications with heightened attention—sometimes even requiring that double espresso from the pantry to stay focused. The true productivity gain comes from thoughtful collaboration with the tool, not complete delegation.
From Reactivity to Strategy: The Planner-Executor Pattern
The most profound shift in my workflow came when I implemented a custom Planner-Executor pattern with Cursor rules.
Here’s how it works:
Planner Mode: When activated, the AI doesn’t write any code. Instead, it creates a detailed plan for implementing a feature, breaking it down into discrete tasks, identifying potential edge cases, and asking clarifying questions.
Executor Mode: Once the plan is approved, I switch to this mode, and the AI methodically works through each task, implementing the code according to the plan.
This approach transformed how I tackle complex features. Instead of diving straight into code, I now spend 10 minutes with the Planner, getting a comprehensive roadmap. The resulting code is more thoughtful, better structured, and has fewer bugs.
This approach is implemented through custom Cursor rules that activate “Planner Mode” whenever I include the keyword plan in my prompt. When triggered, Cursor thoroughly examines the codebase, articulates its assumptions, and poses clarifying questions before taking action. I’ve designated a scratchpad.md file as the central communication hub the Planner documents comprehensive implementation strategies here, while the Executor systematically addresses each task, marking them complete as it progresses through the plan. This structured handoff between planning and execution phases ensures nothing gets overlooked.
I even enhanced this with a confidence score system—the AI rates its confidence in understanding the requirements, and if it’s below 90%, it asks more questions until it reaches that threshold.
The results speak for themselves: fewer revisions, cleaner code, and more predictable timelines.
Lessons from the Trenches: What I Wish I’d Known Earlier
After months of daily use, here are the insights I wish someone had shared with me on day one:
Context is king: Use the @ symbol generously to reference files, folders, and code snippets. The more context you provide, the better the AI performs. Want it to understand your React component structure?
@folder src/componentsbefore asking for a new component.Commit before switching chats: Cursor maintains checkpoints of your code in each chat. If you switch chats without committing, it might revert to a previous checkpoint. I learned this the hard way!
Index your documentation: For third-party libraries, you can index their documentation in Cursor. This dramatically improves the AI’s understanding of library APIs and patterns.
Model selection matters: Don’t just stick with the default always. Different tasks benefit from different models. I use Claude Sonnet 3.7 Thinking for planning and Claude 3.7 for execution. (Spoiler Alert: This might also become irrelevant as time passes by)
Maintain a “lessons learned” file: I created a markdown file where Cursor systematically records insights about my codebase’s architecture, patterns, and best practices. Through carefully crafted rules, I’ve programmed Cursor to continuously update this knowledge repository and automatically inject these accumulated lessons as context for future conversations. Over time, this has become an invaluable knowledge repository that helps the AI understand my preferences.
The Human-AI Partnership: Finding the Balance
The most important lesson I’ve learned is that Cursor works best as a partner, not a replacement. The magic happens in the collaboration between human creativity and AI capability.
I think of it like playing jazz with an AI musician. I set the melody and direction, and the AI improvises within those constraints, sometimes surprising me with elegant solutions I wouldn’t have considered.
This partnership has changed how I approach programming. I spend more time on architecture and design decisions, while the AI handles implementation details. It’s made coding more enjoyable and creative, focusing on the “why” rather than the “how.”
Looking Ahead: The Future of AI-Assisted Development
As I look to the future, I’m excited about the possibilities. The rapid evolution of AI models will continue to make tools like Cursor more powerful. The lines between “programming” and “instructing” will blur further.
But one thing is clear—AI won’t replace developers. It will transform how we work, eliminating the tedious aspects of coding and amplifying our creativity and problem-solving abilities.
