Cursor

1. Agent: Hand the task over to AI
   This is one of Cursor’s core features. With older AI coding tools, you’d usually paste in some code and ask, “How should I change this?” Cursor goes further: you can just describe the outcome you want and let it find the relevant code itself.
   For example:
   “Make this API asynchronous and update everywhere that calls it.”
   That kind of task is a good fit for an Agent because the annoying part usually isn’t changing one line—it’s figuring out what else depends on it. Cursor can handle a lot of that searching and repetitive editing for you.
2. Run multiple Agents in parallel
   For bigger tasks, you can have several Agents working at the same time. One might handle the backend, another the frontend, and another the tests. You can also have different Agents try different approaches and compare the results.
   It sounds powerful, but you don’t need it for everything. If you’re fixing a small bug, spinning up several Agents is overkill. It makes much more sense when the work can actually be split into separate pieces.
3. Understand the whole codebase
   I actually find this more useful than simply having AI write code.
   When you pick up an unfamiliar project, you can ask things like: “Where is the login logic?” “What parts of the project depend on this function?” “How does authentication work here?” Cursor answers based on the codebase, not just the file you happen to have open.
   Sometimes understanding the project first is more valuable than having AI start coding right away.
4. Cursor’s own models and model switching
   Cursor has its own Composer family of coding models, and you can also use other models. In practice, different models are better at different kinds of work. Some are faster and feel better for everyday edits, while others are more useful for longer or more complicated tasks.
   Most people probably don’t need to obsess over model rankings. After using Cursor for a while, you naturally get a feel for which model works best for which job.
5. Cloud Agents, terminal, and browser
   Cursor isn’t limited to your local editor anymore. Some tasks can be handed off to Cloud Agents, the terminal can run commands directly, and for web projects, Agents can work with the browser to check what the page actually looks like.
   That gives you a pretty natural loop: Edit → Run → Check → Fix.
   A lot of that used to mean constantly switching between tools yourself. Now, at least part of it can be handled by the Agent.
6. Team features
   Companies can manage members, billing, rules, and permissions in one place. Team and enterprise plans add things like admin controls, audit logs, and organization-wide rules.
   That’s one of the clearest differences between Cursor and a simple personal AI coding plugin: it’s increasingly being built as a proper development tool for teams, not just something an individual developer installs.

What’s It Actually Like to Use?

The biggest improvement with Cursor isn’t the flashy “AI builds an entire app for you” demo.

It’s all the small, annoying bits of work that suddenly take less time.

I tried something like this on a small Python project:

“Make this function async and update every place that calls it.”

Doing that by hand isn’t difficult, but you still have to find every reference, update them one by one, and make sure you didn’t miss anything.

Cursor handles a lot of that grunt work for you. It finds the relevant files, updates the call sites, and gives you a first pass to review.

That’s where it feels genuinely useful.

The problems start when the task gets more complicated.

I once asked it to refactor a module that touched several files. The result looked fine at first glance: the function names made sense, the interfaces lined up, and most of the right files had been changed.

Then I ran it and got an error.

It turned out one part of the code was still calling an old interface. The tricky part was that nothing looked obviously wrong.

That’s probably the biggest catch with AI coding right now.

When it makes a mistake, the code doesn’t always look bad. Quite often it looks perfectly reasonable—clean formatting, sensible names, everything in the right place—while the actual bug is buried in the logic or dependencies.

So I tend to let Cursor do the first pass, then I check the diff and run the tests myself.

Letting it run completely unsupervised is where things can get risky.

Are Multiple Agents Really That Useful?

They are useful, just not as magical as the demos make them look.

If a feature can be split into separate pieces—say the API, the frontend, and the tests—running several Agents at once can definitely save time.

But they still have to come back together at the end.

Sometimes one Agent makes an assumption about an interface that doesn’t quite match what another Agent did, and you still have to sort that out manually.

So I’d think of multi-Agent mode as a way to parallelize part of the work, not as suddenly having a team of fully independent engineers you never need to manage.

What I Like About It

Cross-file edits save a lot of time.
If one change touches several files, Cursor can usually track those places down without you jumping around the project yourself.

It’s great for unfamiliar codebases.
You can ask about the project structure or how different parts connect, which is often much faster than tracing everything manually from the entry point.

It cuts down on repetitive work.
Writing tests, updating APIs, or applying the same refactor across a codebase are all good jobs to hand off to AI first.

VS Code users will feel at home.
You don’t have to learn a completely different editor just to get the AI features.

The Agent workflow feels fairly complete now.
Local editing, cloud tasks, the terminal, and browser tools are starting to work together as one workflow instead of feeling like separate add-ons.

What I Don’t Like

The biggest issue is still simple: it gets things wrong.

And the more complicated the task, the less you should trust “done” to actually mean done.

Cost is another thing to keep an eye on if you use Cursor heavily. Agents can read a lot of context and make multiple model calls, so occasional use and all-day use are very different in terms of consumption.

There’s also more going on in the product now, which can be a little overwhelming at first.

A while ago, you mostly needed to know Tab completion and chat. Now there’s Agent, Plan, Cloud, model selection, Rules, Skills, and more.

None of it is especially hard to learn, but Cursor definitely isn’t just “autocomplete with AI” anymore.

Experienced developers

This is probably who Cursor works best for.

If you already have a good sense of how the code should be written, you’re also much more likely to notice when the AI goes off track. In that case, Cursor can save you a lot of time on searching, editing, and repetitive work.

Small teams and startups

When you have a small team and too much to do, Cursor is useful for the kind of work that still needs to get done but isn’t worth spending hours on manually.

It’s especially handy for MVPs, demos, and internal tools, where getting something working quickly often matters more than polishing every detail from day one.

People who often inherit old codebases

This is actually one of the use cases I’d recommend most.

A lot of the time, the hardest part isn’t writing new code. It’s figuring out:

“How does this thing even work?”

Cursor is good at explaining project structure and tracing how different pieces connect, which can save you from opening file after file just to follow one call chain.

Developers whose English isn’t great, but who know how to code

Cursor can help here too.

You can ask it to explain English documentation, error messages, or third-party library docs right inside the editor, instead of constantly jumping back and forth between the browser and your code.

When You Shouldn’t Rely on It Too Much

Complete beginners

That doesn’t mean beginners shouldn’t use Cursor.

The problem is that if you don’t yet understand why the code is written a certain way, it’s easy to keep hitting Accept until the program works without really learning what happened.

Even worse, when the AI gets something wrong, you may not notice.

For beginners, Cursor is better as an assistant than as something that does the whole job for you.

Projects where reliability really matters

AI tools can still be useful in finance, healthcare, infrastructure, and other high-stakes systems.

But testing, code review, security checks, and the usual engineering safeguards still matter just as much.

Cursor can speed things up. It doesn’t mean AI-generated code gets to skip the normal software engineering process.

Final Thoughts

I wouldn’t describe Cursor as “software that writes code for programmers.”

It’s closer to a tool that takes some of the work you would normally do yourself and lets AI take the first pass.

Sometimes it gets it right in one go. Sometimes it gets you 70 or 80 percent of the way there. And sometimes it confidently makes the wrong change.

As long as you can judge the result yourself, though, it can save a lot of time.

For an experienced developer, the real value of Cursor isn’t that you never have to code again. It’s that a lot of the small, repetitive work no longer has to start from scratch every time.

As for SpaceX, the more accurate wording right now is that a deal has been signed and the acquisition is expected to close later, rather than saying Cursor is already a wholly owned SpaceX subsidiary.