Cursor After Three Months: Whats Actually Good and Whats Overhyped

Three months ago I switched my dev environment from VS Code to Cursor. I haven't switched back.

Not because Cursor is perfect. Because some things, once you've used them, you genuinely can't go back.

But I'm not here to hype it up either. This is what I've actually found — what's genuinely good, what's not as great as people say, and the stuff I've figured out along the way.

Cursor vs. VS Code with Copilot — What's Actually Different?

A lot of people ask: "Isn't Copilot also AI coding? Why switch editors?"

I thought the same thing. Seemed like just VS Code with an AI plugin. After actually using it, I realized "plugin" vs. "built-in from the ground up" is a real difference.

With Copilot, you're writing code and it quietly offers completions. You're still in charge; it's an assistant.

With Cursor, it feels more like having a coworker sitting next to you. You describe what you want, it writes it. You're unhappy with a piece of code, it rewrites it. You hit a bug, it searches your entire project to find the cause.

This difference is most obvious when you need something that touches multiple files. Like "switch our auth from sessions to JWT." Cursor can update several files at once. Copilot mostly works within the file you currently have open.

That doesn't make Copilot bad — they just have different design philosophies. If you want quiet completion while you code, Copilot is fine. If you want AI deeply involved in the process, Cursor's experience is more complete.

@References: The Feature Worth Taking Time to Learn

In Cursor, you type @ to reference files, functions, classes in your project. It sounds simple. Using it well vs. not using it is the difference between night and day.

Here's a real example from last week. I was writing a new API controller, and our project has a specific pattern: unified error handling, particular log format, fixed response structure.

If I just said "write me a product management API controller," it would write something generic that doesn't match the project's conventions.

Instead I said: "Following the code style in @controllers/userController.ts, write @controllers/productController.ts with basic CRUD operations. Match the error handling in @utils/errorHandler.ts."

The result matched the project almost exactly. Minimal changes needed before I could use it.

The more specific your references, the closer the AI output fits your project. Not referencing vs. referencing carefully sometimes feels like using two different tools.

Cmd+K and Cmd+L: Two Shortcuts That Cover 90% of What I Do

When I first started I was trying every feature. Eventually I realized I use two shortcuts almost exclusively.

Cmd+K: Select some code, press it, describe what you want changed in natural language. "Add error handling to this function." "Make this async." "Optimize this loop."

For straightforward changes — adding type annotations, error handling, renaming variables — it's fast and reliable. For complex logic changes, sometimes it drifts from what you intended, so you need to review.

Cmd+L: Opens a chat panel where you can talk to AI about your entire project. "What does this file do?" "How does the login flow work?" "Help me implement feature X."

My most common use case: onboarding onto unfamiliar code. Instead of opening dozens of files and piecing things together, I ask Cursor "explain the overall project structure and how data flows through it." Within minutes I have a framework understanding that used to take hours of reading.

The quality of the chat output depends heavily on how you ask. Vague questions get vague answers. Specific ones — targeting a particular file or module — get much better results.

About Cursor's Autocomplete

Cursor's autocomplete feels different from VS Code's IntelliSense. VS Code completes function names, variables, parameters — it "completes." Cursor often writes entire lines or blocks at once. It's more like it's guessing what you'll write next.

Sometimes it's eerily accurate — I finish writing a function signature and it's already written the whole body. Sometimes it's completely off and I delete it and do it myself.

My approach: when it's right, accept it. When it's not, ignore it. Don't force yourself to use it. Treat it as an assistant that occasionally has a good moment, not something you depend on completely.

A Workflow That Saved Me Real Time

One thing that changed significantly after switching: writing unit tests.

I used to hate writing tests. Code is done, now you have to think through every edge case for every function and write test cases for each one. Cursor made this much less painful.

The process is simple: open the source file, tell Cursor "write unit tests for all public functions in this file, using the project's existing test framework, covering normal cases and common edge cases."

The first version sometimes has issues — mocks that don't quite match the project, or edge cases it didn't think of. But the structure is right, and a few tweaks make it workable.

The time saving compared to writing from scratch is substantial.

The Thing You Have to Remember: AI-Written Code Isn't Runnable Without Review

The most important lesson from three months: don't just run AI-written code. Think about it first.

I've hit these problems more than once:

It misunderstands project context. Sometimes it references deprecated utility functions or uses patterns that don't fit the tech stack. It's not malicious — it just doesn't deeply understand the whole project.

Edge cases get missed. Normal inputs are handled fine. But null values, extreme inputs, concurrency — it sometimes glosses off those.

It's confidently wrong. This is the one to watch for. AI gives code with total certainty, but it still gets things wrong. Especially with math, date handling, regex — anything requiring precision, check it yourself.

My rule now: AI writes it, I review it, I run it, I confirm it works — then I commit. Not blind trust. "Trust but verify."

Is the Free Tier Enough?

Cursor's free tier has monthly AI usage limits. Light use — writing code occasionally, small edits — is fine. But if you're generating lots of code daily or using Cmd+L frequently, you'll run out.

Pro is $20/month. For me it's worth it. The time I save translates to far more than that. But this depends on your situation — if you only use AI coding tools occasionally, start free and upgrade when you're sure you need it.

One more thing: Cursor supports using your own API key. If you have OpenAI or Claude keys, you can plug them in and not burn through Cursor's quota. Good option if you already have keys.

On the "AI Will Replace Programmers" Question

Every time a new AI tool drops, there's a wave of "programmers are obsolete" discourse. After using Cursor for three months, my take: it's not replacing programmers. It's changing what programmers spend their time on.

Before, a developer's time went mostly into implementation — translating designs into code, writing business logic, debugging details. Now AI handles a chunk of that, and developers can spend more time on design and decisions — system architecture, solution choices, logic reasoning.

But design, decision-making, spotting problems before you start coding — AI is still far from that. An experienced developer can sense the uncertainty behind a requirement, can tell which approach has more pitfalls before writing a single line. That's not something AI can autocomplete.

So my prediction: AI tools make good developers more productive and help less experienced developers get closer faster. But "closer" doesn't mean "replaced."

Should You Switch?

If you're on VS Code with Copilot and it's working for you, no urgent need to switch.

But if any of these sound like you, it's worth trying:

• You frequently need to understand new or unfamiliar codebases
• You write a lot of repetitive code (CRUD, boilerplate, config files)
• You like the idea of talking to AI to explain and modify code
• You're willing to spend a little time adapting to a new workflow

Cursor isn't magic. It won't replace your understanding of code. But it's a tool that genuinely reduces repetitive work — as long as you take its output seriously and don't accept everything blindly.

Download the free version, try it on a real small project. Whether it's right for you, you'll know after using it.