GitHub CoPilot Reviews

There are multiple use cases for this product because it is tied in with LLMs altogether. I have been using it for coding purposes, for reviewing code, for any Git work that we do, such as push, pull, or committing. Additionally, I use it for developing test cases, and it has been really helpful in those terms altogether.

It does assist with creating unit tests, and it totally depends on your prompt and whatever you give to it.

One of the biggest impacts from the company's perspective is the turnaround time. If I had to do work that could take me about two days, I can finish that within half an hour altogether. This is where it is helping us by reducing one and a half days altogether. Another half day sometimes is needed to refresh or review the code that has been generated so that it does not fall anywhere, but it does help a great deal in those terms. Learning-wise, it also helps significantly, and there are many use cases. For example, we are developing one RAG system with it, a chatbot where it reads all the test cases and gives answers in a real text-like structure. It is a great help altogether.

GitHub CoPilot is effective at generating code based on language prompts. I use Claude Sonnet as the main LLM, and the kind of code it generates is really good and really refined. I do have to do some manual effort so that I have clean code altogether, but it is a really good option for white coding.

I am learning Python now to learn new things and work on the AI part because this forms the main heart and soul of any LLMs. I started learning Python and GitHub CoPilot is helping me tremendously. I would say it is a really good teacher.

It has a positive impact on my developmental process.

Things which were taking like two days are now finished within half an hour. There is a great impact on the productivity.

Any technology comes with two things, or rather anything in this world has both sides, good and bad. LLMs also have the same thing. The bad part is for a person who is 100% dependent on AI because they won't be able to learn more if they are 100% dependent on that. The main thing is that there has to be restraint from our side. I won't say it is from the tool side, but from our side, we need to learn and we need to work on it. We need to review the code. That is one thing that we need to do from our end. From a technology perspective, it is designed to help us out, and it is totally on our side of thinking about how exactly we are going to use that.

There is not any area for improvement from the tool side, but it is from the users altogether. Users should not be 100% reliant on AI or any LLMs. They need to work on it and they need to review the code.

GitHub CoPilot is 100% stable.

It is quite easy to scale. I just need to buy the license, and if buying an enterprise license, as in the case of my company, they bought an enterprise license. Setting up the complete infrastructure might be a consideration, but usage-wise, I do not think it requires anything.

Negative

It is quite easy. I just need to buy the license, and if buying an enterprise license, as in the case of my company, they bought an enterprise license. Setting up the complete infrastructure might be a consideration, but usage-wise, I do not think it requires anything.

GitHub CoPilot provides a great deal of return on investment.

For now, I think it is okay. It is not that expensive.

The kind of use that I am having with a $20-30 license, I think it is really of really good help.

One of the biggest impacts from the company's perspective is the turnaround time. If I had to do work that could take me about two days, I can finish that within half an hour altogether. This is where it is helping us by reducing one and a half days altogether. Another half day sometimes is needed to refresh or review the code that has been generated so that it does not fall anywhere, but it does help a great deal in those terms. Learning-wise, it also helps significantly, and there are many use cases. For example, we are developing one RAG system with it, a chatbot where it reads all the test cases and gives answers in a real text-like structure. It is a great help altogether.

I think it is of great help altogether. Even if any software or new technology helps you bring down your productivity by even one or two minutes, it is a great help for the complete team or even the company.

I gave this product a rating of nine points only because of the danger that you should not be 100% reliant on AI.

I usually use GitHub CoPilot for all my work since I'm a developer, and I use it majorly in my development user stories. I do a lot of enhancements of features using GitHub CoPilot. Regarding GitHub CoPilot, the one main usage of it in my daily life was when I was committed to my 100-day AI journey. Most of the Python AI prototypes that I have done were mostly completed using GitHub CoPilot, assisted by all the ideas that I had. The main important use case is to use GitHub CoPilot for all the development and the enhancements that I do on a daily basis in terms of development.

Mostly the projects that I was building in my 100-day journey, including Fast APIs and Streamlit APIs, were completely built by using GitHub CoPilot. Even debugging ML models, including the Hugging Face emotions and all those things, were easily done by GitHub CoPilot. The context-aware suggestions and the speed coding done by GitHub CoPilot has been helpful for me in many tasks that I do on a regular basis. On the company side, for the major development user stories, I cover it using GitHub CoPilot, and even the Agentic mode in GitHub CoPilot has been so helpful because earlier for about one year, it was just the chat model. I was using it in IntelliJ and Visual Studio most of the time. However, once that chat model has been enhanced into Agentic mode, that's when I actually got to know the actual power of GitHub CoPilot in building things faster. Earlier it was just a chat model, so I was chatting, getting to know the context, and then after that, I was actually using that code in developing tasks. But now, since the Agentic mode has come in IntelliJ with respect to GitHub CoPilot, it's an absolute beast in terms of all the development that I do on a daily basis.

My company has developed our own PR review system that uses GitHub CoPilot underlying. The moment I raise a PR, I get to review the PR using GitHub CoPilot. The PR review process was a tight, cumbersome process earlier, but now using GitHub CoPilot, the PR reviews have been absolutely done fast. It has helped a lot of PR reviewers in terms of reviewing the PRs.

The Agentic mode is something that I'm truly amazed by because the way it autocompletes the code and gives me the context awareness of the complete codebase, the inline autocompletions is something that I really look for in GitHub CoPilot to get help from. It is available in multiple language IDEs including Visual Studio, IntelliJ, and Cursor, which I use daily for my personal activities. In all the IDEs, I need not learn a new system to build systems. Visual Studio has GitHub CoPilot, IntelliJ has GitHub CoPilot, Cursor also has GitHub CoPilot, and Vimsurf has GitHub CoPilot. It has been an easy process in terms of adapting to the same thing over and over again. The context awareness is another feature that I am amazed by. Context awareness, inline autocompletions, rapid code prototyping, Agentic mode, and availability in multiple language IDEs are the best features of GitHub CoPilot.

The one thing that I am highly reliant on these days is the Agentic mode and inline completions since I take on a lot of development tasks. It would be tough for me to get into the code, but then I turn on the Agentic mode, give it the complete context of what I need, and it understands my context, relating it to the project context and starts building things. Agentic mode is something that I am heavily reliant on. The way it impacts the workflow is remarkable; earlier it was one feature in one week, but now I develop about seven features in a week. It's been a rapid prototyping and rapid production-grade code developed using Agentic mode.

Over the course of two years, GitHub CoPilot has been rolled out to all the employees out in ADP who are mostly developers. All the developers have it handy. Earlier, when it was in chat mode, everybody used it as a knowledge base. Instead of going into Stack Overflow, I was just asking my doubts in GitHub CoPilot and getting the answers. However, now that it has given us the Agentic mode, the kind of developments happening currently in all applications is so rapid, and the improvement in development and moving to production has increased over 15 to 200X times. Development that used to take a quarter or two quarters of time is now reduced to just 90 or 80 days. Every developer is on their toes, full of confidence because they are equipped with GitHub CoPilot and Agentic mode, which help them build things rapidly. It has heavily impacted us positively in terms of development, and the organization is very happy about it, with fruitful results too.

There is a lot of hallucination happening in GitHub CoPilot sometimes. On one side, it provides production-grade environment code, but on the other side, it lacks understanding the context of what I tell it. Instead, it hallucinates a lot. That's one con that I have in mind. Out of the AI tools I use daily, GitHub CoPilot does not really focus on UI a lot; it's less UI focused than other AI tools that I use. Probably these two are areas that should be improved by GitHub CoPilot.

The moment I prompt something in GitHub CoPilot, I believe it takes it into its system and builds a custom system prompt to analyze the complete prompt, breaks it down, and gets the response. However, in this process, it hallucinates a lot, which needs to be addressed. The second part is that the UI is vague compared to other AI tools, so the UI focus can be significantly improved. These are the two areas for improvement that I believe could be beneficial.

I have been using GitHub CoPilot for about two years now.

GitHub CoPilot is stable in all environments.

GitHub CoPilot handles workloads and larger teams excellently. Multiple people using it get a lot of immediate and exact responses useful for fixing issues, debugging, automating, or enhancing features. The scalability is skyrocketing.

The customer support for GitHub CoPilot is too good. Whenever there's a downtime of GitHub CoPilot or any issue with login or plugins, customer support is good enough to solve those issues. I would rate it 10 on 10 for customer support.

I would rate customer support 10 on 10.

Positive

GitHub CoPilot is something that I started with. There was no other AI tool I was using as a coding assistant. GitHub CoPilot is a primary pioneer that I would say in terms of the coding assistance I've used.

When I started using coding assistance two years ago, it was just GitHub CoPilot making a huge noise in the market. I chose GitHub CoPilot and stuck with it. Over time, it has been evolving and I use it daily, so I haven't really considered other options. I have been exploring other options too, but one thing I've stuck with in the organization is GitHub CoPilot.

There is absolutely a humongous return on investment with GitHub CoPilot in my organization. Earlier, it took about six to twelve months for an application development from scratch to production, but now it takes about two to three months, which is a rapid growth in the pace at which we develop applications. A lot of time is saved using GitHub CoPilot because the PR review process used to take two to three days, but now it takes about two to three minutes to analyze the complete PR, get context, and give the rating. This way, a lot of time has been saved. The company has rolled out GitHub CoPilot to all developers and has cut down on fewer employees—those not very adaptive in terms of AI—resulting in reduced employee numbers, increased revenue, and saved money. The pace at which we develop today is exceptional with GitHub CoPilot.

I would advise people to try out GitHub CoPilot in the free version. You would easily adapt to the Agentic mode and the chat mode. The way it understands the complete context of the project is awesome. I recommend starting with the free version and then buying a pro version to start building cool applications, wherein you get to know a lot of things that you never knew in your tech career. The moment you prompt it out, it builds a lot of features. Go check out your GitHub account, probably install GitHub CoPilot, and start building things. Importantly, have a detailed idea of what you need to build, and GitHub CoPilot will bring them to reality. I advise everybody to check out the free version, try it, and once they adapt to the environment, they can buy the pro version and start building cool applications and features.

One feature I missed mentioning earlier was the MCP servers, the Playwright MCP server accessible through GitHub. That's amazing for automation, which my team uses. The Playwright feature is captivating in GitHub. MCP servers is what I missed, and I feel I have spoken everything about GitHub CoPilot.

My overall review rating for GitHub CoPilot is 8.5.

We use GitHub CoPilot to automate boilerplate code and unit testing. For example, when a developer is handling a new API endpoint in Python, CoPilot suggests the entire data model and validation logic based on our existing patterns, generating a suite of Pytest cases in seconds, which has reduced our manual testing setup time by nearly 60%.

Regarding our main use case and other ways our team uses GitHub CoPilot, there is a remote sharing feature that CoPilot offers, allowing our remote teams to use shared knowledge bases where we index our internal documentation. This enables a remote developer in a different time zone to ask GitHub CoPilot chat questions about our specific internal libraries and receive answers grounded in our company's unique code standard.

The other main features that stand out for us include code privacy, vulnerability filtering, and IP indemnity, which are major features. The vulnerability filtering has a security filter that blocks common insecure code patterns, and GitHub provides an IP indemnity policy that protects our organization against potential copyright claims related to the AI-generated code. These are the standout features I believe are important.

GitHub CoPilot has positively impacted our organization by significantly improving developer happiness and retention, as it removes the drudgery of writing repetitive code, allowing our engineers to spend more time on creative problem-solving and system architecture. It has helped junior developers level up faster by providing real-time coding suggestions and explanations.

There were not many options for us before choosing GitHub CoPilot, as we were mostly relying on manual coding. Once we learned about the features GitHub CoPilot offers, we did not need to think twice and went directly to GitHub.

One metric I have noticed since adopting GitHub CoPilot is that once developers start using it, they are completing coding tasks 55% faster, which I consider a great achievement worth sharing.

I mainly use GitHub CoPilot for code suggestions, debugging, generating boilerplate code, and understanding unfamiliar libraries or frameworks while working on assignments and projects.

I was working on a programming assignment with a bug in my API integration, and GitHub CoPilot suggested the correct async handling and helped me identify a missing await statement, which saved me a considerable amount of debugging time.

The best features GitHub CoPilot offers are the real-time code suggestions, autocompletion, and debugging support. I also appreciate how it can generate boilerplate code quickly and help explain unfamiliar code snippets, which saves a lot of time while learning and coding.

The real-time suggestions from GitHub CoPilot are usually very accurate for common coding patterns and repetitive tasks. They help me write code much faster because GitHub CoPilot often predicts what I am trying to do after just a few lines. The autocompletion is especially useful for boilerplate code and function structures, and the debugging support stands out because it can suggest fixes or point out mistakes quickly, which makes troubleshooting less stressful.

I also appreciate that GitHub CoPilot supports multiple programming languages and integrates smoothly with IDEs such as VS Code, so it fits naturally into the workflow without interrupting productivity.

GitHub CoPilot has helped me become more productive and efficient with assignments and projects. I can complete coding tasks faster, spend less time on repetitive work, and focus more on problem-solving and learning how new concepts work. It also improved my confidence when working with unfamiliar technologies or frameworks.

It probably saves me around twenty to thirty percent of coding time on average, especially for repetitive tasks and debugging. It also improved my confidence because I can experiment with new frameworks or coding approaches more easily, knowing I have quick guidance and suggestions available while coding.

An improvement for GitHub CoPilot would be making the suggestions more accurate in complex or large-scale projects, especially when there are many dependencies. It could also be better at understanding full project context and giving more consistent explanations alongside code suggestions.

It could also improve in terms of explaining why a suggestion is made, not just providing the code. Better support for niche languages and deeper integration with project documentation or comments would also make it even more helpful for learning and collaboration.

I have been using GitHub CoPilot for one year.

GitHub CoPilot is generally stable for me, especially the in-line code suggestions in VS Code. I rarely run into major issues during normal coding sessions. That said, there are occasional reliability or performance hiccups, such as suggestions lagging, not loading briefly, or slower responses in longer chat sessions. These do not happen often, but when they do, restarting the IDE or starting a fresh chat usually fixes the issue.

In my experience, GitHub CoPilot scales reasonably well for my projects and multiple assignments. It continues to provide useful suggestions even in larger codebases, but the accuracy can drop slightly when the project becomes very complex and spans many files. For most coursework and mid-sized projects, it still performs well and stays helpful. For very large or highly interconnected projects, I usually have to rely more on my own understanding and use GitHub CoPilot as a supporting tool rather than fully depending on it.

I have not needed to reach out to GitHub CoPilot support directly. Most of the issues I have encountered were small setup or usage questions, and I was always able to resolve them. Overall, the documentation and online resources have been sufficient for my needs, so I have not needed to contact customer support.

Before GitHub CoPilot, I mainly relied on Stack Overflow, documentation, and basic IDE autocompletion. I switched to GitHub CoPilot because it provides real-time suggestions directly in the editor, which is much faster and more convenient than constantly searching for answers externally.

I did not do a formal comparison, but I was aware of tools such as Tabnine and ChatGPT for coding help. I ended up using GitHub CoPilot mainly because it integrates directly into my IDE and fits more naturally into my day-to-day coding workflow.

I would suggest using GitHub CoPilot as a support tool rather than relying on it completely. It is most effective when you already understand the basics and use it to speed up coding, explore ideas, or debug faster. Additionally, it is good to review its suggestions carefully so you can learn from them and avoid blindly accepting incorrect code.

My usual use cases for GitHub CoPilot include creating simple system architectures and getting input on using AI for building solution architectures. I also use it for a lot of test documentation and automation, and we have a lot of technical documentation that needs to be done based on the code. A little bit of code debugging is being done, but not extensively.

To write some simple codes, simple feature functionality code, and to debug that code is what we are using it for.

Efficiencies with GitHub CoPilot have improved by 30%, which means a quicker go-to market and a simplified way of documenting technical designs. The code itself has become better and more structured; we no longer wait for people to find the time to do proper documentation. It becomes a part of the process because it doesn't take too long to get that done.

The features I found most valuable in GitHub CoPilot include the ability to converse and find ways to solve problems. It's very helpful from a documentation perspective, as it helps me quickly and meaningfully document the code that has been written. Earlier, it was very manual and human-driven and took a lot of time. So, it is certainly time-saving; we have seen upwards of around 30% plus of time savings using GitHub CoPilot.

GitHub CoPilot offered slightly better performance in terms of output, and since we are already using GitHub for our code base, it makes sense to use what GitHub provides rather than using Perplexity and pushing code to GitHub while managing versioning and all that.

The areas of GitHub CoPilot that need improvement include the ability to debug, which is applicable to AI-driven tools that allow you to code, and to understand our application better and learn from it. This would likely require access to the entire code base, which a lot of companies may not allow. There's a lot that can be done regarding avoiding random errors that the system struggles to recover from.

It has been three to four months since I have been using GitHub CoPilot.

From the stability perspective, I would rate GitHub CoPilot eight. I rate it eight because at certain times, you may not get the required response and realize it's either down or not responding for other reasons. Broadly, I deduct two points from a response perspective or availability perspective. Maybe I'm being overcritical.

I think GitHub CoPilot deserves a scalability rating of six. I rate it six because regarding scalability, we think of enterprise-level development or coding that comes with huge complexities. AI still needs to catch up to a lot of that. It cannot build multiple data pipelines and architectures with multiple layers and microservices all on its own. It cannot be fully depended on to build every component and run a large enterprise application without significant human intervention.

I have not interacted with the technical support for GitHub CoPilot yet.

Neutral

Before GitHub CoPilot, we were tinkering with Claude and Perplexity. The most recent solution is Codex, and we are evaluating it in parallel with GitHub CoPilot.

I was not part of the initial setup of GitHub CoPilot.

For the maintenance of GitHub CoPilot, we have around 15 engineers who all have access and manage and maintain their code base. They don't have a specific role aligned only to managing CoPilot. We have 15 users for GitHub CoPilot in total.

Efficiencies with GitHub CoPilot have improved by 30%, which means a quicker go-to market and a simplified way of documenting technical designs. The code itself has become better and more structured; we no longer wait for people to find the time to do proper documentation. It becomes a part of the process because it doesn't take too long to get that done.

I honestly don't have a clue about how much we usually pay for GitHub CoPilot because the increase in license costs is managed by another team, and I am not the administrator, so I generally don't have these costs with myself.

GitHub CoPilot offered slightly better performance in terms of output, and since we are already using GitHub for our code base, it makes sense to use what GitHub provides rather than using Perplexity and pushing code to GitHub while managing versioning and all that.

I didn't buy this from the AWS Market Space or Marketplace in general. This was just us trying to figure out if there are better tools to manage product requirements and so forth, and that's how it was discovered and bought. At this point, I don't have any other tool that I have bought specifically through Amazon Marketplace.

Unfortunately, we don't have the privilege of learning new programming languages, given that we have a particular tech stack that we follow. However, we are better at debugging and understanding the structure and system to analyze if there are better ways to design the system or not.

We already have the standards practices defined. We didn't create any application from scratch with GitHub CoPilot. We already had an existing enterprise application with coding standards in place. If you can provide instructions on what coding standards to maintain and where a little leniency is acceptable, I feel that it follows the instructions pretty well.

Overall, I would rate GitHub CoPilot seven on a scale from 1 to 10.

My main use case for GitHub CoPilot is during my college project, specifically a capstone project titled a gym application, a fitness tracking system, where I am creating my fitness tracking application with React and Python and the database in MySQL. To create the application, I need some AI support, and I use my code editor as VS Code. At that time, I came to know about GitHub CoPilot, which provides AI features into the integrated IDE system. I installed GitHub CoPilot into my VS Code as an extension. As a file edit, I work with AI assistance. When I need to make some changes to my file, in the GitHub CoPilot chat, I tell it which kind of functionality I want, and then GitHub CoPilot generates it, directly adding it into my source file. I don't need to add it every time, and I don't need to give the prompt or problem sequence. For example, with ChatGPT, when I need a solution, I have to copy my command and my file and then give it to ChatGPT. There are some limitations; I can't provide it with large files or multiple files, and I always have to give it manually to ChatGPT to receive a solution that gets edited into my VS Code. However, GitHub CoPilot provides assistance directly in the IDE.

In my back-end development, I mostly work with GitHub CoPilot in my VS Studio code. I mainly use it for speeding up coding, solving errors, fixing bugs, and figuring out different kinds of logic. Sometimes I am unsure about what logic to use and what is best for a particular case. At times, I create logic and write scripts that are too long, lengthy, and time-consuming. That is when I turn to GitHub CoPilot's logic, which is easy to use, easy to understand, and also time-saving.

The best features GitHub CoPilot offers include functionality as a working tool and AI assistant that works alongside me. I don't need to manually add everything or explain everything every time; it finds out which file needs attention based on the problem statement I provide. It effectively helps in bug fixing and speeds up my coding work significantly. For example, what I create in one day, it can help me create in one or two hours. It gives real-time code suggestions and speeds up bug-solving. Additionally, it lets me decide whether to approve any code changes or reject them if I don't find them satisfactory. It proves to be helpful for my regular tasks. GitHub CoPilot also offers an easy and effective approach for how to use these kinds of tools.

GitHub CoPilot can be improved by making it easier, more impactful, and more accurate. While it provides good answers now, aiming for more accuracy would enhance its effectiveness. I need it to be excellent and free from any errors on my side, along with offering better understanding and explanations if that can be provided to the user.

GitHub CoPilot is stable at 100%.

GitHub CoPilot is fully scalable. At any given time, when there are multiple users utilizing GitHub CoPilot, it still provides fully accurate answers.

My advice for others looking into using GitHub CoPilot is that if you are a developer, you should try it for your basic and easy life during your coding journey. You will learn many things from it, and many easy tasks will become simplified in your everyday life. I give this product a rating of 8.

I use GitHub Copilot for various tasks, and its usage varies depending on the case and sometimes on the task itself. 

Occasionally, when I'm tasked with rebasing our entire codebase, I use Copilot to summarize the purpose of the file to gain an understanding of what the entire code is meant for. Afterward, I provide suggestions on how to minimize the codes and logic so that the code is refactored and redundant code is eliminated. This saves me a lot of time. Before using Copilot six months ago, the process was cumbersome as we used Chargebee, which required copying the code and pasting it into Chargebee. 

However, GitHub Copilot's extension is integrated into VS Code, making the process more efficient. By simply hitting a keyboard combination, I can communicate directly with the agent within the Code Editor. This integration makes the process seamless and easy to use, as it has the code context baked into the Code Editor.

Previously, when using other AI agents, I had to provide the code without the context of its usage or ultimate goals. These agents only checked the code for logic without understanding the bigger picture of the project. However, Copilot is integrated into my environment, providing the context and the bigger picture of how the code is used throughout the project. This makes the suggestions more helpful since the agent works better with more context. Copilot's integration saves a lot of time, which previously required cumbersome processes involving Chargebee. 

With Copilot, a keyboard combination brings up a chat interface, allowing direct communication with the agent within the Code Editor. This seamless integration has made it very easy to use.

In terms of improvements for Copilot, I haven't considered much since it offers many useful interactions. It integrates well with GitHub repositories, tracks changes on PRs, and provides valuable suggestions where applicable. There is excellent support across various code editors like JetBrains, VS Code, and NeoGen. I also run many automations within GitHub. When an NPR is raised, it automatically provides suggestions, which is part of the enterprise edition without limitations. 

While I don't see immediate room for improvement, one suggestion is for Copilot to provide specific suggestions for certain lines of code instead of rewriting entire sections. If the tool could focus on specific lines where changes are suggested, it would save time and reduce server load.

I have been using it for five to six months.

I would rate the stability a solid eight. As we are in the early phase of the AI boom, there are continuous improvements and modifications. While there is significant room for improvement and AI's fundamental nature sometimes leads to diverging topics, in most cases, it does not generate irrelevant code.

Scalability depends on the plan. With an enterprise plan, there are no limitations, so scalability is not an issue. As it is entirely cloud-based, scalability is inherent to the cloud infrastructure. I would rate it a solid nine out of ten.

GitHub's forum support and community are excellent. With a large user base, it covers a wide range of questions, from simple to complex, ensuring that answers are available. This community support proves highly useful whenever I have a doubt regarding anything. Even the smallest questions receive helpful responses.

The setup is straightforward. I mostly use VS Code and sometimes JetBrains IDE. Once logged into my GitHub account in VS Code, installing the Copilot extension is simple. I search for GitHub Copilot in the extensions, add it, and then sign in. It redirects me to the browser to authenticate with the GitHub token, confirming a successful login. The process is similar in JetBrains IDE, requiring extension installation and verification through GitHub login.

They recently made Copilot free to use up to a certain limit, which is a positive change. The pricing aligns with other AI agents like Chargebee and Anthropic Cloud. The ability to switch between models, such as GPT-4 or Cloudera, enhances its intelligence.

For Copilot's competitors, several exist, but they lack Copilot's flexibility and accuracy. Since GitHub hosts a vast portion of global code, its models are trained for better suggestions. Another solution, Cursor, offers an IDE entirely AI-based, which provides more context and control over files but differs from GitHub's concept and isn't a direct competitor.

Based on my current experience, I would give Copilot a solid nine out of ten due to its automation capabilities and integration into workflows. 

It streamlined and robustly automated processes that previously took days and encountered many errors. Copilot is highly recommended for everyone. Some perceive it as a job-threatening tool, however, I see it as a time-saving and convenient aid, similar to modern technologies that replaced older methods. The tool is now free for everyone, and I urge others to take advantage of its benefits. 

We use GitHub Copilot to enhance our productivity while coding. While GitHub itself serves as our code repository, Copilot provides suggestions and reviews as we work on our code. Copilot's effectiveness depends on the quality of its training data and how we integrate it into our workflow. It offers valuable feedback and performs various types of analysis, including statistical and dynamic, to help ensure code quality before it goes into production.

The effectiveness of GitHub Copilot depends on the number of transactions and your subscription plan. Copilot performs well with generic use cases, but the training dataset also influences its performance. For instance, companies with client-server architectures can benefit from Copilot as it learns from exposure to more repositories and user feedback. The more you interact with Copilot and provide feedback, the better its suggestions become.

GitHub Copilot can improve productivity by up to 40%, especially for experienced developers. Senior developers often spend more time reviewing code, which can make the code review process a bit longer.

It comes out with more unique codes; the training dataset needs to be larger.

Logical coding is better done by a human being. It can be improved.

The limitation is based on the training dataset and the number of repositories. The migration can be a little easier for people to do it. Also, the lack of awareness and understanding of what Git is and what GitHub is can be handled quickly. There could be more awareness.

I have been using GitHub CoPilot for over a year.

I have not faced any stability concerns because it's not a large base. If there are concurrency issues with multiple people doing the same thing simultaneously, it is for a mid-sized or a large bank.

You can scale GitHub. I've used it for 300, but other companies are looking at thousands. It has a lot of potential to expand its user base, as indicated by its roadmap.

The initial setup is peaceful. I have not personally installed it. I've installed only the GitHub. The Copilot is more at the server level.

It doesn't take much time. The configuration is pretty much relatively simple.

It saves 40 percent of the cost. For productivity, it's close to about 70 percent.

Copilot costs around $20 per month. While it's currently priced at $20, startups or organizations may be able to get a better rate, particularly for enterprise licenses, which might be available at a lower cost, such as $19 or $18. At the moment, there isn’t a direct competitor offering a similar product at a lower price.

If you're considering a complete CI/CD pipeline, you'll need to integrate various tools such as Jenkins for builds and ensure connectivity with platforms like AWS or Azure. All these aspects must be managed effectively. Therefore, it's essential to have a dedicated configuration management team to oversee and maintain the pipeline.

We're working on developing our in-house AI tool. GitHub Copilot, closely integrated with Microsoft products like .NET, offers extensive support for various programming languages. For example, it supports a wide range of languages, while a customized tool might only cover around seventy percent of the same range.

It definitely can do a little bit of statistical analysis and give recommendations.

I would recommend considering GitHub Copilot. If you already use another tool, be aware of the migration effort required to switch to Copilot. Assess the process of adopting and onboarding Copilot to ensure a smooth transition. If you're moving from one tool to Copilot, you'll need to evaluate the migration effort involved. It’s essential to have early adopters to facilitate this process.

Overall, I rate the solution a nine-point five out of ten.

I use GitHub CoPilot for cybersecurity practices. I am not a developer, but I use it to build MCP tools directly in the codebase.

My goal was not to learn programming but to utilize the tools effectively.

GitHub CoPilot is easy to set up as it only requires enabling certain settings.

An improvement would be integration with different IDEs beyond VS Code, as it is currently only supported by VS Code.

GitHub CoPilot should be integrated with different IDEs beyond VS Code, as it is currently only supported by VS Code.

I have worked with GitHub CoPilot for the past 12 months.

GitHub technical support is excellent. I would rate it ten out of ten.

Positive

Setting up GitHub CoPilot is straightforward as it only requires enabling specific settings.

I am not fully aware of the pricing details as my company manages it, but I recall it was not inexpensive.

I am an AppSec Engineer and end-user of GitHub solutions. My email address is m.alasfar@eastnets.com.

On a scale of 1-10, I rate GitHub CoPilot a 9.

I can get suggestions by giving some prompts for code generation and code validation. And even when we need to understand already written code, we'll use it to explain.

Sometimes, we are able to get benefits from understanding the existing code, writing new code, and even validating our already written code.

So, Copilot enhanced our productivity through its AI capabilities.

Code generation is the most helpful feature. It's easy to use.

Sometimes, if it is a bigger piece of code, it breaks in between. So the performance could be improved.

Sometimes it requires some manual validation, whether the given result is correct or not. Maybe it should be more accurate.

I have been using it for six months. 

It's good. I didn't try increasing the number of users or anything as such, but it's working well.

In my organization, almost 200 to 300 people use it.

The initial setup is straightforward. No issues. It took a couple of minutes, not more than that.

We haven't deployed it in any special way. We just installed it, and we are using it.

The number of people required for setup depends on the project size.

We saw at least 20% ROI, we are able to get the benefit of using Copilot in our day-to-day life.

Overall, I would rate it a nine out of ten. But it still has a long way to go.

I would recommend it to others.