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?

Steve (Builder.io)

GitHub Copilot은 무료 티어를 추가하고 기능 면에서 Cursor를 따라잡았지만, 멀티 파일 편집 기능과 코드 생성 품질에서 Cursor에 비해 아쉬운 점이 있다.

Cursor는 빠른 코드베이스 검색과 정확한 코드 생성 능력으로 개발 생산성을 높여주며, 특히 에이전트 모드를 통한 자동 코드베이스 분석 및 수정이 강점이다.

전반적으로 Cursor는 유료이지만 개발 시간 절약 효과가 커서 투자 가치가 있으며, GitHub Copilot은 무료 티어를 제공하지만 기능 제한이 있을 수 있다.

🤖 깃허브 코파일럿 vs 커서: 주요 기능 비교

깃허브 코파일럿이 Visual Studio Code 사용자에게 무료 티어를 제공하고 지난 1년간 기능 면에서 커서를 따라잡았지만, **실제로 커서만큼 좋을까요?** 이 글에서는 두 AI 코딩 어시스턴트를 비교합니다.

📝 "Edit with Copilot" 기능의 문제점

코파일럿의 "Edit with Copilot" 기능은 코드베이스 내 여러 파일에서 동시에 읽고 쓸 수 있게 해주지만, **실제 사용에서 몇 가지 문제점이 드러났습니다.** 예를 들어, 관리자 API에 댓글 컬렉션 읽기/쓰기 기능을 추가하는 데 실패했으며, 올바른 파일을 찾거나 업데이트를 수행하지 못했습니다.

코드베이스 수정자를 사용하여 파일을 자동으로 가져오는 기능도 매우 느리거나 오류가 발생하는 경우가 많았습니다. **클라이언트 측 라우팅 버그 수정과 같은 간단한 작업조차 제대로 수행하지 못했습니다.**

심지어 GPT-4 모델을 사용해도 결과는 개선되지 않았으며, **파일 업데이트가 멈추거나 불필요한 코드를 삭제하는 등 UX 문제도 발생했습니다.**

🚀 커서의 강점: 코드베이스 검색 및 정확성

커서는 에이전트 모드를 통해 코드베이스를 자동으로 검색하고 관련 파일을 빠르게 찾아냅니다. **관리자 GraphQL API에 필요한 모델과 리졸버를 정확하게 추가하는 등 코파일럿보다 훨씬 나은 결과를 보여주었습니다.**

클라이언트 측 라우팅 버그 수정에서도 커서는 간단하게 변수를 찾아 부울 값을 변경하는 정확성을 보여주었습니다. **이는 코파일럿이 어려움을 겪었던 부분입니다.**

✨ 코파일럿의 돋보이는 기능: 터미널 AI 및 커밋 메시지 자동 생성

코파일럿은 터미널 AI 기능 (Command-E)을 통해 명령어를 쉽게 생성하고 실행할 수 있게 해줍니다. **이는 bash 전문가가 아니더라도 터미널 작업을 효율적으로 수행할 수 있도록 돕습니다.**

또한, 커밋 메시지를 자동으로 생성하는 기능도 제공하며, **기본적으로 깔끔하게 작성해 줍니다.**

⚙️ 맞춤형 지침 및 인라인 자동 완성

코파일럿은 `GitHub Copilot instructions.md` 파일을 통해 맞춤형 지침을 설정할 수 있으며, **이는 커서의 규칙과 유사한 기능입니다.**

인라인 자동 완성 기능도 잘 작동하지만, **커서는 여러 줄에 걸쳐 인라인 업데이트를 제안하는 기능으로 더욱 발전된 경험을 제공합니다.**

🏗️ 새로운 프로젝트 생성 시뮬레이션: 커서의 뛰어난 성능

새로운 Remix 앱을 만들고 Figma 디자인을 코드로 변환하는 시뮬레이션에서 커서는 Builder CLI 명령어를 통해 디자인을 코드로 빠르게 생성했습니다. **`randomuser.me`에서 사용자 테이블을 가져오는 작업도 정확하게 수행했습니다.**

코파일럿은 동일한 작업을 수행하는 데 시간이 오래 걸렸고, **결과도 정확하지 않았습니다. 파일을 수동으로 태깅해야 하는 번거로움도 있었습니다.**

커서는 테이블을 별도의 컴포넌트 파일로 생성하여 코드를 더 깔끔하게 유지했지만, **코파일럿은 모든 코드를 인라인으로 추가하여 코드가 복잡해졌습니다.**

💰 결론: 커서 vs 코파일럿, 무엇을 선택할까?

전반적으로 커서는 더 안정적이고 정확한 코딩 경험을 제공하며, **특히 에이전트 모드는 매우 효율적입니다.**

월 20달러의 비용을 지불할 가치가 있다고 생각하며, **시간을 절약하고 생산성을 높이는 데 도움이 됩니다.**

코파일럿은 무료 티어를 제공하지만, **기능 제한이 있을 수 있습니다.** 더 저렴한 옵션을 원한다면 Tabnine도 좋은 대안이 될 수 있습니다.

궁극적으로 어떤 AI 도구를 선호하는지는 개인의 선택에 달려 있습니다. **자신에게 가장 적합한 도구를 선택하여 코딩 효율성을 높이세요!**

GitHub Copilot의 'Edit with Copilot' 기능 평가: 장단점 분석

'Edit with Copilot' 기능 소개 및 다중 파일 편집 기능 설명

관련 파일 자동 검색 기능(codebase modifier)의 속도 및 정확도 문제점 지적

admin API 수정 작업에서의 부정확성 및 파일 검색 실패 사례 제시

간단한 버그 수정 작업에서의 지연 및 오류 발생 상황 설명

전반적인 기능의 느림, 버그, 낮은 정확도에 대한 비판적 평가

GitHub Copilot과 Cursor의 다중 파일 편집 기능 비교

GitHub Copilot의 다양한 모델 지원 기능(Claude 3.5, Sonnet 등) 언급

GPT-4 모델 사용 시에도 유사한 문제 발생을 확인

Cursor의 다중 파일 편집 기능의 빠른 속도와 정확도 강조

Cursor를 이용한 admin GraphQL API 수정 작업 성공 사례 제시

Cursor를 이용한 라우팅 버그 수정 작업 성공 사례 제시

GitHub Copilot과 Cursor의 부가 기능 비교

두 프로그램 모두 제공하는 AI 기반 터미널 기능 비교 (단축키 차이점 언급)

GitHub Copilot의 자동 커밋 메시지 생성 기능 및 Cursor와의 비교

GitHub Copilot의 사용자 지정 명령어 기능(GitHub Copilot instructions.md)과 Cursor의 규칙 기능 비교

두 프로그램의 자동 완성 기능 비교

새로운 Remix 앱 개발을 통한 실제 사용 환경 비교

새로운 Remix 앱 생성 및 Figma 디자인을 코드로 변환하는 과정 설명

Cursor를 이용한 사용자 테이블 추가 작업 성공 사례 제시

GitHub Copilot을 이용한 동일 작업 시의 부정확성 및 오류 발생

GitHub Copilot의 파일 색인 문제점 지적 및 수동 태깅의 필요성 언급

결론 및 각 프로그램의 장단점 요약

개인적인 선호도를 바탕으로 Cursor 추천 및 유료 서비스 이용 가치 강조

GitHub Copilot의 무료 및 유료 요금제 비교

Builder 블로그에서의 자세한 비교 분석 자료 링크 안내