Tips on Using GitHub Copilot to Become More Efficient at Programming

Thanks to GitHub Copilot, programming has never been easier. It speeds up the development of some of the most complex apps while working alongside you. However, you still control the process, including how much benefits you get from using the tool, and there are many ways to improve your Copilot skills.

Here are 14 tips on how to be more efficient at programming using GitHub Copilot.

Tip No.1 – Provide Better Context

Copilot needs relevant prompts to generate functional—and even more importantly, desired—code, so be sure to contextualize your prompts. Explain to your Copilot what you want to achieve with the code in the comments section.

If you have ready-made files about the app you’re working on, upload them to the system to expand the context. Elements like expected behavior, variable names, and function signatures will give the system a clear picture of the desired result.

Tip No.2 – Check Code

Copilot is powerful but not almighty. Depending on your input, it delivers varying quality of code, requiring you to monitor the system. Sometimes, it’ll provide you with 100% nonsense. Other times, it’ll generate multiple correct versions for you to choose from.

This is where you step in. It takes an expert to separate the wheat from the chaff and figure out if you can actually use the code just by looking at it. If you’re not a proficient developer, you might not be able to tell valuable from useless code. You can observe the mistakes when testing the app, but this is time-consuming.

That’s why you should constantly elevate your programming skills rather than let Copilot lull you into a false sense of security.

Tip No.3 – Use Shortcuts

Copilot has many features to speed up your programming, one of which is the built-in shortcuts. Here are some of the most common ones:

• Ctrl + Enter – opens 10 suggestions in a different pane
• Option or Alt + \ - triggers a suggestion
• Option or Alt + [ - shows the previous suggestion
• Option or Alt + ] – shows the next suggestion
• Esc – dismisses an in-line code suggestion
• Tab – accepts an in-line code suggestion

Tip No.4 – Set Examples

There’s a reason GitHub Copilot is called a copilot and not a pilot – it can only work alongside you. That’s why you should provide the system with examples of code you expect the AI to reproduce. Over time, Copilot will mimic your patterns and analyze any corrections you made. This will enable it to apply your coding style and make your programming even more efficient.

Tip No.5 – Use Copilot Labs

You may often encounter unfamiliar code in Copilot, and the best way to explore the uncharted territory is to use Copilot Labs. Think of Copilot Labs as a knowledge base. Once you install the extension, you’ll see it as a sidebar with four features:

• Code explanations – Highlight code and ask Copilot to explain it in simple terms.
• Creating custom prompts – Customize the four built-in prompts to create your own applications.
• Translating code – Highlight code, choose the language you want the system to translate it into, and press “Ask Copilot” for a quick translation.
• Test generation – Point Copilot to a function in your code, and it’ll start a unit test based on the data in the code or doc comments.

Tip No.6 – Be Consistent

You typically only use one programming style in a particular project. It’s important to adhere to it, especially when coding in Copilot. The reason is simple – Copilot works by replicating your style. If you mix different approaches, you may confuse the system and make it less accurate.

Tip No.7 – Rely on Copilot’s Translation Capabilities

Git is based on English, which can be a problem if this isn’t your native language. But not with Copilot by your side. Since it was built on OpenAI Codex (a descendant of GPT-3), which was trained on many natural languages, it can understand and respond in non-English queries.

If you don’t know how to explain a concept in English, you can use a different language when prompting Copilot, and it will provide the answers. Additionally, it will autocomplete common programming phrases to the language you used (so “import” becomes “importar” in Spanish).

Tip No. 8 – Let Copilot Perform Repetitive Tasks

Copilot’s main purpose is to provide code suggestions. But it also offers to auto-fill your prompts. As you code, the system harnesses its knowledge database to deliver relevant recommendations and complete your snippets.

Even though Copilot isn’t entirely polished, auto-completion is one of its better and most consistent features, which is why Copilot should remain in charge of this. Allow the platform to finish repetitive code so you can focus on other, more complex tasks.

Tip No.9 – Go Through Comments

One of the reasons you enjoy coding is that it lets you use your advanced problem-solving skills. However, there are other, less fun parts of the job – leaving comments on your code and compiling documentation. The good news is that Copilot can handle these tedious tasks, but it’s not always accurate.

You’ll need to scan every comment and document created by Copilot to ensure they’re relevant and comprehensive. Check for detailed explanations of algorithms and provide feedback whenever necessary. In some cases, you may need to leave comments and craft documents yourself to make your apps more understandable.

Tip No.10 – Don’t Neglect Security

Although Copilot is intuitive, it might not be aware of your security practices. As such, it may auto-fill code without following your protocols, which can lead to security weaknesses.

The only way to find these weak spots is to look for them manually. Check and address improper data handling in your code to prevent information leaks. Copilot will note your feedback and be less likely to make the same mistake twice.

Tip No. 11 – Use Copilot to Automate Commands

Auto-filling is where Copilot shines, especially if you want to auto-fill commands. As you enter the first part of your command, Copilot examines the context to generate a relevant suggestion and provide the desired command.

This feature is especially useful for Git commands:

• git init – turns your directory into a blank Git repository
• git add – adds new or changed files in the working directory to your staging area
• git commit – records the edits made to files in your local repository
• git status – returns the state of your repository
• git config – assigns configurations or settings
• git branch – determines the branch of your local repository or adds/deletes a branch
• git checkout – switches branches
• git merge – fuses branches together
• git clone – creates a copy of your source code from a remote repository
• git push – pushes any committed file change from a local to a remote repository for other users to access
• git pull – retrieves the latest changes from a remote repository to a local repository

Another great thing about writing commands in Copilot is that the system doesn’t limit you to Git commands only. It can generate pretty much any command based on your context.

Tip No. 12 – Leverage the Tool’s Potential to Accelerate Web Development

If you’re a web developer, Copilot can be a real ace up your sleeve. It has a few notable features to help you work faster:

• Error handling and form validation – You can use Copilot to auto-fill code for error handling, data sanitization, and form validation.
• Framework-specific programming – Another impressive feature of Copilot is that it adapts to many frameworks, including Angular, Vue.js, and React. Based on your prompts, the platform can generate snippets for state management, routing, components, and many other aspects.
• CSS/HTML templates – Gone are the days when you had to create manual CSS and HTML templates. Copilot can do the work for you. Simply describe the responsive design, layout, or any other web component, and let Copilot generate the desired code.

Tip No. 13 – Feed Copilot Small Chunks of Information

When working in Copilot, it’s better to code smaller elements of your application at a time instead of trying to program an entire app in one go. Why? Because longer prompts are more likely to produce vague results, and the AI might reword it, losing some context in the process.

To maximize your Copilot productivity, feed the system small chunks of information. It’ll keep the context relevant, enabling Copilot to generate more accurate code.

Tip No. 14 – Open All Relevant Tabs

Copilot uses the neighboring tabs technique to refine your code. Opening all tabs related to your application allows Copilot to access all the relevant data and find matching code snippets. This further expands the available context and increases Copilot’s accuracy.

Become a Copilot Mastermind

When you first start using Copilot, it may be tempting to sit back and let the platform do most of the work without any input on your part. Don’t give in to this temptation. Remember – Copilot is merely an assistant. Only when you provide it with valuable context does it produce the desired results. It also requires double-checking to ensure consistent code and informative documentation.

Besides refining Copilot, don’t forget about your coding skills. Stay up-to-date with the latest programming languages and see if you can incorporate them into Copilot. The more you know, the easier it is to harness Copilot’s power.