Transitioning to Cursor: A New AI-Powered Coding Experience

Cursor AI significantly enhances coding efficiency with its superior context awareness and quick shortcuts over GitHub Copilot.

### Transitioning to Cursor: A Game-Changer in AI-Powered Coding
* 💻 After 9 years of coding experience, I transitioned from **Vim/Neovim** to **VS Code**, and finally to **JetBrains IDE**, specifically **WebStorm**, for **full-stack web development**.
* 🚀 Recently, I decided to try Cursor, the new AI-powered IDE, for two weeks, and I was genuinely **impressed with its capabilities** compared to GitHub Copilot and other AI solutions.
* 🔍 Cursor, built on the VS Code framework, offers a **familiar environment** and seamlessly supports **existing VS Code extensions**, making it **user-friendly** for those accustomed to VS Code.
* ✨ The two major improvements Cursor has over GitHub Copilot include a **superior user experience** and **new AI use cases**, allowing for **easier interaction with the code** and **contextual awareness**.
* 🔄 One standout feature is Cursor's ability to **predict the next line of code across the entire project**, significantly reducing manual coding efforts, unlike GitHub Copilot, which requires **more manual navigation**.
* ⚡ Although Cursor has remarkable AI functionalities, I still find JetBrains IDEs superior in terms of **Git UI and refactoring capabilities**, which I believe Cursor could improve upon.
* 🤔 Ideally, a combination of JetBrains' **robust features** with Cursor's **advanced AI functionalities** would create the perfect coding environment, enhancing **productivity and efficiency**.
* 💬 I encourage others to try out Cursor and share their experiences, as I believe it represents a **significant advancement in AI-assisted coding**.

I've been coding for the past 9 years, and for the first 3 years or so, I was a Vim/Neovim user. Then, the next 3 years, I was a VS Code user. Finally, for the past two years, I actually converted to being a JetBrains IDE user, particularly WebStorm, because I mostly do full-stack web development. But lately, there's been a lot of hype surrounding the new IDE on the block, Cursor, which is supposed to be the first AI-powered IDE built from the ground up. At first, I really didn't believe the hype because I was a Copilot user, and I was like, Um, Copilot's insane. How can I get much better than that? So, I went in to try out Cursor for 2 weeks on a free trial, and I walked away from this two-week trial really impressed with how much better Cursor is than GitHub Copilot and the other AI solutions out there. So, in this video, I'm going to walk you through my experience.

trying out cursor and why I'm actually going to be switching over to cursor over JetBrains and VS Code products out there. There are certain things that I definitely don't like in cursor that I prefer in a JetBrains IDE, for example, and we'll also get into that too. So now let's quickly transition into talking about what it's like using cursor. So cursor is pretty much built off of VS Code, so it's a very familiar environment if you are an existing VS Code user. And you can use any VS Code extension within cursor as well, at least the extensions that I had in VS Code. They have ported over to cursor very seamlessly. I've had no issues there. And if you're an existing GitHub Copilot user, cursor has the same exact experience there where, you know, as you're coding, it will then predict certain lines of code that will come out next. Now with cursor, there are two major improvements that it has over GitHub Copilot. Number one is the user experience of the AI being integrated.

into the product, and number two is actual net new AI use cases in VS Code. There are two main ways you interact with a GitHub Copilot. Number one is the way that they just predict the lines of code that you're going to write, and number two is with the GitHub Copilot chat extension that you also install, which is fine, but it does require a few clicks here and there to navigate around, copy and paste code to get everything into GitHub Copilot chat. Whereas in Cursor, when you highlight blocks of text, you immediately have that quick keyboard shortcut, either Command K or Command L, to either prompt the AI to generate code and write code for you, or to actually start chatting with that code instead. And then, as you chat with your Cursor code as well, you also have the option to chat within just the context of that one file, or you can actually chat with the context of the entire project. And I actually found Cursor to be the best contextually aware AI coding assistant compared to GitHub Copilot or Jet.

brains AI assistant, which I've actually been a little bit underwhelmed by. Don't quote me on this, but if I recall correctly, I do think GitHub Copilot and JetBrains AI assistant claims to ingest the context of your coding project into your code completion. But I haven't had the best experience doing that. There have been multiple times where I ask within GitHub Copilot chat or even Jet's AI assistant to generate some type of code using some existing component that I already have defined somewhere else in my project, but it kind of just fails to do so. Whereas with Cursor, six or seven out of the ten times, it correctly does find that other existing component that I'm referencing to. So, I find the user experience of Cursor to be just a lot snappier because you have these very quick keyboard macros to quickly start chatting with your code, asking the AI to start generating code. Whereas Copilot, technically, you can do the same thing.

but there does feel like there's a little bit more UI friction preventing me from using the AI. If the only advantages that cursor had over GitHub co-pilot were just quick little UI integrations and keyboard shortcuts, I wouldn't be making this video talking about it, and I also wouldn't be switching over to cursor as well. But what really sold me on switching over to cursor over GitHub co-pilot is a net new use case, which is your next line of code prediction. Now, what I mean by that is that we already know that GitHub co-pilot right now will complete your current line of code, but what cursor does really, really well is the fact that after you complete a certain line of code, it can then predict the next line of code somewhere else in the file or somewhere else in your project that you're probably going to write. A simple example of what this might look like in practice is, let's say you're refactoring your code, you're changing a function name or something, and then in

GitHub Code Pilot. When you change your function name, you still have to manually go and find and replace all of the function name references. Whereas with cursor, if you change that same function name, you will then see a prompt at the very bottom saying click tab to jump to this line. And when you click tab, it will automatically take you to each and every single reference of that function name in your project and rewrite that function name for you as you go along. So, there are lots of times where within cursor, I just write one line of code, and it's able to very reliably jump around the entire file where I'm writing code and update all the necessary logic that I'm trying to update. And that's really awesome because it significantly reduces the amount of code that I manually have to write because I can just autocomplete tons of code by just hitting the tab button over and over and over again. Let me walk you through a couple of video examples of what that actually looks like in practice. All right, so just for some context, all the code completion

examples you're going to see right now is for this open-source social media scheduling tool that I'm building called social q. It's essentially a tool that allows users to quickly upload one piece of content across all their YouTube, Instagram, and TikTok accounts. It's a very simple tool, and it is open source, so on cud a link to it down in the description below if you want to check it out. But I just want to provide that context before showing you these clips of the code completion that it's going to generate. So first of all, you can see in this video I have this one function called disable accounts based on video duration, and initially, it only has support for disabling accounts for a TikTok video if the video is too long. But I want to apply the same logic with Instagram and YouTube, so I just highlight the entire text, hit my keyboard shortcut of command K, and from there, I can then prompt it to just do the same for Instagram and YouTube. Very plain English, no technical lingo there, and it's able to successfully get the

entire context of that file and generate the same logic for my Instagram and my Tik Tok accounts, which is so crazy. And this video here is a good example of tap to predict that next line of code. As you can see that text right there down at the bottom, tap to jump, and when you hit it, it's going to be jumping me throughout my entire editor and declaring certain functions that are not declared. And then sometimes, depending on how the AI is feeling, if it's confident enough, it'll then also complete that function as well for you. In this case, you can see that it didn't, but I also blame the fact that this is on plain Wi-Fi, so my connection was kind of spotty. And here's another example of using cursor to generate code via prompting it. So I had my function disable accounts based on video size, and I just prompted to write code to get the Instagram, TikTok, and YouTube channels and disable the accounts based on the video sizing. And as you can see in the

initial code prediction. It uses this one property called Max file size, which doesn't seem to be defined. So then, you can actually ask a follow-up question or a follow-up prompt, and I do that where I say, It seems like Max file size doesn't exist. Can you please rewrite the entire code? And it is able to successfully generate the correct code referencing the correct property, which is called Max video size. Once again, really great code prediction in my opinion, way better than anything I've personally experienced with GitHub co-pilot. You can clearly see that cursor AI is way faster and way better at generating code compared to GitHub co-pilot, at least in my experience. I think it is. I'm personally writing code significantly faster with cursor than I ever did with K up copil, but that's also not to say that cursor is like the best IDE editor experience out there, and there's nothing wrong with it. No, there is plenty wrong with it. The big thing that I don't like about cursor is the fact that it is VSS code-based.

and I personally don't like managing VSS code extensions and all of that. I've already made a video in the past talking about why I don't like VSS code and why I ended up switching to using JetBrains products. But the big thing I don't like about VS Code is the fact that it starts off as an open canvas with very minimal customization added. You can then go and install all of your extensions, but I personally hate managing extensions. I hate looking for cool extensions. I optimize my developer experience strictly for the speed it takes to get a new machine and start coding as fast as possible in my regular developer setup. But the difference between VS Code versus JetBrains products is the fact that JetBrains products are very opinionated on how things are done and a lot more works very out of the box compared to VS Code. In my previous go-to JetBrains IDE setup, I had to install two extensions, whereas on VS Code, I would have to download like 15 or 20 different

extensions to get feature parity with my JetBrains IDE, and I found that kind of annoying. And there's also certain features within JetBrains editors that I wish VS Code and by proxy Cursor had. Number one being a great Git UI. I think JetBrains has a phenomenal Git UI, and I don't like the idea of having to pay for GitLens on VS Code. And I think JetBrains has a much better refactoring experience as well compared to VS Code. For those of you that aren't aware, if you're refactoring a certain line of code within JetBrains or a certain file, it'll detect all the other references of that particular piece of code within your entire project to make sure you're not making some breaking change in your codebase. For me, the most perfect editor would be a JetBrains editor that had that Cursor AI functionality, where you had those quick keyboard shortcuts, keyboard macros that immediately start editing code, generating code, chatting with code, as well as having the ability to tab line completion and tab to

predict your next line of code that you're going to write as well. If it had that cursor AI experience within the JetBrains IDE, I would be the happiest developer in the world. But that's probably not going to happen unless JetBrains, you do something about it. Please add that function. I need it. It'll make it so much better. So, try out cursor yourself and let me know what you think. And if you have tried out cursor, let me know how your experience was in the comments down below. Thanks for watching today's video, and I'll see you in the next one. Peace.

I Finally Tried The AI-Powered VS Code Killer | Cursor IDE Review

Your Average Tech Bro

My Transition to Cursor: The AI-Powered IDE

After 9 years of coding, I transitioned from Vim/Neovim to VS Code, then to JetBrains WebStorm, and finally tried Cursor for 2 weeks.

I was impressed by Cursor's superior performance compared to GitHub Copilot, offering a familiar VS Code environment and seamless extension integration.

Cursor's unique features, such as quick AI code generation and contextual chatting, set it apart as the best AI coding assistant I've used.

Cursor's AI assistant has a better user experience, with quick keyboard macros and a higher success rate in finding existing components for code generation.

The unique feature of Cursor is its next line of code prediction, allowing it to jump to and update all references of a changed function name in the project.

This capability significantly reduces the amount of manual coding required, making Cursor a more efficient option for code completion.

Social Q: An Open-Source Social Media Scheduling Tool

Social Q is a tool that allows users to upload content across YouTube, Instagram, and TikTok accounts simultaneously.

The tool's code completion feature helps users apply the same logic for disabling accounts based on video duration and size across all platforms.

It also offers a "tap to predict" feature and cursor-based code generation for added convenience.

Cursor AI excels in code prediction, quickly generating the correct code by referencing the right property.

The author finds Cursor's code generation faster and more efficient than GitHub Copilot.

However, the author dislikes Cursor's VS Code-based setup and the need to manage multiple extensions, preferring the more opinionated and out-of-the-box approach of JetBrains products.

Desired Features for a Perfect Code Editor

The speaker finds it annoying to use extensions for feature parity between VS Code and JetBrains IDE.

They appreciate JetBrains' Git UI and refactoring experience, wishing for similar features in VS Code.

The ideal editor would combine JetBrains' functionality with Cursor AI features, such as quick keyboard shortcuts and line prediction.