Cursor vs. GitHub Copilot: AI Coding Showdown!

YouTube Video

Summary

This YouTube transcript is a comparison between two AI coding tools: GitHub Copilot and Cursor. The video presents a practical, hands-on comparison by walking through a coding task in Go language using both tools side-by-side in VS Code.

The video starts by introducing the premise that while many believe AI coding tools are dominated by big players, a smaller, lesser-known tool, Cursor, might actually be better than established giants like GitHub Copilot.

The comparison is structured as a “battle” between Copilot and Cursor, focusing on their performance and capabilities in several coding scenarios. The core task involves defining a global variable to control the response format (JSON or text) based on a feature flag, and then refactoring the code to use only JSON responses.

Here’s a breakdown of the comparison points and the presenter’s observations:

Initial Task: Define Global Variable and Conditional Response Format

• Speed and Response Detail: Cursor was significantly faster in providing a solution and offered a more extensive and structured answer than Copilot. Cursor broke down the changes into logical blocks (adding variable, modifying functions), while Copilot gave a single, large code block.
• Codebase Awareness: Cursor correctly identified and proposed changes across multiple files (main.go and root.go), demonstrating an understanding of the entire codebase. Copilot, on the other hand, focused only on the currently open file (main.go), even though both tools were instructed to consider the entire workspace.
• Change Application: Cursor’s approach of presenting changes in separate blocks felt more natural and safer, allowing for step-by-step application. Copilot applied all suggested changes at once.
• Visual Clarity: Cursor’s visual presentation of code changes was considered cleaner and easier to understand than Copilot’s use of shades of green.

Code Writing Example: Fibonacci Function with Conditional Response

• Proactive Completion: When writing code for the Fibonacci function to handle JSON or text responses, Cursor was more proactive and intelligent. It anticipated the user’s intent even before the line was fully typed and proposed complete solutions. Copilot worked more line-by-line.
• Code Improvement beyond Minimum: Cursor went beyond just implementing the conditional logic. It enhanced both JSON and text responses by adding more information (input number, calculated Fibonacci number). Copilot provided a minimal solution, simply adapting the existing code to the new requirement.
• Refactoring and Codebase Understanding (JSON-Only Requirement): When asked to switch to JSON-only responses, Cursor again demonstrated superior codebase understanding. It correctly identified and removed the now unnecessary feature flag logic from multiple files (main.go and Fibonacci Dogo). Copilot only made changes in the currently open file, leaving technical debt.
• Addressing All HTTP Responses: When asked to apply changes to all HTTP responses across the codebase, Cursor successfully identified and proposed changes in multiple relevant files (root.go, P.O memory leak.goo, etc.). Copilot remained limited to the currently open files.

Testing:

• Unit and Integration Tests: Cursor suggested tests that were context-aware, adapting to previous code changes and even modifying existing tests. It also created new test files automatically. Copilot required manual file creation and provided less contextually relevant tests, especially integration tests which were essentially unit tests.
• Test Code Quality: Cursor’s integration tests were more realistic and followed established patterns within the existing codebase, simulating real application behavior and database interaction. Copilot’s integration tests were deemed unusable.

Other Comparisons (Briefly Mentioned):

• Script Assistance (Nal scripts): Both tools were surprisingly capable of understanding and assisting with Nal scripts.
• Error Handling: Both could relate terminal errors to code, but Copilot was limited to the open file, while Cursor considered the entire codebase.
• DevOps Files (GitHub Actions, Docker, Kubernetes): Both tools struggled with GitHub Actions workflows but offered decent improvements for Docker files and Kubernetes manifests.

Overall Conclusion:

The video concludes that Cursor is significantly better than GitHub Copilot in almost every aspect tested. Key advantages highlighted for Cursor include:

• Speed and Responsiveness
• More Detailed Explanations
• Whole Codebase Context Awareness
• Better Code Change Representation
• Superior Autocompletion
• More Intelligent and Proactive Suggestions

The presenter, having used Copilot for a long time and Cursor for a month, strongly recommends trying Cursor. The only minor complaint mentioned is some shortcut conflicts.

Accuracy

The information presented in the transcript regarding the comparison between GitHub Copilot and Cursor needs to be evaluated with a degree of nuance. Here’s an accuracy check based on general knowledge and common perceptions:

• Cursor’s Focus on Codebase Context: The video highlights Cursor’s strength in understanding and operating across the entire codebase, while criticizing Copilot for being limited to the open file. This is a generally accurate observation. Cursor is designed to be a full-fledged AI-powered code editor built on top of VS Code, with a strong emphasis on codebase-wide understanding. Copilot, while improving, historically has been perceived as more file-focused, especially in older versions. However, Copilot’s capabilities have evolved, and it can now utilize more context, particularly with features like @workspace mentions in prompts.

• Cursor’s Speed and Responsiveness: The claim that Cursor is faster in generating suggestions and responses is subjective and potentially variable. Performance can depend on many factors, including network conditions, server load, the complexity of the request, and the specific models and infrastructure each tool uses. While the video presenter experienced Cursor as faster, this might not be universally true for all users and scenarios.

• Cursor’s Detailed Explanations and Structured Responses: The assertion that Cursor provides more detailed and structured explanations is plausible and aligns with Cursor’s design philosophy. Cursor aims to be more conversational and provide more context and reasoning behind its suggestions. Copilot’s explanations can be more concise and focused on code completion.

• Cursor’s Proactive and “Extra Mile” Suggestions: The idea that Cursor goes “the extra mile” by suggesting code improvements beyond the immediate request, as seen in the Fibonacci example, is consistent with Cursor’s marketing and reported behavior. Cursor aims to be more of a proactive coding assistant, offering suggestions for code quality, refactoring, and improvements. Copilot, in its core functionality, is often perceived as being more focused on code completion and direct task fulfillment.

• Testing Capabilities: The description of Cursor’s superior test generation, especially integration tests, and its ability to learn from existing test patterns is a strong claim that needs further verification. While Cursor aims to be intelligent about test generation, the extent of its capabilities and its consistent superiority over Copilot in this area requires more comprehensive testing and user experiences beyond this single video. Copilot’s test generation capabilities have also improved over time.

• General Conclusion of Cursor being “Better”: The overall conclusion that Cursor is “better” than Copilot is a strong subjective statement. “Better” is relative and depends on individual needs and priorities. For users who highly value codebase-wide understanding, proactive assistance, detailed explanations, and a more integrated AI coding experience, Cursor might indeed be perceived as “better.” However, Copilot also has its strengths, including deep integration with GitHub, a vast user base, and continuous development by Microsoft. Copilot might be preferred by users who are already heavily invested in the GitHub ecosystem or who prioritize specific features or workflows that Copilot excels in.

Potential Biases:

• Sponsorship: The video is sponsored by TwinGate. While the sponsorship is unrelated to Cursor or Copilot, it’s always worth noting potential influences.
• Enthusiasm for New Tool: The presenter expresses excitement about Cursor as a newer tool, which could introduce a slight positive bias. It’s common for users to be enthusiastic about new tools and potentially overemphasize their advantages compared to established alternatives.
• Specific Use Case: The comparison is based on a specific coding task in Go. The relative performance of Copilot and Cursor might vary depending on the programming language, project complexity, and specific coding styles.

In summary, the transcript provides a useful and insightful comparison based on the presenter’s experience. Many of the observations about Cursor’s strengths in codebase understanding, detailed explanations, and proactive suggestions are generally accurate and align with the tool’s design and marketing. However, the overall conclusion of Cursor being definitively “better” is subjective and should be considered in the context of individual needs and preferences. The accuracy of claims, particularly regarding test generation and consistent speed advantages, would benefit from further independent verification and broader user experiences. It’s also important to remember that both tools are rapidly evolving, and their relative strengths and weaknesses may change over time.

Resources

Here are 5 relevant resources to learn more about AI coding assistants and the tools mentioned in the transcript:

1. GitHub Copilot Official Documentation:

   • Link: https://docs.github.com/en/copilot
   • Relevance: The official documentation is the best place to get a comprehensive understanding of GitHub Copilot’s features, capabilities, setup, and usage. It includes tutorials, FAQs, and detailed explanations of how Copilot works. For anyone wanting to learn more about Copilot directly from the source, this is essential.

2. Cursor.sh Official Website and Documentation:

   • Link: https://cursor.sh/
   • Relevance: The official Cursor website provides an overview of its features, benefits, and pricing. The documentation (likely accessible from the website) will offer detailed guides on how to use Cursor, its specific functionalities, and how it differs from standard VS Code. This is crucial for understanding Cursor’s unique approach to AI-assisted coding.

3. “GitHub Copilot vs. Cursor: Which AI Coding Tool is Better?” (Blog Post/Article):

   • Link: (Search for recent articles comparing “GitHub Copilot vs Cursor” on tech blogs like TechCrunch, The Verge, InfoWorld, etc.)
   • Relevance: Look for recent, in-depth articles or blog posts that provide comparative reviews of Copilot and Cursor from various tech publications or developer communities. These articles often offer different perspectives, user experiences, and more balanced comparisons than a single YouTube video. They can help you see a broader picture of the strengths and weaknesses of each tool.

4. “Awesome AI Code Assistants” (GitHub Repository/Curated List):

   • Link: (Search GitHub for “awesome ai code assistants” or “awesome copilot alternatives”)
   • Relevance: GitHub is likely to host curated lists (“awesome lists”) that compile various AI code assistants, including Copilot, Cursor, and other alternatives (like AWS CodeWhisperer, Google Gemini for Code/Bard, Tabnine, etc.). These lists often contain links to documentation, articles, blog posts, and community discussions, providing a broader overview of the AI coding assistant landscape and helping you discover other options beyond Copilot and Cursor.

5. Developer Communities and Forums (Reddit, Stack Overflow, Hacker News):

   • Links: https://www.reddit.com/r/programming/, https://stackoverflow.com/, https://news.ycombinator.com/
   • Relevance: Engage with developer communities on platforms like Reddit (subreddits like r/programming, r/developers), Stack Overflow (search for questions tagged with “github-copilot” or “ai-coding-assistants”), and Hacker News. These platforms are great for finding real-world user experiences, discussions about the pros and cons of different AI coding tools, and getting answers to specific questions you might have after watching the video. You can search for existing discussions or start new threads to ask about specific aspects of Copilot and Cursor.