Coding with an AI pair programmer: Getting started with GitHub Copilot

1 Dec 202329:53

TLDRChristopher Harrison, a senior developer advocate at GitHub, discusses GitHub Copilot, an AI-powered code completion tool. He emphasizes that Copilot is a tool that feels magical but operates based on the context provided by the user. Harrison provides insights into how Copilot works, sending code context to GitHub for suggestion generation. He offers practical tips for maximizing Copilot's effectiveness, such as clear commenting, being flexible with suggestions, providing examples, and maintaining good coding practices. The session includes a live demo of building a Django model and views, highlighting the importance of specificity and flow in interaction with the tool.


  • 👋 Introduction to GitHub Copilot as a suite of tools primarily focused on code completion.
  • 🧠 Understanding that GitHub Copilot works by sending context to the IDE and generating suggestions based on that information.
  • 🔍 Clarity on what 'context' means for Copilot, including the entire file being worked on and open tabs in the IDE.
  • 📝 Emphasizing the importance of 'prompt crafting' to effectively communicate intent and desired outcomes to GitHub Copilot.
  • 🎯 Focusing on the four components of prompt crafting: context, intent, clarity, and specificity.
  • 📌 Describing the goal at the top of the file to provide a clear direction for GitHub Copilot.
  • 💡 Being flexible with GitHub Copilot's suggestions, as it operates on probabilities and may vary its outputs.
  • 🌟 Providing examples to guide GitHub Copilot in generating the desired code snippets.
  • 🔧 Following best practices in coding, such as proper naming conventions, to ensure GitHub Copilot aligns with your coding style.
  • 🌐 Keeping relevant files open to provide additional context for GitHub Copilot's suggestions.
  • 🚀 Embracing the flow and adapting to GitHub Copilot's assistance to maximize productivity.

Q & A

  • What is GitHub Copilot and how does it function?

    -GitHub Copilot is a suite of tools primarily focused on code completion. It generates suggestions for code and comments based on the context provided by the user's current work. The context includes the entire file being worked on, as well as open tabs in the user's editor. GitHub Copilot sends this context to OpenAI models, which then generate and return suggestions to the user's IDE.

  • How does GitHub Copilot use the context provided by the user?

    -GitHub Copilot uses the context to understand the user's coding intent and environment. It considers the entire file being edited, including all tabs that are open in the user's IDE. The tool prioritizes the files most relevant to the current task by starting from the tabs closest to the one the user is actively working on.

  • What is the significance of the file being worked on and open tabs in GitHub Copilot's functionality?

    -The file being worked on and the open tabs provide GitHub Copilot with the necessary context to generate accurate code suggestions. The entire content of the file, not just the part around the cursor, is considered. Open tabs indicate the files that are most relevant to the task at hand, helping Copilot focus on providing suggestions that are most useful to the user.

  • What is meant by 'prompt crafting' in the context of GitHub Copilot?

    -Prompt crafting refers to the process of phrasing comments and code in a way that effectively communicates the user's intent to GitHub Copilot. This includes being clear, specific, and providing examples to help the tool understand what the user is trying to achieve, thereby improving the relevance and usefulness of the suggestions provided.

  • How can users ensure that GitHub Copilot provides the most relevant suggestions?

    -Users can ensure more relevant suggestions by providing clear and specific prompts, including examples, and structuring their code and comments in a way that clearly communicates their intent. Additionally, users should manage their open tabs to reflect the most relevant files for the task at hand, as GitHub Copilot uses this information to prioritize context.

  • What are some best practices for working with GitHub Copilot?

    -Best practices include describing the goal at the top of the file, being flexible with the probabilistic nature of the tool, providing examples to clarify intent, naming variables and following best practices in coding, and keeping relevant files open to provide context for the tool.

  • Why should comments be left in the code when using GitHub Copilot?

    -Comments should be left in the code because they serve as artifacts of how the code was generated. They can be helpful for future reference and for fine-tuning the model, as they provide a clear record of the user's intent and the structure of the task at hand.

  • How does GitHub Copilot handle the deletion of related records in a Django model?

    -GitHub Copilot can suggest code that follows Django's cascade deletion behavior by default. However, if the user wants to prevent deletion of a parent record if it has children, they need to specify this intent clearly in their comments or code, using specific vocabulary or examples that indicate the desired behavior.

  • What is the role of variable naming in effective communication with GitHub Copilot?

    -Variable naming plays a crucial role in communicating with GitHub Copilot. The tool uses variable names to understand the context and generate suggestions. For example, if a user types 'LinkedIn', Copilot understands that a URL field is likely needed. Therefore, using clear, descriptive variable names can improve the relevance of the suggestions provided by the tool.

  • How can users influence GitHub Copilot to follow specific coding conventions?

    -Users can influence GitHub Copilot to follow specific coding conventions by demonstrating the desired style through examples in the code. As the user codes and provides examples of the desired conventions, Copilot learns from this pattern and adapts its suggestions accordingly.

  • What should a user do if GitHub Copilot does not provide the expected suggestion?

    -If GitHub Copilot does not provide the expected suggestion, the user should be flexible and rephrase or adjust their prompt. They can also provide additional context or examples to clarify their intent, and the tool will adjust its suggestions based on the new information provided.



📢 Introduction to GitHub Copilot

Christopher Harrison introduces himself as a senior developer advocate at GitHub and discusses the importance of understanding GitHub Copilot as a tool. He emphasizes that while it may seem magical, it is essential to recognize its true nature as a tool similar to an IDE. Harrison suggests that users should learn how to maximize the utility of GitHub Copilot by understanding its behind-the-scenes workings and applying tips and tricks to enhance their coding experience.


🔍 Understanding Context and Suggestions in GitHub Copilot

The speaker delves into how GitHub Copilot uses the context of the code and comments to generate suggestions. He clarifies that the entire file, not just the cursor's vicinity, is considered, along with open tabs in the editor, which helps focus the AI's attention. The speaker also advises on managing context by naturally opening files related to the current task, allowing GitHub Copilot to intuitively grasp the relevant information and provide more accurate suggestions.


🛠️ Prompt Crafting for Effective Use of GitHub Copilot

Harrison introduces the concept of 'prompt crafting' as a technique to optimize interactions with GitHub Copilot. He breaks down the process into understanding the context, clarifying intent, ensuring clarity in communication, and specifying details. The speaker illustrates the importance of crafting prompts with precision to guide GitHub Copilot in generating the desired code, using the analogy of ice cream flavors to emphasize the need for specificity.


🚀 Practical Demonstration of GitHub Copilot's Features

The speaker provides a practical demonstration of using GitHub Copilot, showcasing how it suggests code based on comments and the context of open files. He explains how to be specific in comments to guide the AI, such as defining a speaker model with name, email, and LinkedIn fields. The demonstration includes accepting suggestions, modifying them, and showing how GitHub Copilot learns from the user's actions to improve its future suggestions.


📌 Tips for Enhancing GitHub Copilot's Suggestions

Harrison offers tips for improving the quality of GitHub Copilot's suggestions. He advises to name variables properly, follow best practices, and be open to the probabilistic nature of the AI's suggestions. The speaker also emphasizes the importance of providing examples and opening relevant files to guide GitHub Copilot more effectively. He demonstrates how these practices lead to better code suggestions and a more efficient coding experience.


🎯 Final Tips and Closing Remarks

In the final section, the speaker reiterates the importance of flexibility, clear communication, and following best practices when using GitHub Copilot. He provides additional tips, such as naming variables correctly and ensuring that relevant files are open for context. The speaker concludes by encouraging users to 'go with the flow' and adapt to the AI's suggestions, ultimately thanking the audience for their time and participation.



💡GitHub Copilot

GitHub Copilot is an AI-powered tool designed to assist developers by providing code suggestions and completions as they write code. It operates by analyzing the context of the code and comments, and then generating suggestions based on patterns it has learned from vast amounts of code. In the video, the speaker discusses how to maximize the utility of GitHub Copilot by understanding its workings and applying certain strategies, such as prompt crafting and providing clear context.

💡Code Completion

Code completion is the feature of GitHub Copilot that provides suggestions to complete a line of code as a developer types. It helps to increase productivity by reducing the need to look up syntax or recall specific coding patterns. The video emphasizes the importance of understanding how to effectively use this feature by providing clear and specific prompts to guide the AI's suggestions.


In the context of GitHub Copilot, context refers to the information that the tool uses to generate code suggestions. This includes the content of the file being edited, open tabs in the editor, and any comments or code that the developer has written. Providing the right context is crucial for getting accurate and useful suggestions from the tool.

💡Prompt Crafting

Prompt crafting is the process of carefully phrasing comments or code in a way that effectively communicates the developer's intent to GitHub Copilot. This involves being clear, specific, and providing examples to guide the AI in generating the desired code suggestions. The goal is to make the most of the tool's capabilities by helping it understand the task at hand.


Probabilistic, in the context of the video, refers to the nature of AI tools like GitHub Copilot, which operate based on probabilities rather than certainty. This means that the tool may provide different suggestions under the same conditions at different times, as it learns from the data it has been trained on and adapts to new inputs.

💡IDE (Integrated Development Environment)

An Integrated Development Environment (IDE) is a software application that provides a comprehensive set of tools for software development. It typically includes a code editor, a compiler, a debugger, and other utilities that aid in the coding process. In the video, the speaker mentions the IDE in relation to how GitHub Copilot integrates with it to offer code suggestions and completions.


Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. It is used to build web applications quickly and efficiently by providing many pre-built components, an approach known as 'batteries included'. In the video, the speaker uses Django as the framework for their example application, demonstrating how GitHub Copilot can assist in creating models and views for a Django project.

💡Variable Naming

Variable naming refers to the process of assigning names to variables in a program, which should be descriptive and follow best practices to improve code readability and maintainability. Good variable names make it easier for both humans and tools like GitHub Copilot to understand the purpose and usage of the variables within the code.

💡Best Practices

Best practices are standard procedures or techniques that professionals recommend based on research or experience. In software development, these practices aim to improve the quality of the code and the efficiency of the development process. The video discusses several best practices for using GitHub Copilot effectively, such as providing clear context and examples, and following good coding conventions.


Flexibility in the context of the video refers to the developer's ability to adapt and adjust their approach when using GitHub Copilot. Since the AI's suggestions are probabilistic, developers should be prepared to rephrase or modify their prompts to get the desired output. Embracing flexibility allows for a more effective and efficient use of the tool.


GitHub Copilot is a suite of tools primarily focused on code completion.

Context is sent to GitHub Copilot as you type, which includes the entire file you're working on and open tabs in your editor.

GitHub Copilot uses OpenAI to generate suggestions based on the context it receives from your code and comments.

The tool helps keep developers in the zone by providing suggestions that can be accepted, rejected, or modified.

Prompt crafting is introduced as a technique to phrase comments and code effectively to maximize the utility of GitHub Copilot.

Good variable naming and clear comments can help GitHub Copilot provide better and more accurate suggestions.

Being flexible with GitHub Copilot is important as it operates on probabilities and may offer different suggestions under the same conditions.

Providing examples can greatly assist GitHub Copilot in understanding the developer's intent and generating relevant code.

The tool learns from the developer's actions and follows along, adapting to the coding style and conventions used.

Describing the goal at the top of the file can help GitHub Copilot understand the overall objective and provide relevant suggestions.

GitHub Copilot can automatically import relevant models based on open tabs and the context provided.

The tool can help optimize database queries by pre-selecting specific fields to reduce unnecessary roundtrips.

Developers should follow best practices and good coding standards for GitHub Copilot to align with their coding style.

Examples and comments left in the code can serve as documentation and assist in future fine-tuning of the model.

The key takeaway is to go with the flow and be open to the probabilistic nature of GitHub Copilot's suggestions.

Good code begets good code, emphasizing the importance of maintaining coding standards for better AI-generated suggestions.

The presentation concludes by thanking the audience for their time, highlighting the practical applications and insights shared.