Get up, Copilot has added a free tier for Visual Studio Code users and in the last year has caught up massively to

Cursor's feature set, but is it as good as Cursor? Let's find out. The first thing we need to look at is the "Edit with"

Copilot" feature. This gives you the ability to read and write from multiple files in your codebase at a time. You can

even use a number of context tools, such as the codebase modifier, to automatically search and find relevant

files for you as it generates. You'll see the code updates stream in, and then you can review them one by one and accept or

discard them all in a click. In this case, I asked Copilot to add to our admin API

the ability to read and write to the comments collection, and in short, it didn't do a good job. It simply didn't

find the correct files or make the correct updates. This is a prompt I've seen successful pretty much every time

with Cursor and Windsurf. I tried it multiple times, and it never worked correctly. To make things worse, when you

use the codebase modifier to pull files automatically so you don't have to manually list them as context, the search

can be incredibly slow. I've waited ages just for the search to complete, and then sometimes I just get an error and it

doesn't work at all. This time, I'm trying a much simpler prompt: fix a bug in our existing site so that we do client-side

routing correctly instead of server-side. This is something that even Tabnine was able to do correctly; it's never really

failed with Cursor and Windsurf. And first, it's taking an eternity with GitHub Copilot. This `content.tsx` file

has been updating forever. I actually think it's broken right now, but I can already tell it didn't do the right

The correct solution is just to set this no-client-side-routing variable to false. Pretty much every tool

is able to pick that up. Yet, get up Copilot updated tons of files and code; it simply just completely got stuck on

content.tsx, and it's in a broken infinite loading state. I was really excited to try this feature, and the UX

seems pretty good, but I've been disappointed by its quality, bugginess, and slowness, and I really just cannot

see myself using this day-to-day. But hey, technically this feature is in preview, even though it's enabled by default, so

maybe with a little time they'll make this better. To me, the multi-file editing agent feature is the single most

important feature of Cursor and Winsor. Note that I am using one other new feature from GitHub, which is you can

now choose what model you want, which includes Claude 3.5, Sonnet, which is undoubtedly the best model today for

coding. It's what Cursor and Winsor use by default, and I'm using it so we can

do an apples-to-apples comparison on code generation. If you're curious if, when using GPT-4, the default model that's

not in preview, if I got better results with even the simple prompt about client-side routing, unfortunately the answer is

no. Get up Copilot is still trying to update files that don't even make sense; like it's removing `getStaticProps`; it's

also listing files in this working set that apparently didn't even update. So the AI regenerated this file but didn't

actually change anything at all in the file. There's no diff, so I'm honestly just hitting UX problems all over the place.

I also gave the same prompt to try with other models; it's not any better; it's not

doing it right, and it's just wiping out our JavaScript for some reason. I also tried with `ow` and preview, and it's still

not doing anything. It's really, really broken for me for some reason. Let's compare that to Cursor, where I like to

use the agent mode by default, so I don't have to tag the codebase. It automatically searches the codebase and finds relevant

files. The codebase search is incredibly fast compared to GitHub, and the output starts streaming a lot sooner, too. But

most importantly, Cursor is actually doing the correct thing and identified the admin GraphQL API. It's adding the models and resolvers that I need and hooking up

this to the API correctly. I've had the same good results with this with Windsurf as well. Now let's try fixing the

routing bug with Cursor. This one uses a smaller codebase, so I really thought GitHub Copilot would be able to do

this one, and Cursor does it exactly right. It finds a variable, it flips the boolean; it's a really simple fix, but

hey, maybe it was unfair for us to compare Cursor's best feature to one of GitHub Copilot's newest features. Let's

touch on another couple of great features that Copilot has added. One of my all-time favorite AI features is AI in the

terminal. Just hit Command-E; the AI will spit out results. Hit Command-Enter to run it. Now you don't actually need to be

a bash wizard to pretend you're a bash wizard. Cursor has basically the same thing, except it hijacks Command-K in the

terminal, which drives me crazy. I hate that. I like Command-E better. One other cool feature GitHub Copilot has is the

ability to autogenerate a commit message, which it does pretty nicely by default. When Cursor generates commit messages, it

can be a little bit more verbose, which is not quite my style, but it's fine. I can just delete the rest of this stuff.

Another nice thing that GitHub Copilot has now is custom instructions by adding a `GitHub Copilot instructions.md` file.

It's basically the equivalent of cursor rules. GitHub Copilot supports inline autocomplete; it was frankly the

OG of AI-driven inline autocomplete, and it does a good job, but Cursor takes things even further by being able to

suggest inline updates to multiple lines. You can hit tab to complete, as well as the standard usual stuff, you know, tab to

complete works fine. Overall, though, it's the composer that makes Cursor really shine. As a result, I want to do one more

test to see if Copilot can compete here. Instead of taking an existing code base, I'm going to start with something new

from scratch. Let's simulate a real-world end-to-end workflow with a bare minimum code base and see how they compare. I'm

going to start by making a brand new, fresh Remix app, and I'm going to take this design in Figma and convert it to

code with Builder. I'll grab the CLI command and I'm going to paste it in the Cursor terminal. We're now generating the

code for the design, matching the style and components and theme of our code base. And now I've got my beautiful

design in code. I'm going to ask Cursor to replace this placeholder with a table of users. So I said, "replace the table

placeholder with a table of users from `randomuser.me`". So let's see if it can find the right location, generate a UI,

including API data. All right, looks like it did great! It found the right location and it added the table, even with a nice

hover effect. Now let's try the same prompt over with GitHub Copilot. We need to manually tag that we need to include

the code base as well. Copilot, again, takes a lot longer, and it didn't even do it correctly; it didn't even include it.

where it's supposed to go. Honestly, this code would have never worked anyway; it's totally incomplete. Let's try again. This

time, specifically manually adding the file we want that has the user table placeholder, and wait a super long time

again. And thank goodness it did something this time! It did add a table. Doesn't look quite as nice or have the

images, but that's fine. The code's also not as good. Cursor put the table into its own component and file, whereas VS

code just added all this stuff inline, which is just kind of messier. But the thing I think that's more clear to me

now is: don't trust GitHub Copilot's indexing. Always manually tag files when you want to use them in the multi-file

editing interface. For me personally, I hate doing that; I feel like it's a waste of my time. I love Cursor's

agent that I can just type things, it figures out what it needs to see, what it needs to do, and just does it reliably

with surprisingly clean and functional code. Overall, though these are two feature-packed AI coding assistants, for me, I'm willing to pay $20 a month, and so

I'm more than happy with Cursor, and I see no reason here to switch to GitHub Copilot. But that said, GitHub Copilot

has a free tier, and while you may hit the free tier limits after not long and need to upgrade anyway, plans start at

just $10 a month. In my biased opinion, you should pay $20 for Cursor. Cursor saves me hours of coding if you learn to

use it well, and you value your time at all. I think Cursor is more than worth it. If you want a lower-cost option that's

similarly good and feature-rich, Tabnine is really, really good too. But hey, I'd personally still take GitHub

Copilot plus VS Code over some IDEs like Zed or IntelliJ. For a full rundown of GitHub Copilot versus Cursor, take a look

at our full article in the builder blog, and in the blog you'll also find comparisons with Windsurf, Devon Klein,

and a bunch of other AI tools. But ultimately, what matters most is: what do you prefer? What is your favorite

favorite AI tool? Let me know in the comments, and I'll catch you next time.

Github Copilot vs Cursor: which AI coding assistant is better?

Scripts