How To Use GitHub Copilot for Efficient Code Generation

Writing code, debugging, testing, and pushing apps into production are time-intensive tasks. Trying to find sources of different errors in your code can eat into your productivity, especially if you’re a beginner. But there’s a way to ease this process.

GitHub Copilot is an AI pair programmer that can assist by generating boilerplate code, completing code snippets, and suggesting code based on comments or function names. GitHub Copilot’s collaboration with OpenAI and Microsoft allows it to use the advanced GPT large language models (LLMs) behind ChatGPT.

Integrating GitHub Copilot into your software development workflow can help you save time, write better code, and learn new programming approaches and techniques. We explain how you can use GitHub Copilot for efficient code generation.

How does GitHub Copilot work?

GitHub Copilot is a form of generative artificial intelligence (AI) that’s capable of producing various responses like code, text, and synthetic data, depending on user inputs.

Powered by OpenAI’s Codex model and natural language processing (NLP), GitHub Copilot analyzes different files and comments in code and provides auto-complete suggestions in an integrated development environment (IDE). The Codex model is trained using various programming languages like Python, Java, TypeScript, C++, JavaScript, PHP, and Ruby—enabling GitHub Copilot to provide valuable insights within different software projects.

Since GitHub Copilot has been trained on past data from public repositories, it can use its machine learning algorithms to provide suggestions to improve coding tasks. As a result, it can generate real-time code suggestions, including code snippets, entire functions, and even unit tests.

How to write code with GitHub Copilot

From installation to writing code in your IDE, we provide steps to get you started with GitHub Copilot.

Note: We’ll primarily use VS Code in this step-by-step tutorial to keep things simple and help you gain a faster understanding of this AI-powered tool.

1. Install GitHub Copilot

Before using GitHub Copilot, you’ll need a GitHub account to activate your subscription.  If you don’t have an account, sign up.

You can choose between two pricing plans (Individuals and Business). Fortunately, GitHub Copilot offers a free trial, which you can use to test out its features before committing.

GitHub Copilot provides an extension that you can integrate into IDEs like Visual Studio Code to access its core functionalities. However, you’ll need VS Code version 17.5.5 or newer.

1. To get started, launch VS Code on your computer.

2. Click on the Extensions icon to navigate to the Visual Studio Marketplace.

3. The Visual Studio Marketplace should display as follows:

4. Search for GitHub Copilot from the marketplace.

5. Click on the first extension with the description “Your AI Pair Programmer.”

The homepage of the GitHub Copilot extension should open in the adjacent window.

6. Press the blue Install button to add the extension to VS Code.

If the installation is successful, GitHub Copilot will appear as follows:

2. Authenticate your session

You’ll need to link your GitHub account for authentication, tracking your usage, and billing purposes. If you’re new, navigate to “github.com” to create one. Note that you’ll need a good internet connection for a successful authentication.

If you’ve used GitHub before in VS Code, the authentication will be completed automatically. But if you haven’t, you’ll need to sign in to activate Copilot.

1. In VS Code, click on the Profile icon on the side navigation bar, then select Sign in with GitHub to use GitHub Copilot.

2. You’ll be directed to a browser with a pop-up window (this only works if you’re already logged in to your GitHub account on your browser).

3. Grant the permission and click the Open Visual Studio Code button.

3. Initiate your first coding session

If you’ve successfully installed and authenticated GitHub Copilot, you should see the following icon on the bottom right section of VS Code.

By default, the GitHub Copilot extension is enabled globally. This means you can use it for any project in VS Code without having to enable it every time.

To turn off the global setting, click on the GitHub Copilot icon and then press the Disable Globally button.

Now that we know some of GitHub Copilot’s basic settings, let’s start a new coding session.

1. Create a new project folder and then open it in Visual Studio Code. In our case, we created a folder named code and then opened it in VS Code.

2. Next, create a new file in the project folder based on the programming language you’re using. In this example, we’re working with JavaScript, so we’ll label our file as index.js. GitHub Copilot can automatically detect the programming language you’re using in the project.

3. You can now start typing code to interact with GitHub Copilot. For instance, we added the comment “generate a function that calculates the next leap year” to our file.

4. You can activate GitHub Copilot to generate the code by pressing the Enter key on your keyboard twice. It produced the following code:

5. To accept the changes, use the Tab key. This will also enable GitHub Copilot to complete the function.

6. GitHub Copilot can also provide code suggestions as you type to help complete different lines of code. To illustrate, it helped us complete the following declaration:

You can integrate the above code suggestion in a file by using the Tab key on your keyboard.

7. GitHub Copilot can also help explain what specific code does. To do this, highlight the unclear code and press CTRL+/ to access the Chat functionality and then use the command /explain.

4. Use real-time code suggestions

GitHub Copilot offers a real-time code suggestion feature. With NLP technology and AI models running behind the scenes, it can process, predict, and suggest code as you type.

To illustrate, we wanted to create a function that could reverse a number in JavaScript. So, the first step was to invoke the function and then write the code logic. GitHub Copilot provided useful and real-time code suggestions throughout this process.

1. GitHub Copilot helped us pass a value to a function and then call it.

2. GitHub provided real-time code suggestions, enabling us to complete the actual function. We clicked the Tab key to accept the generated function.

The above real-time code suggestions enabled us to save some development time.

In a large project, the benefits of GitHub Copilot can even be more noticeable, especially when it comes to filling boilerplate code and auto-completing various statements. And since GitHub Copilot is trained on large data sets, it can provide code suggestions that feature best practices from the works of other developers.

But if you don’t like the generated suggestions, you can continue typing to skip or ignore them.

‍‍

5. Refine code suggestions

While GitHub Copilot features some advanced capabilities, it’s not perfect. It can sometimes produce inaccurate content—and even introduce errors and bugs into your code. In other cases, it can generate code that simply doesn’t fit your use case. So, always review the code suggestions for accuracy and relevance.

Once GitHub Copilot has provided code suggestions, you can modify and fine-tune the suggestions to suit your project requirements. For instance, you may have to change variable and function names, add certain comments, invoke functions in different places and modify what they return, and even revise certain logic—like rather than using lists, you can change to arrays.

You should also ensure the generated code adheres to the coding standards and practices of your project. This calls for an in-depth manual review. For example, if GitHub Copilot used certain libraries and frameworks that don’t fit into your project, you may have to go back and use compatible ones.

You can review code suggestions in a separate window by writing a comment and then clicking CTRL+Enter on your keyboard. The suggestions will appear as follows:

6. Explore programming language specifics

Based on its training data, GitHub Copilot can support different programming languages like JavaScript, Python, Ruby, and Java. It’s also compatible with various software development frameworks like React, Angular, and Django. GitHub Copilot works exceptionally well in certain programming languages like Python and JavaScript due to the nature of its training data.

GitHub Copilot can adapt its code suggestions based on your selected programming language or framework. Whether you’re working with Python or Java or using frameworks like Django and React, you’ll be able to access code suggestions to boost your development speed and enhance overall code quality.

To illustrate, we created a new file in the project and named it main.py—meaning we’ll be working with Python. We then proceeded to create a simple function to calculate the sum of numbers in a list.

Even though we’re working with a new programming language, GitHub Copilot still provides proper syntax and code suggestions.

‍

Tips for creating prompts for GitHub Copilot

While GitHub Copilot can help transform your coding experience, you’ll want to know how to use it properly to get the best results. We offer some tips to assist you in harnessing the power of GitHub Copilot.

• Grasp prompt basics. A good GitHub Copilot prompt should be clear, concise, and detailed enough to allow it to get valuable information to process your inputs accurately. For instance, don’t just say “create a function” but rather go into detail with a prompt like “create a function called nextLeapYears() to calculate the next leap years starting from 1990.”
• Maintain explicitness and clarity. Using vague prompts in GitHub Copilot may get you inaccurate or irrelevant results. For example, a prompt like “create a database connection” may yield an irrelevant result since GitHub Copilot doesn’t have enough information to process your request. In this case, an example of a good prompt might be “create a database connection using the Java drivers that connect to a MySQL database.”
• Incorporate context. When writing prompts, including context provides GitHub Copilot with more information regarding what you want to generate, facilitating more accurate and relevant code suggestions.
• Use comments for additional information. Detailed text descriptions can allow GitHub Copilot to generate outputs that are much closer to what you’re looking for. Using comments within the code is a good way to convey extra information.
• Experiment with different prompt structures. Prompts can produce varying results. So, experiment with different prompts and review the results to determine the best fit.  An alternative to a prompt like “generate a function that reverses the order of elements in a list and stores them in a new list” is “Write a function called reverse_list() that takes a list as input and returns a new list with the elements in reverse order.”
• Engage in continuous improvement. Enhancing your prompts over time can help you get more accurate results. To do this, use feedback from GitHub Copilot to refine your prompts.

FAQ about GitHub Copilot

Integrating GitHub Copilot into your workflow can lead to benefits like better code quality and time savings. We provide answers to FAQ to improve your understanding of this platform.

Can I use GitHub Copilot on other IDEs besides VS Code?

GitHub Copilot is compatible with other IDEs like Azure Data Studio, Vim, and Visual Studio. It also supports JetBrains IDEs.

Is there a way to use GitHub Copilot for free?

For long-term free access to GitHub Copilot, you must be a verified student, teacher, or maintainer of popular open-source projects. Otherwise, there’s a free one-time, 30-day trial you can use to test GitHub Copilot’s features.

What are the advanced features of GitHub Copilot, and how can I access them?

GitHub Copilot provides other plug-ins like Copilot Nightly, Copilot Chat, Copilot Labs, and Copilot Voice you can use for code generation, debugging, and refactoring. For example, you can use the “/explain” command in Copilot Chat to generate insights regarding how specific code works.

Apart from the extensions, GitHub Copilot can be used for different use cases, such as creating REST APIs, improving code base docs, and writing algorithmic functions.

Make your software development more productive with AI

GitHub Copilot is a tool that can save you time and increase your productivity. With Copilot’s suggestions, you can complete your code faster and even learn better ways of implementing various concepts in a software project.

However, GitHub Copilot can still produce inaccurate and irrelevant code snippets and suggestions. You’ll need technical expertise to review the suggested code, edit and modify the outputs, and include only those responses that fit your projects. Consider working with GitHub Copilot specialists on Upwork to help you harness the power of GitHub Copilot and other AI tools.

And if you’re an AI specialist looking for work, Upwork can connect you to various GitHub Copilot jobs to help you develop your portfolio and earn extra income.

‍

Upwork does not control, operate, or sponsor the tools or services discussed in this article, which are only provided as potential options. Each reader and company should take the time to adequately analyze and determine the tools or services that would best fit their specific needs and situation.