GitHub Copilot Reviews & Product Details

As a software engineer managing our BIAI-CRM project at Neuroxyte, the AI intelligence of GitHub Copilot is simply unmatched for architectural analysis. The UI and UX are incredibly intuitive, offering seamless integrations directly inside my IDE (VS Code) to analyze our Dockerfiles and Prisma scripts. From day one, the onboarding process was smooth, and their technical support documentation made it easy to set up. Most importantly, it drastically improves our coding performance and execution speed by automating repetitive boilerplate and identifying deployment risks. When calculating the engineering hours saved, the subscription pricing offers a massive ROI (Return on Investment) for our business. Review collected by and hosted on G2.com.

While highly capable, GitHub Copilot occasionally struggles with deep context retention across massive multi-file workspaces. For instance, when working on complex Prisma schemas alongside specific Vercel deployment configurations for our CRM, it sometimes suggests deprecated library methods or loses track of custom types defined in adjacent directories. You have to be very precise with your prompts and manually steer the AI to ensure it adheres to the latest framework updates, which can briefly slow down your coding momentum. Review collected by and hosted on G2.com.

The tight integration with Visual Studio and VS Code makes GitHub Copilot feel like an effortless extension of the IDE rather than an intrusive third-party add-on. In daily C# and ASP.NET API development, it delivers its greatest value in boilerplate reduction and unit testing. It accurately anticipates DTO mappings, controller endpoints, and repetitive mock setups in xUnit with minimal prompting. The inline suggestion speed is instantaneous, keeping you locked in the flow state, and it frequently eliminates the need to switch out to documentation for complex LINQ queries or regular expressions. Overall, it saves hours of mechanical typing each sprint without degrading code control. Review collected by and hosted on G2.com.

The main drawback of GitHub Copilot lies in its limited context awareness across large, multi-project enterprise solutions. In structured .NET codebases with dozens of dependencies, it tends to pull context only from currently open tabs rather than the full repository architecture, often leading to suggestions that ignore internal shared libraries or domain models. Additionally, it occasionally hallucinates non-existent NuGet package methods or proposes deprecated framework idioms, which increases review overhead to catch subtle edge cases like missing null checks or unhandled async exceptions. Better whole-solution semantic indexing and stricter target-framework boundaries would significantly reduce the need to constantly police generated code. Review collected by and hosted on G2.com.

GitHub Copilot helps me cut down on repetitive work and troubleshoot issues more quickly. I use it to generate infrastructure code, validate scripts, fix command syntax, and make sense of unfamiliar code, logs, or errors. Overall, it speeds up development, improves code quality, and lets me spend more time on solution design and production problem-solving instead of getting stuck on routine coding tasks. Review collected by and hosted on G2.com.

GitHub Copilot’s suggestions aren’t always fully context-aware and can sometimes produce incorrect or suboptimal code, so I still need to manually review what it generates. It can also struggle with organization-specific codebases, architecture, and business logic, which makes human validation essential before implementing anything. Review collected by and hosted on G2.com.

We use the GitHub Copilot integration with Visual Studio Code in our workspace, and I also use it personally for my freelance and personal projects. Overall, it has been really good.

Copilot understands the context of the project, which helps a lot with debugging and building connected features. Plus, since it’s GitHub, version control feels easier, faster, and less error-prone. It reduces reliance on manual steps and helps cut down on human mistakes. Review collected by and hosted on G2.com.

Sometimes the answers feel a bit too generic, almost as if they’re pulled straight from the web, and they don’t always address my specific problem. It can also get stuck in a loop, especially with highly complex projects, which can lead to inaccuracies or inconsistent results. The code it generates often needs manual tweaking and additional adjustments before it truly matches the project’s expectations. Review collected by and hosted on G2.com.

I like GitHub Copilot because it integrates smoothly with my development environment and has a clean, easy-to-use interface. Its code completion and AI suggestions can significantly speed up development, especially for repetitive tasks and common coding patterns. It performs well during regular coding and fits naturally into my existing workflow. The productivity gains can make the pricing worthwhile for developers who use it regularly. The onboarding is straightforward, and the AI assistance is useful for understanding code, generating solutions, and debugging, although the suggestions sometimes need to be reviewed because they are not always accurate. Review collected by and hosted on G2.com.

The main limitation is that Copilot's AI suggestions are not always accurate and sometimes generate code that needs significant correction or review. The quality can vary depending on the context and complexity of the task. It can also occasionally suggest outdated or inefficient approaches. While the integration and user experience are good, I would like to see more consistently reliable answers, better contextual understanding, and improved accuracy for complex coding problems. The pricing can also feel less worthwhile for users who do not use Copilot regularly. Review collected by and hosted on G2.com.

The AI intelligence and contextual awareness are what I like best about GitHub Copilot. Its ability to seamlessly integrate into my IDE and understand my local code context makes it feel less like a tool and more like a collaborative partner.

Instead of just generating generic boilerplate code, Copilot excels at predicting my exact intent based on variable names and surrounding functions, often completing entire multi-line blocks of code with a single press of the Tab key. This high-level performance saves me hours each week by minimizing repetitive typing and reducing the need to constantly switch tabs to browse documentation.

An unexpected benefit has been its value during onboarding and learning. When working with unfamiliar libraries or new syntax, I can write a quick comment explaining what I want to achieve, and Copilot instantly provides a working baseline. This dramatically accelerates my learning curve and keeps me in flow state, delivering an incredible ROI for daily development workflows. Review collected by and hosted on G2.com.

The primary drawback is its occasional hallucination of outdated libraries and issues with large codebase context. Because the AI intelligence relies on historical training data, it sometimes suggests deprecated syntax or functions from older versions of packages, which requires manual verification and debugging.

Additionally, the UI/UX can feel a bit restrictive when dealing with large, multi-file projects. While the inline suggestions are highly performant, Copilot can struggle to fully grasp the context of changes made across separate architectural layers (like a database schema change affecting a frontend component) unless those files are explicitly open in the IDE. This means I still have to spend time bridging the gaps between complex, cross-file dependencies. Review collected by and hosted on G2.com.

GitHub Copilot has contributed a lot to my programming journey. It has allowed me to learn about code types, gain insights into current implementations, and get my coding done easily through smart code completion suggestions.

What I found most interesting here is the fact that we work with various AI models in one place. The ability to select a specific model depending on task parameters contributes to flexibility and helps optimize time and token use. Review collected by and hosted on G2.com.

GitHub Copilot might be quite slow while trying to comprehend large code bases, which will mean longer hours to understand the applicable coding context. Furthermore, while being used for a longer time, the tool may also lose track of the prior used context and consume too much memory which eventually will make you repeat the commands. To conclude, the solution can provide some irrelevant suggestions for your project, meaning that the final outputs must still be examined. Review collected by and hosted on G2.com.

I use GitHub Copilot in VS Code for Django development, and its autocomplete is fast and often gets the code right. It handles much of the routine structure and indentation, so I can focus on the logic instead of repetitive typing. Review collected by and hosted on G2.com.

My experience is mainly with code autocomplete in VS Code for Django, so I have not explored every Copilot feature. I don't have a specific drawback to call out from the workflow I use most. Review collected by and hosted on G2.com.

I use GitHub Copilot in VS Code, where it’s integrated directly into the editor. It helps me with bug fixes, code optimization, and code completion. In GitHub Copilot Chat, I can attach an entire file, and I can also add multiple files by clicking the plus icon in the chat. When I send those files along with my prompt, it analyzes the code and responds using the full-file context. Most of the time, it resolves my coding issues within minutes. It also feels more accurate than other AI tools because it can access my files and understand the context better, which saves me a lot of time. When I need changes, it can update my code directly; I can review the suggested edits line by line and then approve or reject them based on my requirements. Review collected by and hosted on G2.com.

This is not always accurate; sometimes it makes mistakes and I have to reject the suggested code changes. Some times it only generates basic code, so I have to guide GitHub Copilot about what advanced changes are required for my code and for a more secure site. Once I explain what I need, GitHub Copilot follows it. But I still can't trust it blindly. Also, this is not completely free. They provide a free limit, and after the limit is exhausted, we have to buy a premium plan or wait some day. I’m also facing an issue with chat history: I’m unable to track my previous chats in GitHub Copilot. Review collected by and hosted on G2.com.

I use GitHub Copilot every day in Visual Studio Code while developing JavaScript, SAPUI5, SQL, and Python applications. The inline code suggestions help me complete repetitive functions, formatter methods, SQL queries, API calls, and boilerplate code much faster than writing everything manually. For example, when creating CRUD operations or utility functions, Copilot often generates a solid first draft that only needs minor adjustments.

Copilot Chat has become one of the features I use most. It helps me understand unfamiliar code, troubleshoot errors, explain complex logic, and generate sample implementations without leaving my IDE. This has reduced the amount of time I spend searching through documentation or online forums.

The integration with Visual Studio Code is seamless, the interface is intuitive, and suggestions typically appear almost instantly, keeping my development workflow uninterrupted. Getting started was straightforward and required only a few minutes of setup. While the subscription cost is something to consider, the productivity gains, faster development, and reduced time spent on repetitive coding make it a worthwhile investment for my daily work. Review collected by and hosted on G2.com.

GitHub Copilot is a valuable productivity tool, but I always review its suggestions before using them. For straightforward tasks it performs well, but for complex business logic or large codebases it can sometimes generate code that doesn't fully align with the project's coding standards, architecture, or naming conventions. It may also lose context across multiple files, leading to repetitive or overly generic implementations that require manual refinement.

Copilot Chat is useful for explanations and troubleshooting, but I occasionally encounter examples that are outdated or not fully aligned with the latest versions of certain libraries or frameworks. Because of this, I still verify important recommendations against official documentation and test the generated code before committing it.

I would like to see better awareness of the entire project structure, more accurate framework- and version-specific suggestions, and improved handling of large, multi-file projects. These improvements would make GitHub Copilot even more reliable for professional software development. Review collected by and hosted on G2.com.