AI Coding Assistants Explained: GitHub Copilot under the microscope

GitHub Copilot is created by GitHub and OpenAI, and it is a tool for code completion, code generation, and analysis. It assists users of Visual Studio Code, Visual Studio, Neovim, and JetBrains’ integrated development environments (IDEs) by providing code autocompletion and additional features.

Utilizing machine learning techniques, especially through models like Codex, which is based on GPT, provides code suggestions as you type. With training on billions of lines of publicly available code, Copilot is well-versed in a variety of programming languages and frameworks, acting like an “AI pair programmer” aimed at reducing repetitive coding tasks and boosting your productivity.

The top 5 Features (Uses) of GitHub Copilot are:

1. 1. Code Completion and Suggestions—Copilot provides real-time suggestions while you type; it ranges from single lines to complete functions. Ideal for boilerplate code, frequently used algorithms, or configuration files.
   2. Context-Aware and Code Generation—Comprehends the context of your project, including variable names, comments, and function signatures. You can write a comment such as // retrieve user by ID from database, and Copilot will create a corresponding function.
   3. Language and Framework Versatility—Accommodates a broad spectrum of programming languages: JavaScript, Python, TypeScript, Go, Ruby, C#, Java, etc. Functions effectively with frameworks like React, Angular, Django, ASP.NET, Node.js, and others.
   4. Learning and Exploration—Beneficial for acquiring new languages or APIs by providing idiomatic code examples. It serves as a live reference tool, minimizing the necessity to switch to browser-based searches.
   5. Test Generation (Partial Support)—It can assist in scaffolding unit tests based on your current code or comments. It is valuable in TDD workflows or for incorporating tests into legacy code.

GitHub Copilot is evolving day by day, and it is getting more and more features and capabilities. As we speak, these are the most common and known features that it offers:

1. Code Completion & Generation

• Autocomplete entire functions: It can fill in whole functions based on just the name and a few comments or lines.
• Suggest inline code: You’ll get smart suggestions while you type, especially for loops, conditions, and API calls.
• Create repetitive code faster: For instance, it can quickly generate DTOs, serializers, or data classes.

2. Boilerplate and Scaffolding

• Generate typical code patterns: Such as REST API routes, database queries, or form validations.
• Build UI components: It helps with the HTML/JSX structure, CSS classes, and event handlers in frameworks like React or Angular.
• Setup configuration files: It can create .gitignore, Dockerfile, package.json, and more.

3. Test Case Generation

• Unit test stubs: Automatically creates test cases based on method names using popular test frameworks like xUnit, JUnit, Jest, and others.
• Edge case suggestion: Copilot often brings up those rare but important test cases that you might overlook.
• Mocks/stubs generation: Useful for services, repositories, or API calls.

4. Comment-Driven Development

• Just write a comment like `// fetch user by ID from API`, and Copilot will suggest the actual code for you.
• This feature works seamlessly across various languages, including Python, JavaScript, TypeScript, C#, Go, and more.

5. Code Refactoring Assistance

• Suggest improved patterns: Helps refactor imperative code to utilize LINQ, map/reduce, or async patterns.
• Suggest smaller helper methods: Breaks lengthy methods into smaller, logically grouped ones.
• Rename and restructure: While Copilot doesn’t refactor like an IDE, it does offer better alternatives when you’re rewriting method signatures.

6. Learning & Code Explanation

• While Copilot doesn’t provide direct explanations for code, you can add a comment above your code, such as // Explain what this function does, and Copilot might give you a summary.
• This feature is particularly handy for onboarding new team members or getting a grip on legacy code.

7. Language and Framework Translations

• Seamlessly migrate coding patterns between languages: for instance, converting a JavaScript function to its Python equivalent.
• Adapt frameworks easily: like transforming Express.js routes into FastAPI equivalents, all driven by prompts.

8. Writing Simple DevOps Files

• Quickly create GitHub Actions workflows: just start with a comment like # deploy to Netlify on push.
• Generate basic configs for Dockerfiles or Kubernetes manifests in no time with Copilot’s help.

What Copilot Can’t Do (or Not Well)

• Provide in-depth explanations of why certain code works
• Handle large refactoring that involves multiple files or significant architectural changes.
• Deeply understand the context of files or projects: Copilot is limited to the open file and a few adjacent tabs.

Like any other tool from the market, GitHub Copilot acts under specific terms and conditions which strongly depend on the license type that is chosen.

For any AI-based tool that is involved in coding, privacy is a concern. The questions that come around all the time are the following:

• Will my code be used to train other LLM’s?
• Is my code legal? Does GitHub Copilot generate code that is compliant with the license type of my software?

To answer these questions, it is important to understand how GitHub Copilot was built and what it actually does. Here is a brief description in this regard:

• GitHub Copilot is built on models that have been pre-trained using public code (like the public repositories available on GitHub).
• When you use it, your code isn’t sent back to retrain the model.
• However, some code snippets might be sent to GitHub’s servers to help generate suggestions.

Thus, if you are working on commercial software the only two type of licenses that you can use for GitHub Copilot are:

• Business
• Enterprise

Both ensure what GitHub calls “Copyright Shield”. Meaning that the usage is safe from all perspectives.

Although the usage of GitHub Copilot is safe when used with the proper license, there are some key caution points that the developers must be aware of:

1. 1. Avoid leaking sensitive data—It’s important to avoid using Copilot or any AI assistants for handling sensitive information such as API keys, proprietary algorithms, credentials, or customer data.
   2. Generated code may be insecure or incorrect—AI suggestions can sometimes miss the mark, be inefficient, or even pose security risks. Always take the time to review and test any AI-generated code, especially when it comes to critical systems.
   3. License ambiguity—Keep in mind that Copilot might occasionally produce code that looks like open-source content with strict licenses (like GPL). So, if you’re working on commercial or proprietary software, proceed with caution.
   4. Compliance and data residency—For industries that are heavily regulated, like healthcare and finance, make sure that your use of AI tools aligns with data residency requirements and company security policies.
   5. Don’t Rely on AI for Domain Logic—AI is great for tasks like boilerplate code, refactoring, and testing, but it shouldn’t take the place of domain experts or in-depth logic design.

When it comes to using AI effectively, here are some best practices to keep in mind:

• If necessary, turn off telemetry and logging to minimize external exposure of your code.
• Always write tests for your AI code; this way, you can catch any bugs or risky behaviors early on.
• Don’t forget to add comments to clarify your intentions—some code needs a bit of explanation, and AI might not always grasp those tricky edge cases.
• Incorporate AI into your code review processes; it can provide helpful hints, but remember, human judgment is key.
• AI suggests rather than auto complete, so you are actually responsible for reviewing and accepting any code it generates.

So, here’s the million-dollar question… Is AI the ultimate game-changer for developers?

While the answer is more in the gray area, one thing is certain: it definitely boosts their skills.
However, AI isn’t meant to take over the role of developers; rather, it’s becoming an invaluable tool in their toolkit.

1. Speed and Efficiency

• AI can whip up boilerplate code, test stubs, SQL queries, and configurations in just seconds.
• What used to take minutes or even hours can now be done in seconds.
• This allows developers to concentrate on design, logic, and innovation instead of getting bogged down by syntax or repetitive tasks.

2. Instant Knowledge

• AI offers on-the-spot examples and explanations for any APIs, frameworks, or languages you might not be familiar with.
• It’s like having a personal mentor or a handy reference guide right in your IDE.

3. Supercharged Debugging and Refactoring

• It can break down errors, suggest fixes, and even help you refactor code in bulk.
• This is a game-changer when you’re working with legacy code or managing large codebases.

4. Accelerated Learning

• New developers can pick things up quicker by recognizing patterns, asking questions, and getting context for their code from AI assistants.
• It’s a more engaging way to learn, rather than just passively reading through documentation.

5. Creative Exploration

• You can prompt AI to prototype different options, come up with various solutions to a problem, or quickly test ideas.
• It’s perfect for brainstorming sessions or when you hit a coding roadblock.

But… It’s not all magic. Even superheroes have their vulnerabilities. Here’s the reality check:

• Fast code generation—Risk of incorrect or insecure logic
• Broad API knowledge—No deep domain understanding
• Productivity boost—Can lead to over-reliance or shallow coding habits
• Helpful explanations—May hallucinate or make up info

AI is a game-changer for developers who:

• Think critically and don’t just take suggestions blindly.
• Leverage AI to tackle routine tasks, freeing them up to focus on what really matters.
• Keep their human judgment, domain expertise, and creative thinking at the forefront.

When it comes to coding, AI in general and GitHub Copilot in particular act as empowerment for us as developers — boosting our efficiency. In other words, we are using it not to avoid work, but to enhance it.

Last but not least, we are responsible for the quality, security, and legality of the code produced.