Why I’ve Been Enjoying Cursor as My AI IDE

Artificial intelligence has changed the way developers work, but not every AI tool genuinely fits into a real development workflow.

Some tools feel impressive in demos but awkward in day-to-day use. Others are useful for one-off snippets, but fall apart once you need to work across a proper codebase with context, structure and existing conventions.

Since it was released, I’ve been using Cursor, and I’ve found it genuinely useful.

Not as a replacement for understanding the code. Not as a magic button that does everything perfectly. But as a development environment that helps me move faster, think through problems, and reduce repetitive work that often slows projects down.

What is Cursor?

Cursor is an AI-powered code editor built around the idea that artificial intelligence should be part of the development workflow, not something bolted on afterwards.

It feels familiar if you already use modern editors, but the difference is how deeply the AI assistance is integrated. You can ask questions about your codebase, generate changes, refactor sections, explain unfamiliar logic, create plans for complicated tasks, and work with an AI agent that understands the project context.

The official Cursor documentation now covers features such as Agent mode, rules, MCP, skills and the CLI, showing that it has grown beyond simple autocomplete into a much broader AI development environment.

Why it has worked well for me

The biggest thing I like about Cursor is that it fits naturally into how I already build software.

I work across projects using tools like Next.js, TypeScript, Tailwind, APIs, databases, authentication, CMS integrations and various automation workflows. In that kind of environment, context matters. A generic AI answer is not enough. The tool needs to understand the structure of the project, how files relate to each other, and what the existing implementation is trying to achieve.

That is where Cursor has been helpful.

Instead of copying code into a separate chat window, explaining the whole project manually, then trying to merge the answer back in, I can work closer to the code itself. I can ask for changes, review the output, tweak the approach, and keep control of the final result.

It does not remove the need for engineering judgement, but it does make the process smoother.

The CLI is one of my favourite parts

One of the parts I have enjoyed most is the Cursor CLI.

The official CLI documentation describes it as a way to code with Cursor directly from the terminal. For me, that is a big deal because a lot of development work already happens in the terminal: running commands, checking logs, installing packages, reviewing Git changes, running tests, debugging builds and working through project tasks.

Having AI assistance available in that environment feels practical.

It reduces context switching. It means I can stay closer to the workflow I am already using. Instead of jumping between multiple apps, browser tabs and chat windows, I can use AI support in the place where the work is happening.

The Cursor CLI also supports more advanced usage such as scripting, automation, headless workflows, shell mode and MCP integration, which makes it more than just a simple chat-style terminal tool.

It is useful, but it still needs a developer in control

The important point with tools like Cursor is that they are not there to replace good software engineering practices.

You still need to review the code.
You still need to understand the architecture.
You still need to check edge cases.
You still need to run tests.
You still need to think about security, performance and maintainability.

AI can produce code quickly, but speed is only useful if the output is correct and maintainable.

That is why I see Cursor as a productivity tool rather than a replacement for developers. It helps with the heavy lifting, but the responsibility still sits with the person building the software.

Used properly, that is exactly where it becomes valuable.

Where I find it most helpful

For me, Cursor is particularly useful for:

• exploring unfamiliar parts of a codebase
• planning implementation steps
• refactoring repetitive code
• generating boilerplate
• explaining existing logic
• writing tests
• improving TypeScript types
• debugging errors
• working through CLI-based development tasks
• making small but consistent changes across multiple files

These are not always the most glamorous parts of development, but they take time. Anything that helps reduce friction here can make a real difference over the course of a project.

Why I think developers should try it

What I like about Cursor is that it feels like a proper developer tool.

It is not just a novelty. It is not just autocomplete with a nicer interface. It is starting to feel like an environment built around how modern software development is changing.

AI-assisted development is becoming normal very quickly. The question is no longer whether developers will use AI tools. The better question is how we use them properly, safely and effectively.

For me, Cursor has been one of the better tools in that space.

It works well, the CLI is genuinely useful, and it fits nicely into the way I already build software.

Final thoughts

I do not think AI tools remove the need for strong technical knowledge. If anything, they make it even more important.

The better you understand software development, the better you can guide the AI, review its output and use it in a way that actually improves your workflow.

That is why I have enjoyed using Cursor. It helps me move faster without feeling like I am giving up control of the code.

For developers, technical founders, or anyone building software regularly, I think it is worth trying.

Disclosure: The Cursor links in this article are referral links.