Enhancing GitHub Copilot's Efficiency: Providing Meaningful Context
Tags: ai, github, githubcopilot, promptengineering
Published: 2023-06-02 06:45:46

Hello, fellow coders!

Let's will delve into a simple yet crucial aspect of leveraging the power of AI in our coding journey, mainly focusing on GitHub Copilot, an AI-powered coding assistant.

## Contents

- [Why Context Matters in AI Coding](#why-context-matters-in-ai-coding)
- [The Power of Import Statements](#the-power-of-import-statements)
- [More Than Just Imports](#more-than-just-imports)
- [Code example](#code-example)
- [The Human Touch](#the-human-touch)
- [Conclusion](#conclusion)

## Why Context Matters in AI Coding

Just like humans, AI tools like GitHub Copilot need a good amount of context to provide the best possible assistance.

Suppose you ask Copilot to generate code, such as a unit test. It will produce a better result if it understands the broader scenario. That's where 'import statements' come in handy.

## The Power of Import Statements

In most programming languages, such as Dart, Python, or JavaScript, we use import statements to include libraries or modules in our project. These imports allow us to utilize prewritten code, like functions or classes, while keeping our project organized. For instance, if you plan to manipulate data in Python, you might import pandas at the start of your code.

Adding these import statements before asking Copilot to generate code gives the AI a clear idea of what resources it has at hand. So, if you've imported pandas, Copilot knows it can use pandas' functions in the code it generates!

## More Than Just Imports

While imports are a good start, you can provide even more context. For example, naming your variables meaningfully, specifying their types, or writing explicit comments about what you want to do can help Copilot generate more accurate and helpful code.

Imagine if a friend asked you to write a story but gave no details. That's like being asked to find the 'most whimsical seagull' on a beach. But, if they told you they wanted a saga about a seagull who moonlights as a detective solving the mystery of missing french fries (plot twist, the seagull is also the thief), you'd instantly have more direction, wouldn't you? Similarly, the more detail you give Copilot, the better it can assist you.

## Code example

A quick code example will help illustrate these prompting techniques.

```py
# Importing Python's built-in `re` module for regex operations 
# since it will be useful
import re

# We have a text description of our cozy, secluded beach town.
# Perhaps it holds some clues about our missing french fries!
a_cozy_secluded_beach_town: str = """
Welcome to our cozy, secluded beach town 🏖️. With a vibrant 
community of seagulls, it's well known for its delectable 
boardwalk french fries, which tend to mysteriously disappear 
occasionally.
"""

# Now, let's create a function to hunt down mentions of these famous french fries.
def find_french_fries_in_text(text: str) -> str:
    """
    🔎 This function searches for the term 'french fries' 
    in the provided text.
    💬 It prints a message indicating whether the fries 
    have been found or not.
    """
    # Let's ask Copilot to write the regex search for us.
    # Remember, GitHub Copilot, we are searching for 'french fries'.
```

With this setup, you can use GitHub Copilot to generate the following code:

```py
    match = re.search('french fries', text)
    if match:
        print("🍟 We've found the french fries!")
    else:
        rprint("😭 The fries are still missing!")
```

Admittedly, the amount of prompting outweighs the generated code in this example. However, you can imagine a more complex situation where the desired code output isn't as straightforward as finding "french fries" in a description of a beach town. So remember, the more breadcrumbs (or should we say crispy fries?) you leave for Copilot, the better it can help you!

## The Human Touch

As impressive as AI is, remember it's not perfect (and nor are we.) It's important to always review the code that Copilot generates, similarly to how we have peer-review for our code. This way, you help ensure the code is correct, efficient, and secure.

## Conclusion

In summary, GitHub Copilot is a fantastic tool to enhance our coding productivity. However, it is most effective when provided with ample context. And, like any other tool, it should be used with a healthy dose of human judgment and review.

So, next time you use GitHub Copilot, try these tips and see how they can help you code more efficiently!

Keep coding and stay curious!