AI Engineer World's Fair 2024
GitHub Copilot - The World’s Most Widely Adopted AI Developer Tool
Read the talk
GitHub Copilot from code suggestions to repository context
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.
Read the complete timestamped transcript
- 0:00
[upbeat music] So good morning, everybody.
- 0:15
Good morning.
- 0:16
There we go. My name's Dave Burnison. I'm a senior DevOps advocate with GitHub, and I wanna talk today about GitHub Copilot and demo a little bit of everything that Copilot is today because it has...
- 0:33
The capabilities have grown a lot now over the last, uh, two, three years. So how many, how many of you are using GitHub Copilot today?
- 0:43
Okay, looks like, uh, half to two thirds kind of a thing, kind of a ratio or so here. So yeah, as we get started, we can see GitHub Copilot started out just as generating code in the IDE with Copilot Individual.
- 1:01
Then we launched Copilot Business into GA. Uh, shortly after that, year and a half ago, I guess that would be, we launched Copilot Chat. So now not only could you ask Copilot to generate code for you, but you could take somebody's existing code.
- 1:21
Maybe they didn't write very good comments in their code. Shocker, right? Say, "Hey, Copilot, explain that code to me," or, "Help me simplify that code." So many more ways to use GitHub Copilot.
- 1:33
And then just this February, we launched GitHub Copilot Enterprise, being able to not only use Copilot in your IDE of choice, but also right on github.com itself, have Copilot help you generate pull request summaries or tap into information that may be stored in your knowledge bases and ask Copilot questions,
- 1:58
uh, and things like that, and use a lot of the same chat features right there. And I'll also talk about some of the things that, um, we're launching. Uh, right now we've got in beta and, and technical preview and, and such.
- 2:13
So as most of you know, uh, GitHub Copilot is there to be your AI pair programmer, help you, uh, generate code based on comments and things. Now, the thing about Copilot Individual and Copilot Business, it lives and runs as extensions in Visual Studio Code, GitHub Codespaces, which is Visual Studio Code running inside the browser, the JetBrains
- 2:38
IDEs like PyCharm and IntelliJ, and Visual Studio. And a key thing about this is it doesn't actually matter where your code lives, right? The code hopefully lives on GitHub, GitHub Enterprise Cloud, but the code could live in Bitbucket or Azure DevOps, even in Team Foundation Version Control.
- 2:59
It doesn't even have to be Git-based version control, and you can still take advantage of everything that Copilot Business and Copilot Individual have to offer. So I am gonna play through a little, little video of the basics here because there's a couple of things I wanna point out.
- 3:15
This is just a two-minute video.
- 3:17
Let's see how Copilot can make me a more productive developer. I'm using Django Python, which like most programming languages and frameworks, is supported by Copilot. Django is a framework for creating line-of-business applications, and the first step is to create my model classes, which is typically tedious.
- 3:36
What I'm gonna do instead is describe, using natural language, what I need my model to look like. That gray italicized text is Copilot generating the appropriate code. It creates the class definition and the full class across multiple lines of code.
- 3:55
Copilot is also context-aware. It saw the fact that I created a speaker class, and once again goes, "Well, speakers need to do something," and it generates a talk class for me.
- 4:07
That entire class, all of those lines of code, was generated for me automatically by Copilot. There was one thing I didn't necessarily want here, which is it's allowing for speakers and talks all to be deleted.
- 4:24
I wanna modify that, so I go back to Copilot, ask it for a new suggestion, and it generates one. Finally, I wanna add on a code for the talk which matches a particular pattern.
- 4:38
Normally, at this point I would go running off to Stack Overflow to look up how to write this regular expression. Instead, I describe in natural language what that pattern is supposed to look like, and Copilot generates all of the appropriate code for me.
- 4:55
This allows me to stay in the zone and focus in on the more important aspects of writing code.
- 5:04
All right, now I know that's a very basic demo, and most of you who are using Copilot have seen it and used it in this way, but still there's some key things to point out here.
- 5:14
It's called GitHub Copilot. It's not called GitHub Autopilot. You know, this is not gonna replace developers. We still need that person in the middle, and there was a great example here of that.
- 5:27
You know, when it generated, uh, the, the, in the talk class, initially it was allowing speakers to be deleted even when talks existed. So he wiped out that line.
- 5:40
Con- he continued the conversation with Copilot, added that additional comment to say, "Hey, no, don't allow speakers to be deleted when talks exist," and then he was able to get, you know, exactly what he needed in this case.
- 5:56
Now, another thing, there's, there's actually an opportunity here in this, in the, even in this little demo to talk about prompt crafting or prompt engineering You know, when, when he was adding this talk code, he didn't just say, "Add a talk code."
- 6:13
He was more specific, right? He said, "With a format of three letters, a dash, and three numbers." And that w- allowed him to get back the regular expression that he needed.
- 6:26
So the, you know, part of prompt crafting is that specificity in your comments, in your requests and things. But another key element here is he was able to stay in the flow.
- 6:38
He didn't have to leave the IDE and go to find some regular expression documentation or do a, a Google search or anything like that to figure out that syntax.
- 6:49
He got that in a matter of seconds. So you can see, in a second actually, you know, so you can see just how much this can improve productivity and keep you in the flow and things like that.
- 7:01
Now, next we la- ... Oh, so here's some ... At the end, I'll have a link where you can find a lot of these resources, uh, and things. And at some point after this session, I'll put a PDF up there so you've also got all of these, uh, links and things.
- 7:19
But we got several resources now to learn about prompt crafting. You know, this is not something where you need a week-long boot camp or anything like that. Just an hour or two of, you know, w- it'll take less than an hour to understand prompt crafting, but then just kind of playing around with it yourself to get a
- 7:35
better feel, how do you get more accurate suggestions for the context that you're in and everything? And then next, we launched GitHub Copilot Chat. So we went from just typing in comments in code to having a chat panel right inside the IDE.
- 7:53
So now I can do things like, "Hey, give me an overview of the entire solution. Uh, help me write automated tests. Explain this code to me. Help me find and fix the bugs in my code and stuff."
- 8:05
So let's see a little demo of that
- 8:06
Copilot is great for giving you code suggestions inline as you type, but there was no way to easily ask questions or provide additional context until now. Copilot Chat lets you have a much richer pair programming experience right in Visual Studio and Visual Studio Code.
- 8:22
It can suggest tasks based on your code. For example, here I have some code I've inherited with a bunch of regular expressions in it, but it's pretty poorly documented.
- 8:31
Let's ask Copilot what they do. Oh, looks like we have validation for email addresses, phone numbers, and strong passwords. Makes sense. But let's ask for help to make this code a bit more readable for the next person.
- 8:44
I'll type, "Make this code more readable." Not bad, but I'd like some more, so let's ask Copilot to separate out the validation functions and add more comments.
- 8:58
Okay, great. That's much better. The code is now in separate functions with the comments, and the variables have much more meaningful names. This is gonna be a lot easier to maintain going forward, so let's bring it over.
- 9:12
Now let's take a look at some code that isn't working and see if Copilot can help me figure out why. I'll ask Copilot to propose a fix for the bugs in my code.
- 9:24
Now, Copilot's determined by looking at my comment and comparing it to the code that I was treating the data as comma-separated in my code. But in my comment, I was saying it was space-separated.
- 9:36
It's also noticed from the comment that I was returning the values in a different order, and it's adding some error checking for me that it typically sees with this type of code.
- 9:47
Okay, so let's bring this code over and run it. And yep, that works. Brilliant. While we're here, let's ask Copilot to create us some unit tests so we don't accidentally break this code again.
- 9:59
Perfect. Copilot's analyzing the code paths we take in our code and using the context from the comment to generate a set of unit tests for the branches of logic it sees.
- 10:09
It's a great start for us, so we could take this, copy it over into a test function, and then build that out over time. But let me show you one last thing.
- 10:17
With chat functionality right in your editor, it's so much easier to stay focused and on task. You can ask for help about coding right where you are. You can even have a conversation with Copilot to learn more.
- 10:30
Let's ask for an example here. However, we're deliberately constraining the prompt to ensure we only have questions that we detect has an intent around programming. If we stray outside of this, it'll politely decline.
- 10:44
So yeah. While Copilot can help, you're, you're on your own as far as figuring out what's for dinner. So,
- 10:52
so yeah, you can see there he was able to have the code explained to him, generate comments for the code, refactor it, uh, debug code, write unit tests for it, all from working right inside of GitHub Copilot Chat.
- 11:08
So we added a lot more capabilities there. Now, we made a pretty big splash at Microsoft Build last month talking about GitHub Copilot Extensions. So this brings the world's knowledge into the most widely adopted AI developer tool.
- 11:29
And through a growing partner ecosystem, Copilot Extensions are gonna enable developers to build and deploy to the cloud where the, with natural language with their preferred tools and services.
- 11:41
You know, a lot of third parties out there, MongoDB and, and, um, Octopus Deploy, and DataStax and, and, and lots of others understand that GitHub is the place that developers wanna be.
- 11:56
So the developers can stay in the flow now with GitHub Extensions. You can access information and things, uh, from a lot of these other third-party systems directly from GitHub Copilot Chat.
- 12:13
And so you can see we had a, an initial set of partners here, and actually I'm gonna play through one of the little demos here that, so that, that link there, and again, all, this'll all be provided, uh, at the end, uh, takes you to this blog post where we made the announcement, and I'm gonna play the,
- 12:35
uh, Octopus Deploy demo. [upbeat music]
- 12:42
The Octopus extension for GitHub Copilot allows developers to maintain a state of flow by querying the state of their deployments from the same tools they use to write their code.
- 12:52
In this example, we have a Node.js web application. We will commit and push changes to our Git repository and track those changes through the GitHub Copilot Chat interface. We'll make a small change to the index page, save those changes, and then push those to our repository.
- 13:08
Once pushed, the GitHub actions workflow will trigger a build and initiate a deployment to Octopus Deploy. We can then track the deployment through the Octopus extension for GitHub Copilot.
- 13:19
We can view the high-level status of deployments to all environments with a text-based dashboard.
- 13:25
So you can see he asked there, "Hey Octopus Deploy, show me the dashboard." And again, without breaking the flow, right inside of GitHub Copilot Chat, he's getting this information to see, okay, have the changes been deployed all the way to production yet?
- 13:41
Let's look at the versions and see. No, the latest version is not yet in production. So getting all of this valuable information without leaving, uh, your flow.
- 13:53
Useful items in the deployment logs, like URLs, can be extracted. We can use the comprehension ca-
- 13:59
Actually, in the interest of time, we'll ju- we'll just stop there 'cause there's definitely other things that I want to, uh, cover. But yeah, you c- you can see that full demo if you go to github.blog and look for the Copilot Extensions blog post, and we'll have links to that, uh, available, uh, later.
- 14:18
So in February, we launched GitHub Copilot Enterprise. So now, not only are you able to do all of this inside of your IDE, but bringing it to GitHub Enterprise Cloud and adding new capabilities, like building a Bing search right into, uh, the chat and everything, be-
- 14:43
being able to tap into knowledge bases of information that you have, uh, and everything. So for this, I'm actually gonna do a live demo, if I can find... Here we go.
- 14:59
So here I am on GitHub. Uh, let me reload this.
- 15:11
Get logged in here. There we go. So I'm on [REDACTED:url], you know, where, where we have our repositories and everything, and you can see here now, we actually have, uh, the chat available to us right inside of github.com.
- 15:31
So I can come in here, and I can ask general questions. Like let's say I'm starting a new project and I know we wanna put feature flags into our solution.
- 15:43
So I could say, "How do I..." Whoops. If I type my little shortcut right here, "How do I get started with feature flags here at GitHub?" Now, if I don't specify that I wanna search our knowledge bases, I'm gonna get a very generic answer.
- 16:01
Choose a feature flag library, integrate that library, uh, and, and, and such. But now we have the capability to add in your own knowledge bases. So knowledge bases are collections of markdown files that are stored right inside of your repos themselves.
- 16:23
So if I say, "Hey, I, I want as context to look at the GitHub engineering documentation," and then I ask that same,
- 16:35
ask that same... Well, yeah, I should br- pulled out my other keyboard. This keyboard's a little sticky. Come on now.
- 16:53
There we go. "How do I get started using feature flags here at GitHub?" Now I'm gonna see a different answer with more specifics based on GitHub Engineering's, uh, documentation and everything.
- 17:08
So, and actually, this is still somewhat generic. It's, it's, it, but it is referencing documentation from our, uh, from our knowledge base. So I'm gonna do this again, 'cause I typically get a little different answer there.
- 17:31
There we go. Now my shortcut's working. There we go. This is more what I was hoping to see. So now it's giving me specifics. You know, it's saying, "Hey, we use the Flipper fr- Framework here internally."
- 17:49
So it's showing me specifics about here's what I need to actually put in my code to get started with feature flags.
- 17:57
So that's using knowledge bases. All right, now I'm gonna flip over to another environment. This environment uses enterprise-managed users, so let me do a refresh here, 'cause I'll have to re-log in.
- 18:12
There we go So yeah, I have a separate identity under enterprise-managed users, 'cause now this is for everything internal. You know, this is a walled garden to ensure that I, nobody can accidentally take a private repository and make it public, uh, and things like that.
- 18:33
So a lot of the security that enterprises are looking for. But in this case I have... This is, this is, uh, Parts Unlimited, uh, website. So if I open up,
- 18:48
and if I open up the website, it's a site for selling auto parts, right? And how many recognize Parts Unlimited?
- 18:58
Anybody ever read The Phoenix Project by Gene Kim? Okay. Yeah. Parts Unlimited was the fictitional company that was in that book. But anyway, um, yeah. So Parts Unlimited started out as a brick and mortar store in the Washington area.
- 19:17
So right now sales tax is kinda hard-coded to sales tax for Washington, but that, that's not what we want. Now that we're an e-commerce site, we have to be able to calculate sales tax wherever the buyer lives, right?
- 19:33
So I'm gonna bring up GitHub Copilot Chat here, Enterprise Chat, and ask where...
- 19:43
Come on, if my keys will cooperate. Where in this repo do we have code that calculates sales tax?
- 19:54
So it'll take a moment, but it's looking... So something you,
- 19:59
something to notice here is it's saying, "This repository has been indexed for improved understanding and accuracy." So with GitHub Copilot Enterprise, you go through and pick what repos you want to index for these types of searches.
- 20:14
So it's telling me, yes, there's the default shipping tax calculator CS file that includes this calculate tax function. And I'm actually going... Oh, come on.
- 20:29
Well, there we go. I'm gonna copy calculate tax there. But then it's also showing me who the other callers are of calculate tax. So I, I get a good picture, you know, of how this is, uh, working throughout the entire solution, uh, or repository.
- 20:48
So we can open that file up and we'll see, okay, here's calculate tax and yeah, in fact it is hard-coded right now to certain tax rates. So 7.5% sales tax for state of Washington.
- 21:05
That might even be out of date. Um, but now I'm gonna ask Copilot, this is where kinda like the, the Bing, built-in Bing search comes into play. Are there any public APIs out there that I can use to calculate sales tax in any postal code?
- 21:23
So now it's gonna come back with, uh, a, a list of APIs that I could use here.
- 21:32
Free sales tax API, tax APIs, uh, Sales Tax USA,
- 21:39
Avalara, et cetera. So now I wanna leverage GitHub Copilot Enterprise to say, "Hey, what would that calculate tax function look like if I wanted to use, let's say, the Aval- Avalara, uh, API?"
- 21:57
So the... But what I wanna do is first kinda set the context for Copilot. So I'm gonna say...
- 22:05
Now did that paste? Nope, doesn't look like it. Uh, see if I can spell it right. Calcu...
- 22:13
And see if my keyboard will cooperate. There we go. Calculate tax.
- 22:28
So now I'm telling Copilot that's the context that I'm talking about. So now I will say,
- 22:39
"How would this, how would I update this code to use
- 22:47
Avalara API?" All right, and you can see this, this is live demo responding in real time.
- 23:10
So now if we look here at the, the differences, I'll kinda z- try to zoom in here. Yeah, you can see where we were calculating, you know, the tax rate here hard-coded.
- 23:24
Now it is showing me how to... It's doing the same thing. It's still returning taxable times tax rate and all that, but here it is using that Avalara API and everything instead.
- 23:43
Now another key thing here, if I scroll down and look at some of the additional explanation it gave me, said, "Hey, there's one possible vulnerability here. You're, y- when you're working with an API like that, you're gonna have an API key that you have to store."
- 24:01
So it's telling me, "Make sure you do not hard-code that API key in your code. Make sure you store that in HashiCorp Vault or Azure Key Vault or GitHub Secrets or, or something like that."
- 24:15
So it's helping you with some of those security best practices, uh, as well along the way.
- 24:25
Couple more things and then kinda, uh, about five, six minutes left. So yeah, there's demos out there on YouTube for GitHub Copilot Enterprise and everything also. Oh, yeah, so that was the chat in the repository.
- 24:41
One other thing I wanna show you is
- 24:46
we, we have it now so that when we're looking at pull requests. So here's, here's an existing pull request. And I was kinda lazy when I first created this pull request.
- 24:58
I've got GitHub integrated with Azure Boards, so I referred to the Azure Boards user stories and, uh, work i- uh, tasks and stuff that I'm completing as part of this, but I didn't provide any other kind of a description.
- 25:12
Well, now with GitHub Copilot Chat, well, I can edit this, and you'll see we have the Copilot icon in here as well. So I could come in here and say, "Hey, Copilot,
- 25:28
generate a summary for me." So c- how many times do developers write nice summaries that anybody could read? You know, getting ready to c- review the code, uh, and everything.
- 25:41
Yeah, [chuckles] not very, not very often. But with Copilot, it's gonna look at all the changes that you've made, provide a nice summary paragraph, and then file by file, list out all of the changes.
- 25:54
There we go. Just took a few seconds.
- 25:58
So now I have a nice summary here, and then you can see, yeah, file by file, it's listing out each change in each file kind of a thing. So, and it makes it easy for developers then to provide a lot of information and, uh, you know, not have to spend a lot of time doing that.
- 26:19
Now, the other thing that you can do here when you're looking at a pull request, and we, we, we even have more coming with this.
- 26:28
Okay. Come on, internet, you can do it. There we go.
- 26:33
So I can go in and look at one of my changes. I'm gonna skip over this one for the moment. Yeah, let me just look at this change, and I can come in...
- 26:44
Whoops, that's not the- what I want. Here we go. You'll see the Copilot icon here too. Now, this is obviously a very simple change. We're just doing some rebranding of the website here.
- 26:54
But if this were more complex, you know, I could say Explain and have, uh, Copilot explain the change to me. So yeah, th- in this case, it's just that simple changing from Fabrikam to Contoso.
- 27:08
But if this were more complex, you know, the, the reviewer can look at this, look back at that user story and say, "Okay, by looking at the user story, I know what the intent was.
- 27:19
Now, does Copilot agree that the, what's actually implemented matches that intent?"
- 27:25
So that's another way to use Copilot Enterprise.
- 27:30
So we talked about the chat. We talked about searching the knowledge bases,
- 27:37
pull request summaries, and such. This, this works with... Copilot works with any language. The large language models have been built off of the vast majority of the open source code that's out there.
- 27:50
There's even COBOL code out there. So I found a COBOL, uh, a repository out there that has COBOL examples in it. So I said, "Hey, what, what does this code do?"
- 28:07
And GitHub Copilot was able to provide an explanation for me. You know, simple Fibonacci sequence. So you could then next prompt and say, "Hey, how would, what would that code look like in Java?
- 28:21
What would that code look like in C#?" Or something. So use this as a way to modernize your, your, uh, COBOL and other code. The next one is Copilot Workspace.
- 28:34
Ah, I ran out of time. I actually don't... Uh, let's see. Let's go...
- 28:43
All right, let me do this. I'm not sure if there's anybody coming in the room right away here at 11:15. Let me do this first, just in case there is somebody coming in next.
- 28:53
So if you wanna take a screenshot of this, uh,
- 28:59
URL, we have a page out there that has, I don't know, 15, 20 links to additional training, some of our key blog posts, and things like that that we've recently had.
- 29:14
And yeah, this will be dynamic. As more and more things come in, we'll, um, we'll add to that and everything. Uh, also, yes, we'll be at the GitHub booth, uh, where we can a- answer additional questions and, and things like that.
- 29:33
So yep, I see people moving on. Thank you very much for your time. So yeah, stop by the Microsoft booth and we'll show you Copilot Workspace. [outro music]