Introducing Visual Copilot 2.0: Make Figma designs real

Announcing Visual Copilot - Figma to production in half the time

Builder.io logo
Contact Sales
Platform
Developers
Contact Sales

Blog

Home

Resources

Blog

Forum

Github

Login

Signup

×

Visual CMS

Drag-and-drop visual editor and headless CMS for any tech stack

Theme Studio for Shopify

Build and optimize your Shopify-hosted storefront, no coding required

Resources

Blog

Get StartedLogin

‹ Back to blog

AI

Cursor vs GitHub Copilot

December 20, 2024

Written By Vishwas Gopinath

Let's talk about AI coding assistants. They're basically the new hot topic in dev tools, and for good reason. They're designed to help developers write code more efficiently and with fewer errors. They're pretty dang cool.

While there are quite a few players in this space, let's zoom in on two of the major contenders. In one corner, we've got GitHub Copilot, the established player. In the other, Cursor, the new kid on the block shaking things up. Both are trying to make our lives easier as devs.

After spending some time with Copilot and Cursor, I thought it might be useful to break down how they stack up against each other. Whether you're curious about trying them out or just want to know what all the fuss is about, stick around. We're going to dig into some of the key features that matter to us as developers.

Cursor AI

Cursor is basically an AI-powered code editor on steroids. It is a fork of Visual Studio Code, bringing advanced AI capabilities to a familiar interface.

GitHub Copilot is an AI coding assistant that helps you write code faster and with less effort, allowing you to focus more energy on problem solving and collaboration.

Developed by GitHub in collaboration with OpenAI, it uses machine learning to generate code suggestions and complete tasks directly in your code editor (Visual Studio Code, Visual Studio, Vim/Neovim, JetBrains IDEs).

Both Cursor AI and GitHub Copilot offer a range of features designed to enhance productivity and support developers. Let's dive into the specific features and see how these two compare.

You know that feeling when you're typing and the IDE just gets what you're trying to do? That's what we're talking about here.

Cursor's tab completion is pretty wild. It'll suggest multiple lines of code, and it's looking at your whole project to make those suggestions. For TypeScript and Python files - when Tab suggests an unimported symbol, Cursor will auto-import it to your current file. Plus, it even tries to guess where you're going to edit next.

Copilot's more focused on inline suggestions. Tab to accept, and you're off to the races. It often predicts the next logical line of code based on the developer's style, which can significantly speed up coding tasks. Need options? Hit Alt+] or Alt+[ to cycle through different suggestions, or Ctrl+Enter to see multiple alternatives in a new tab.

This is where things get interesting. Imagine describing what you want your code to do, and boom — it's there.

Cursor has this thing called Composer that can create entire applications based on your description. It's looking at your whole project when it generates code, so it tries to match your style. Use ⌘ + I to open it, and ⌘ + N to create a new Composer. For inline generation, boilerplate code and edits, you can use the ⌘ + K feature. Impressively, it can work with multiple programming languages within the same project, adapting its suggestions accordingly.

Copilot's more about those inline suggestions, but Copilot Chat can handle bigger chunks of code if you ask it nicely. The CLI can also generate code if you describe what you want in plain English.

Sometimes you just need to ask a question. But is chatting with an AI actually helpful?

Cursor's chat (⌘ + L) is context-aware, so it knows what you're working on. You can also drag & drop folders into Chat to provide additional context and apply code suggestions right from the chat, which is neat. It even supports images for visual context.

GitHub Copilot Chat is similar — you can ask it to explain code or suggest improvements. It's integrated right into VS Code, so it feels pretty seamless. They've been rolling out some new features lately, like better chat history, drag and & folders and ways to attach more context. But if you're already using Cursor, you might not find anything groundbreaking here.

Terminal work can be a pain, especially with complex commands.

Cursor extends its AI smarts to the terminal with ⌘ + K. It's pretty handy for translating vague ideas into actual commands. However, it hijacks the terminal's clear shortcut, which is just kind of annoying.

Copilot's got a slick terminal integration that lets you just hit ⌘ + I, type what you want, and get the command you need. No need to be a bash wizard anymore – just describe what you want to do in plain English, hit enter, and you're good to go. The command + enter shortcut to run the suggested command is very handy.

This is a big one. Can these tools actually understand your whole project, or are they just looking at the current file?

Cursor's pretty impressive here. It looks at your entire codebase and project structure. You can even use @ symbols to reference specific parts of your project, like @Files, @Folders, @Code, and more.

Copilot's pretty smart about context too. It looks at your open files to figure out what's going on and can pick up cues from your imports, comments, and function names. Use a '#' to reference files or use the 'Attach Context' button to pick exactly what you want Copilot to look at.

Support for working across multiple files enables AI assistants to understand and modify complex project structures.

Cursor's Composer can make changes across your entire project, which is pretty powerful. It understands how different files and components relate to each other. Composer can generate files for an entire app at once. I’ve personally used the feature to refactor a single file into more organized files and folders.

Copilot's latest addition is its Edits feature, and it's pretty sweet. Just define your working set of files, describe what you want in plain English, and watch Copilot make changes across multiple files. You can review each change, accept what works, and iterate until you get it right.

In our testing, we found the feature to be surprisingly slow, sometimes getting stuck in infinite loading states or making incorrect file changes.

Pro tip: manually specify your files instead of relying on automatic detection – it's more work, but you'll get more reliable results.

This is about having an AI assistant that can take control of your editor – running commands, managing files, and handling project-wide tasks.

In Composer, hit ⌘. and you've got yourself Cursor Agent, a super-powered AI assistant. It'll automatically grab context, run terminal commands, handle files, and even do semantic code search. The catch? It only works with Claude models, and each operation counts against your quota. But when you need to get things done fast, it's an absolute game-changer.

Nothing quite like this in Copilot's toolkit yet. While Copilot Chat can handle some similar tasks, it doesn't have the same level of integrated project-wide assistance.

We all need a second pair of eyes sometimes. AI-powered code review can provide automated feedback on code quality, potential bugs, and adherence to best practices.

Cursor's new bug finder is pretty neat. It scans your code and branch changes against main, rating each potential bug it finds. One click and it'll fix things right in your editor. There's a catch though – you'll pay per click (we're talking a dollar or more each time)

Copilot's just rolled out a code review feature that's pretty sweet (though still in limited release). Hit the review button in your Source Control tab, and it'll check your staged or unstaged changes. It drops suggestions right inline in your code that you can apply with one click. Skip what you don't like, accept what you do – simple as that.

One size doesn't fit all in coding. Can you bend these tools to fit your specific needs, or are you stuck with what they give you?

Cursor lets you set custom instructions through settings and .cursorrules files. You can tailor it to your project's specific needs.

Copilot supports custom instructions through a .github/copilot-instructions.md file, similar to Cursor's approach. This lets you specify your coding preferences and conventions, which Copilot will follow when generating code.

Let's see how these tools handle git commits.

AI-generated commit messages might not sound like much, but it saves me a couple of minutes every day and reduces the mental load of coming up with good commit messages. Now, Cursor does have this habit of being a bit...wordy with its commit messages. You can tweak that behavior by adding some instructions in the .cursorrules file.

Copilot does this pretty nice by default. Just hit the auto-generate commit message button and you're good to go. I've found their messages to be cleaner and more concise compared to Cursor's, though you'll probably still want to give them a quick review before committing.

Nobody wants to switch between a bunch of tools.

Cursor is its own thing — it's built on top of VS Code, so it'll feel familiar if you're used to that.

Copilot on the other hand integrates with various IDEs — VS Code, IntelliJ, Neovim. The CLI works in any terminal.

Cursor offers a range of models, including GPT-4o, o1, Claude 3.5 Sonnet, and their custom cursor-small model. You can choose based on what you need — speed or capability.

Copilot has expanded its model offerings significantly. You can now choose between different models including Claude 3.5 Sonnet, o1, and GPT-4o. This flexibility lets you optimize for different tasks – whether you need quick code completions or more complex reasoning and understanding.

Let's talk money. How do their pricing models compare?

Cursor has a free Hobby tier with limited features, a Pro tier for $20/month, and a Business tier for $40/user/month.

Copilot now offers a free tier with limited features (like 12,000 completions per month), while Pro plans start at $10/month. For teams, there's Business at $19/user/month and Enterprise at $39/user/month.

After diving deep into both Cursor and GitHub Copilot, it's time to pick a champ. And drum roll, please...Cursor takes the crown. Its unique features make it a hard sell to beat in the world of AI-assisted coding.

Now, don't get me wrong, Copilot is a solid tool. It's great for quick suggestions and it plays nice with a bunch of different IDEs. But Cursor? It's just operating on another level.

Here's why Cursor wins out:

  1. Project-wide smarts: Cursor's ability to understand and work with your entire codebase is still unmatched. Copilot's context awareness can get sluggish with larger projects.
  2. Speed and reliability: Cursor's Composer consistently outperforms when it comes to project-wide operations. While Copilot's new Edits feature is promising, it often gets stuck or slows to a crawl. Cursor just gets the job done.
  3. Agent power: With Cursor, you get a polished Agent mode that just gets what you're trying to do

Copilot is still a powerful tool, and if you're looking for something that's easy to integrate into your existing workflow, it might be the way to go. Its code completion capabilities are certainly impressive. But if you want to really push the boundaries of what AI can do for your coding, Cursor is where it's at.

Of course, the best tool is the one that works for you. So give them both a spin if you can. But if you're asking me? Cursor's the one to beat right now.

My preferred workflow, overall look like this:

  1. For coding, I work iteratively with Cursor
  2. Our design team works within Figma
  3. Builder.io converts designs to code and also patches in design updates as they're needed
Diagram of my preferred AI stack

But those are just my preferences, what are yours?

If you enjoyed this post, you might also like:

Introducing Visual Copilot: convert Figma designs to high quality code in a single click.

Try Visual CopilotGet a demo

Share

Twitter
LinkedIn
Facebook
Hand written text that says "A drag and drop headless CMS?"

Introducing Visual Copilot:

A new AI model to turn Figma designs to high quality code using your components.

Try Visual CopilotGet a demo
Newsletter

Like our content?

Join Our Newsletter

Continue Reading
ai16 MIN
Cursor vs Windsurf vs GitHub Copilot
January 8, 2025
web development12 MIN
React UI Component Libraries in 2025
January 6, 2025
Web Development8 MIN
React + AI Stack for 2025
January 2, 2025