AI Engineer World's Fair 2024
GitHub Copilot - The World’s Most Widely Adopted AI Developer Tool
Loading slides…
Read the talk
GitHub Copilot - The World’s Most Widely Adopted AI Developer Tool
A Django deletion rule, undocumented validators, deployment status, and a sales-tax refactor show how Copilot’s usefulness depends on the context developers supply and the decisions they retain.
From a talk by Dave Burnison
Before you start: Familiarity with code editors, Git pull requests, and basic database relationships will help you follow the examples.
Getting help with code you did not write
What can you do with somebody else’s code when its comments do not explain how it works? Inline completion helps write the next lines, but understanding or simplifying an existing implementation calls for a conversation. Dave Burnison, a senior DevOps advocate at GitHub, introduces that shift through Copilot’s progression: Individual supplied code generation in the editor, Business followed, and Chat added a way to ask questions about existing code. Enterprise, launched in February 2024, extended assistance to GitHub itself, including pull request summaries and organizational knowledge.
The editor integration and repository host are separate concerns. In this product lineup, Individual and Business run through extensions in Visual Studio Code, browser-based GitHub Codespaces, JetBrains IDEs such as PyCharm and IntelliJ, and Visual Studio. The code can live on GitHub, Bitbucket, Azure DevOps, or even non-Git Team Foundation Version Control. Using Copilot in the editor does not require moving the repository to GitHub.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A generated model still needs a deletion policy
The first recorded demonstration starts with a tedious Django task: defining model classes for a line-of-business application. A natural-language description produces a multiline class suggestion, displayed as gray italicized text. Once a Speaker class exists, Copilot uses that context to suggest a Talk class. But the generated relationship permits deletion behavior the developer does not want. The developer removes the unwanted line and asks for another suggestion that protects speakers while their talks exist.
The corrected relationship uses models.PROTECT. A minimal Django expression of that requirement is:
python
from django.db import models
class Speaker(models.Model):
name = models.CharField(max_length=200)
class Talk(models.Model):
title = models.CharField(max_length=200)
speaker = models.ForeignKey(Speaker, on_delete=models.PROTECT)
The important choice is the relationship’s deletion policy: a referenced speaker cannot be deleted while a talk still points to it. Context helped generate the relationship; the developer supplied the business rule that made it appropriate.
Next, the developer describes a talk-code pattern and receives regular-expression code without leaving the IDE to look up the syntax. Burnison returns to the deletion correction afterward because it captures the division of responsibility: generated code is a proposal the developer must evaluate. The developer notices the unwanted behavior, continues the conversation, and gets a revised suggestion.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give the generator an observable requirement
The talk-code request is more useful than simply asking to add a code field: it specifies three letters, a dash, and three numbers. That gives the generator a concrete constraint to translate into syntax. For an ASCII interpretation of that format, the validation can be expressed directly:
python
import re
def is_valid_talk_code(value: str) -> bool:
return re.fullmatch(r"[A-Za-z]{3}-[0-9]{3}", value) is not None
The requirement determines the structure; fullmatch ensures the whole value follows it. The useful prompting move is to state the behavior precisely enough that the resulting code can be checked.
That specificity also avoids a context switch to search results or regular-expression documentation. Burnison describes obtaining the expression in about a second in this example. His practical advice is to learn the basics of prompt crafting, then experiment with requests in your own context; he estimates less than an hour for the basics, followed by hands-on practice rather than a week-long boot camp. He also points to learning resources and promises a PDF of the session’s links.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Explain, restructure, then test
Chat makes the editor a place to ask for a solution overview, explanations, bug fixes, and automated tests. In the next recorded demonstration, using Visual Studio and Visual Studio Code, the starting point is inherited code containing poorly documented regular expressions. Copilot identifies validators for email addresses, phone numbers, and strong passwords. The developer first asks for more readable code, then makes the request more specific: separate the validation functions and add comments. The resulting suggestion has distinct functions, clearer variable names, and explanations the next maintainer can use.
The debugging example then exposes a mismatch between stated intent and implementation:
| Concern | Comment’s intent | Existing implementation |
|---|---|---|
| Input delimiter | Space-separated data | Comma-separated parsing |
| Return values | A specified order | A different order |
Copilot compares the comments with the code, proposes corrections, and adds error checking. The demonstrator copies the suggested code into the editor and runs it successfully. Here, comments provide a second description of the intended behavior against which the implementation can be examined.
Only after fixing and running the code does the developer ask for unit tests. Copilot uses the visible branches and the comment context to generate cases. The demonstrator treats these as a starting point to copy into a test function and expand over time. The recorded Chat also deliberately restricts answers to detected programming intent, declining unrelated requests—the basis for Burnison’s joke that dinner remains the developer’s problem. Explanation, refactoring, debugging, and initial test generation all happen without leaving the editor.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Ask whether the change reached production
The next expansion brings third-party services into the conversation. Burnison introduces Copilot Extensions, announced at Microsoft Build the preceding month, with partners including MongoDB, Octopus Deploy, and DataStax. The direction is natural-language access to the tools used to build and deploy applications, with service information available inside Copilot Chat. This was the historical limited-beta offering: GitHub later announced retirement of GitHub App-based Copilot Extensions for November 10, 2025, a change that did not cover client-side VS Code extensions.
The Octopus Deploy recording follows a concrete delivery sequence:
- Edit the index page of a Node.js web application.
- Save, commit, and push the change to its Git repository.
- Let the push trigger a GitHub Actions build and initiate an Octopus deployment.
- Ask the Octopus extension for a dashboard inside Copilot Chat.
The response is a text-based view of deployment status across environments. Comparing the versions answers the operational question: the latest version has not yet reached production. Chat exposes the deployment system’s state; it does not make a successful push equivalent to a completed production release.
The recording also introduces extracting useful items such as URLs from deployment logs. Burnison stops the clip before the next capability is explained and directs viewers to the full Octopus demonstration in the Copilot Extensions announcement.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Make “here at GitHub” mean something
Enterprise brings Chat to GitHub Enterprise Cloud, with organizational knowledge and built-in Bing search, which was public beta at Enterprise’s launch. In the live demonstration, Burnison opens Chat in GitHub’s organization and asks how to get started with feature flags at GitHub. Without explicitly selecting organizational context, the response is generic: choose a feature-flag library and integrate it. The words “here at GitHub” alone do not supply the internal engineering guidance.
The demonstrated knowledge bases are collections of Markdown files stored in repositories. Burnison attaches GitHub Engineering documentation as context before repeating the question. This is the historical knowledge-base interface; GitHub’s later retirement notice specified November 1, 2025, with Copilot Spaces as its replacement.
Selecting documentation does not immediately produce the answer Burnison expects. The first grounded response cites the knowledge base but still looks somewhat generic, so he repeats the request. The next response identifies Flipper as the framework used internally and shows code for getting started. The progression matters: first obtain relevant context, then inspect whether the answer actually uses it to resolve the organization-specific question.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Find the business assumption inside the repository
Burnison switches to an environment with enterprise-managed users and signs in with a separate identity. He describes it as a walled garden intended to prevent mistakes such as making an internal private repository public. Inside it, the example application is Parts Unlimited, an auto-parts storefront named after the fictional company in Gene Kim’s The Phoenix Project. Its business has moved from a Washington brick-and-mortar store to e-commerce, but its tax calculation still assumes the old geography. It now needs to account for where the buyer lives.
The first task is discovery, not rewriting: ask where the repository calculates sales tax. The interface indicates that the repository has been indexed; Burnison explains that Enterprise users choose repositories to index for these searches. Copilot locates CalculateTax in DefaultShippingTaxCalculator.cs and identifies its callers, giving both an entry point and a view of where the function participates in the application. Opening the file confirms the assumption. The demo hard-codes a 7.5% Washington sales-tax rate, which Burnison immediately says may be out of date.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn repository context into an integration proposal
With the existing calculation located, Burnison asks for public APIs that calculate sales tax by postal code. Built-in Bing search supplies options including Free Sales Tax API, Sales Tax USA, and Avalara. He chooses Avalara for the next question, first setting CalculateTax as the code context and then asking how to update it to use that API. The sequence combines external discovery with a specific implementation target.
The generated proposal changes the source of the tax rate while retaining the existing calculation of taxable amount multiplied by rate. Burnison compares the hard-coded version with the suggested API-based version on screen. This is a displayed integration proposal, not an executed or deployed Avalara integration.
The explanation also identifies a new responsibility introduced by the integration: protecting the API key. Copilot warns against hard-coding it and names HashiCorp Vault, Azure Key Vault, and GitHub Secrets as storage options. Replacing a constant with a service call changes more than the calculation’s inputs; it introduces a credential that must be managed outside the source code.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Describe the change, then examine its intent
After mentioning additional Enterprise demonstrations on YouTube, Burnison opens an existing pull request. GitHub’s Azure Boards integration already links the user stories and tasks, but the description contains little else. From the description editor’s Copilot icon, he requests a summary. Copilot uses the changes to generate an overview paragraph followed by a file-by-file account. Burnison reports that the pull request summary took a few seconds in this live example. The result gives a reviewer more to work with than task references alone.
The next action works from the reviewer’s side. While inspecting a changed file, Burnison uses Copilot’s Explain action. The actual diff is simple: a website rebrand from Fabrikam to Contoso. For a more complex change, he proposes reading the explanation alongside the Azure Boards user story and asking whether the implementation matches its intent. The demonstrated action explains a diff; the reviewer still has to judge whether the change fulfills the requirement.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Start modernization with understanding
The final technical example moves to COBOL. Burnison describes broad language support and attributes it to training on open-source code, then gives a concrete example: Copilot explains a COBOL program as a simple Fibonacci sequence. He suggests following that explanation with a request for an equivalent in Java or C#. The demonstrated result is comprehension; translation is a proposed next step, not a validated migration. His broad language claim should not be read as equal reliability across languages: GitHub’s current guidance warns that results can be weaker for less common languages.
Copilot Workspace is the intended next topic, but time runs out before a demonstration. Burnison instead closes with a resource page containing training material and recent blog posts, with additions planned over time. He invites questions at the GitHub booth and, in the final invitation, directs viewers to the Microsoft booth for a Workspace demonstration. The recording ends with that handoff rather than a Workspace walkthrough or audience Q&A.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Ruby and Rails feature flags with installation instructions and examples for enabling features by user, group or percentage.
Updates since the talk
- Copilot Chat capabilities and limitationsDocumentation
Current guidance on contextual assistance, generated tests, language coverage, pull request summaries and reviewing generated output.
Full transcript
Loading transcript…